C++类对象内存模型与成员函数调用分析

圆整到 4 的倍数个字节，所以一共就是 12 bytes 了，对于 child 类，由于它仅仅引入了一个 std::string，所以在 12 的基础上加上 std::string 的 4 字节就是 16 字节了。 在单继承不考虑多态的情况下，数据 成员的 布局是 很简单 的。 用一个 图来说 明，如 下。
对于静态数据成员，如果在 static_mem.cpp 中加入下面一条语句： std::cout<<”Size of class memtest is : ”<<sizeof(memtest)<<”/n”;
我们得到的输出是：12。也就是说，class 的大小仅仅是一个 int 和一个 double 所占用的内存之和。这很简单，也很明显，静态数据成员没有存储在类实例的地址空间中，它被 C++编译器弄到外面去了也就是程序的 data segment 中，因为静态数据成员不在类的实例当中，所以也就不需要 this 指针的帮忙了。
无论是 istream 还是 ostream 都含有一个 ios 类型的子对象。然而在 iostream 的对象布局中，我们只需要一个这样的 ios 子对象就可以了，由此，新语法虚拟继承就引
入了。
虚拟继承中，关于对象的数据成员内存布局问题有多种策略，在 Inside the C++ Object Model 中提出了三种流行的策略，而且 Lipp man 写此书的时候距今天已经很遥远了，现代 编译器到底如何实现我也讲不太清楚，等哪天去翻翻 GCC 的实现手册再论，今天先前一笔债在这。
1、C++类数据成员的内存模型 1.1 无继承情况
实验最能说明问题了，首先考虑下面一个简单的程序 1：
#include<iostream> class memtest { public:
memtest(int _a, double _b) : a(_a), b(_b) {} inline void print_addr(){
那么，对应的内存布局就是图 4 所示。
1.3 虚继承
多重继承的一个语意上的副作用就是它必须支持某种形式的共享子对象继承，所谓共享，其实就是环形继承链问题。最经典的例子就是标准库本身的 iostream 继承族。
class ios{...}; class istream : public ios {...}; class ostream : public ios {...}; class iostream : public istream, public ostream {...};
// C++ code struct foo{ public:
int get_data() const{ return data; } void set_data(int _data){ data = _data;} private: int data; };
foo f(); int d = f.get_data();
浩繁的代码里黑客们的神迹了。这个 sizeof 的信息就告诉了系统你应该拿几个(连续)地址上的字节返回给我。例如，int* pInt 的值为 0xbfadfc64，那么系统根据 int*这
个指针的类型，就知道应该把从 0xbfadfc64 到 0xbfadfc68 的这一段内存上的数据取出来返回。
回到 C++的话题上，假设下面的代码段 6，其实就是前面代码段 3，为了阅读的方便 copy 过来一下。
// ... protected:
std::string twitter_url; // 儿子时髦，有推号 };
这里 sizeof(father)和 sizeof(child)分别是 12 和 16(GCC 4.4.5)。先看 sizeof(father)吧，int 占 4 bytes，char 占 1byte，std::string 再占 4 bytes，系统再将 char
多重继承一般都被公认为 C++复杂性的证据之一，但是就数据成员而言，其实也很简单，多重继承的复杂性主要是指针类型转换与环形继承链的问题，这些内容都将在第二部 分讲述。 假设有下面三个类，如下面的程序段 4 所示，继承结构关系如图：
class A{ public:
// ... protected:
int a; double b; }; class B{ public: // ... protected: char c; }; class C : public A, public B public: // ... protected: float f; };
class father { public:
// constructors destructor // access functions // operations protected: int age; char sex; std::string phone_number; };
class child : public father { public:
C++类对象内存模型与成员函数调用分析
C++类对象内存模型是一个比较抓狂的问题，主要是 C++特性太多了，所以必须建立一个清晰的分析层次。一般而言，讲到 C++对象，都比较容易反应到以下这个图表：
这篇文章，就以这个表格作为分析和 行文的 策略的 纵向指 导； 横向上 ，兼以 考虑无 继承、 单继承 、多重 继承及 虚拟继承 四方面 情况， 这样一 来，思 维层次 应该算 是比较 清晰 了。
foo f; f.data = 8; foo* pF = &f; int d = get_foo_data(pF);
在 C 程序中，我们要实现同样的功能，必须是要往函数的参数列表中压入一个指针作为实参。实际上 C++在处理非静态数据成员的时候也是这样的， C++必须借助一个直接的 或暗喻的实例指针来读写这些数据，这个指针，就是大名鼎鼎的 this 指针。有了 this 指针，当我们要读写某个数据时，就可以借助一个简单的指针运算，即 this 指针的地址加上 该数据成员的偏移量，就可以实现读写了。这个偏移量由 C++编译器为我们计算出来。
可以发现以下几点：
1. 非静态数据成员 a 的存储地址就是从类的实例在内存中的地址中(本例中均为 0xbfadfc64)开始的，之后的 doubleb 也紧随其后，在内存中连续存储；
2. 对于静态数据成员 c，则出现在了一个很“莫名其妙”的地址 0x804a028 上，与类的实例的地址看上去那是八竿子打不着；
tu = pC1->twitter_url; 对于(*)行，其实原因就是我们前面所说的，指针类型中包含了一个类似于 sizeof 的信息，或者其他的辅助信息，对比图 5，我们可以这样子想，一个 father 类型 object 嵌套在 了一个 child 类型的 object 里面，因为指针类型有一个 sizeof 的信息，这个信息决定了一个 pF 类型的指针只能取到 12 个连续字节的内容，(*)试图访问到这个 12 个字节之外的 内容，当然也就要报错了。 我得说明一句，这样子想只是一种理 解上的 自由 (而且 我认为 这样理 解，从 结论和 效果上 讲是靠 谱的) ，到 底是不 是这样子 ，我还 并没有 调查清 楚。
std::cout<<"Address of a and b is:/n/t/t"<<&a<<"/n/t/t" <<&b<<"/n"; } inline void print_sta_mem(){
std::cout<<"Address of static member c is:/n/t/t"<<&c<<"/n"; } private: int a; double b; static int c; }; int memtest::c = 8; int main() { memtest m(1,1.0); std::cout<<"Address of m is : /n/t/t"<< &m<<"/n"; m.print_addr(); m.print_sta_mem(); return 0; } 在 GCC4.4.5 下编译，运行，结果如下：
如果要你用 C 你会怎么实现呢？
// C code struct foo{
int data; }; int get_foo_data(const foo* pFoo){ return pFoo->data;} void set_foo_data(foo* pFoo, int _data){ pFoo->data = _data;}
其实不做这个测试，关于 C++数据成员存储的问题也都是 C++ Programmer 的常识，对于非静态数据成员，一般编译器都是按其在类中声明的顺序存储，而且数据成员的起始地 址就是类得实例在内存中的起始地址，这个在上面的测试中已经很明显了。对非静态数据成员的读写，我们可以这样想，其实 C++程序完全可以转换成对应的 C 程序来编写， 有一些 C++编译器编译 C++程序时就是这样做的。对非静态数据成员的读写也可以借助这个等价的 C 程序来理解。考虑下面代码段 2：
class father { public:
// constructors destructor // access functions // operations protected: int age; char sex; std::string phone_number; };