浅谈C++对象内存布局

http://yalung929.blog.163.com/blog/static/20389822520123910561654/

最简单的类

先从一个简单的类开始吧。如下，此简单类，非常简单，两个int成员，通过printf很容易了解到它的内存布局，本质就是一个C结构体，两个成员依次排列。

对象：|成员1 | 成员2 |

   1:  #include <cstdio>

   2:  class Class0

   3:  {

   4:  public:

   5:  int member1;

   6:  int member2;

   7:  };

   8:  int main()

   9:  {

  10:  Class0 c;

  11:  printf("object addr=0x%lx\nmember1 addr=0x%lx\nmember2 addr=0x%lx\n",

  12:  &c, &c.member1, &c.member2);

  13:  return 0;

  14:  }

# ./a.out

object addr=0x7fffea480d70

member1 addr=0x7fffea480d70 //类成员1

member2 addr=0x7fffea480d74 //类成员2

成员函数

那么我们增加点复杂性，添加一个成员函数。

   1:  #include <cstdio>

   2:  class Class1

   3:  {

   4:  public:

   5:     int member1;

   6:     int member2;

   7:     void function1() { printf("Class1::function1"); }

   8:  };

   9:  int main()

  10:  {

  11:     Class1 c;

  12:     printf("object    addr=0x%lx\n", &c);

  13:     printf("member1   addr=0x%lx\n", &c.member1);

  14:     printf("member1   addr=0x%lx\n", &c.member2);

  15:     printf("function1 addr=0x%lx\n", &Class1::function1);

  16:     return 0;

  17:  }

./a.out

object  addr =0x7fff6805bf90

member1 addr=0x7fff6805bf90

member1 addr=0x7fff6805bf94

function1 addr=0x4006a0//成员函数地址在代码段。----这简直是废话，不在代码段没法玩啊。

对象： | 成员1 | 成员2 |
代码段： |成员函数|
我们看到，对象数据成员的布局并没有变化，但是函数成员的地址跑到十万八千里之外了。为什么？很简单，因为函数是代码，放在了代码段。这也是我们通过Class1::function1来取值，而不是c.function1的原因。从这里可以看出，类的函数成员本质就是一个C全局函数，那么如果函数内访问类的非静态数据成员，如何动态的获取成员地址？编译器是这样做的：
1. 编译器生成function1()的指令时，如果遇到了访问对象的数据成员，比如member1，就从一个约定的位置（比如一个寄存器）获取对象的首地址（其实就是this指针），然后加上偏移（这个是编译时期可以确定的），也就找到了member1对应的内存位置，就可以访问member1了。
2. 编译器生成c.function1()对应的指令时，把c的地址，放到了上述约定的位置。
简单来说，c.function1() 等价于function1(c), c是作为隐含参数传递给function1了。

虚函数

好了搞清楚了成员函数的工作机制，我们再进一步分析，如下例子，有了继承，并且基类成员函数是一个虚函数。派生类重载了它。

   1:  #include <cstdio>

   2:  class Base

   3:  {

   4:  public:

   5:     virtual void function() { printf("Base::function1\n"); }

   6:  };

   7:  class Derived : public Base

   8:  {

   9:  public:

  10:     void function() { printf("Derived::function1\n"); }

  11:  };

  12:  int main()

  13:  {

  14:     printf("Base::function addr    = 0x%lx\n", &Base::function);

  15:     printf("Derived::function addr = 0x%lx\n", &Derived::function);

  16:     Base* pb = new Derived();

  17:     pb->function();

  18:     return 0;

  19:  }

./a.out

Base::function addr    = 0x1

Derived::function addr = 0x1

Derived::function1

我们看看它的输出，成员函数的地址是0x1，这明显不是一个合法的地址，更像是一个偏移量，为什么？暂且先不管为什么地址是0x1，不妨先分析下，下面这两行代码是如何工作的。

   1:  Base* pb = new Derived();

   2:  pb->function();

派生类指针赋给了基类指针，调用function，但执行还是派生类的function，这就是多态了。那么对于 pb->function(); 这个语句来说，编译器是不能够在编译时期决定调用哪个function的。因为它并不知道pb这个指针是通过派生类转化而来。大家会说，我们上面的语句不是告诉它了吗？这个肯定不行，编译器不能做这个上下文关联，你要是通过函数参数传递过来，赋值的地方离这条语句很远甚至都不在一个源文件里面怎么办？所以这个决定调用哪个function的信息，必须保存在内存里面，运行期间就可以执行正确的函数。那么具体保存在哪里？如何工作的？gcc是这样做的：
1. 申请一段内存，存放虚函数的地址。就是一些书上所说的虚表。本质就是一个数组。
2. 在对象的起始位置，存放虚表首地址，而不是像普通类对象那样存放第一个非静态数据成员。
3. pb->function(); 这条语句执行时，编译器知道function是一个虚函数（我们声明了virtual关键字），那么就会采用虚函数的调用方法，首先根据pb找到虚表的首地址，然后加上一个偏移量，因为是编译器把function这个函数的地址放到虚表内的，所以它知道偏移量。我们通过下面这段代码验证这点：

   1:  #include <cstdio>

   2:  class Base

   3:  {

   4:  public:

   5:     virtual void function1() { printf("Base::function1\n"); }

   6:     virtual void function2() { printf("Base::function2\n"); }

   7:  };

   8:  int main()

   9:  {

  10:     printf("Base::function addr    = 0x%lx\n", &Base::function1);

  11:     printf("Base::function addr    = 0x%lx\n", &Base::function2);

  12:     Base* pb = new Base;

  13:     long* vtl = *(long**)pb;

  14:     printf("0x%lx\n", *(vtl));

  15:     printf("0x%lx\n", *(vtl + 1));

  16:     return 0;

  17:  }

# ./a.out

Base::function addr    = 0x1

Base::function addr    = 0x9

0x40082a

0x400812

# nm a.out | grep function

000000000040082a W _ZN4Base9function1Ev

0000000000400812 W _ZN4Base9function2Ev

# c++filt _ZN4Base9function1Ev

Base::function1()

# c++filt _ZN4Base9function2Ev

Base::function2()

对象：    | 虚表地址|成员1 | 成员2 |
虚表：    |虚函数1的地址|虚函数2的地址|
代码段： |虚函数1|虚函数2|
1. 通过long* vtl = *(long**)pb; 获取pb对象第一个成员的内容，我们拿到了虚表的首地址vtl。
2. printf("0x%lx\n", *(vtl)); 访问虚表的第一个元素，打印的是0x40082a，恰好对应我们通过nm查看到的Base::function1的函数地址000000000040082a 。
3. printf("0x%lx\n", *(vtl + 1)); 访问虚表的第二个元素，打印的是0x400812，恰好对应我们通过nm查看到的Base::function2的函数地址0000000000400812 。
那么&Base::function1是0x1，&Base::function2是0x9，何解？其实怎么解读，完全看编译器心情。。。从我们的实验结果来看，gcc是把它解读成了虚表偏移量+1。编译器也是可以解读为函数的真实地址的。
所谓多态，也就是这么回事儿，其逻辑并不复杂，只是C++"封装"了细节，只给我们展示了它的强大形象，让我们觉得多态好神奇啊，其实丫的，本质就是函数指针，就是地址而已，因为地址才是CPU理解的东西。懂得这点，就知道内核里到处都是多态，同样是一个read操作，read不同的文件，执行不同的函数。。。内核就是在文件对象（C结构体）里，保存了函数指针，不同的文件系统注册不同的函数指针。内核是各种编程技术、思想的集大成者，OO思想随处可见。

单继承

扯远了，我们还是继续回到C++，多态背后的内存布局讲完了，我们再进一步分析类继承的。当派生类继承了基类，也就拥有了基类的数据成员，那么这些数据成员如何摆放？其实还能怎么摆放？无非是顺着来就好了。对就这样，但是谁先谁后？是否顺序无所谓？答案是，基类在前面派生类在后边更合理。为什么是这样？我们考虑下面的代码：

   1:  class Base

   2:  {

   3:  public:

   4:  int b;

   5:  };

   6:  class Derived : public Base

   7:  {

   8:  public:

   9:  int d;

  10:  };

  11:  int main()

  12:  {

  13:  Derived d;

  14:  d.b = 2012;

  15:  Base* b = &d;

  16:  b->b = 2012;

  17:  }

我们把一个派生类对象地址，赋给基类指针，并且通过它访问基类成员，如果派生类对象的内存布局是，基类在后，即成员d在前面，然后成员b。 d.b = 2012; 这条语句没有问题，编译器知道b的位置，d起始位置加4即可。但是 b->b = 2012; 就没法玩了，因为编译器不知道b是一个Derived对象（原因上面有说），那么它就按b在Base中的偏移0，来算，而这个偏移，取到的其实是Derived::d的内容。如果反过来放，就没问题了。通过下面的代码，我们可以看到，确实是按基类优先的顺序存放的。

   1:  #include <cstdio>

   2:  class Base

   3:  {

   4:  public:

   5:     int b;

   6:  };

   7:  class Derived : public Base

   8:  {

   9:  public:

  10:     int d;

  11:  };

  12:  int main()

  13:  {

  14:     Derived d;

  15:     printf("Derived  = 0x%lx\n", &d);

  16:     printf("Derived.b  = 0x%lx\n", &d.b);

  17:     printf("Derived.d  = 0x%lx\n", &d.d);

  18:     return 0;

  19:  }

# ./a.out

Derived    = 0x7fffece35bf0

Derived.b  = 0x7fffece35bf0

Derived.d  = 0x7fffece35bf4

对象： | 基类的成员|派生类的成员|

多继承

终于来到了最神奇的地方，那就是多继承，在讨论多继承的内存布局之前，我忍不住要吐槽几句。C++的设计哲学是大而全，实际上很多特性可能一辈子都用不到，我觉得一个好的编程语言，应该提供简洁的语言特性和强大丰富的功能库，比如Python。C++太不精简了。实际上，所有C++程序其实都是C++子集程序员；但所有C程序员都是C全集程序员。C的语言特性基本没有多余的，C程序员基本都会用到。多继承就是最多余的C++特性之一。可能有些同学说，有些地方用多继承很方便，不用不太好搞；没这回事儿，那肯定是类设计出了问题，正是因为语言支持这种特性，才导致一些糟糕的设计存在。要是C++不支持，编译器编译不过，你丫的会想不出来解决方案？好的语言特性可以直接引导程序员好的设计思维。比如Erlang不支持循环、不支持变量二次赋值…… 逼得程序员完全改变思维方式。。。结果就是写出来的程序，自然支持多核、高并发，还无锁。另外你看google的C++编程规范就知道，最重要的一部分就是对C++做减法，取子集。吐槽完毕，可能引起一片拍砖。。。（偶尔还是得抛一些观点，否则只是纯技术性的，太冷清了）
单继承的内存布局，是基类成员在前，派生在后，但是多继承呢？丫的有两个基类，谁前谁后？谁前谁后不重要，关键的是根据上面单继承分析，如果基类成员在派生类对象的位置不是从头开始，派生类对像指针转化为基类指针之后，就不能正确访问基类成员了。而多继承，必然至少有一个基类不是从头开始的。那么怎么办？还能怎么办，凉拌！当你把一个派生类对象地址赋值给一个基类指针，如果这个基类在派生类中的位置，不是从头开始的，编译器偷偷的把它改变，加上基类在派生类中的位置偏移量！我们来验证下：

   1:  #include <cstdio>

   2:  class Base1

   3:  {

   4:  public:

   5:     int b1;

   6:  };

   7:  class Base2

   8:  {

   9:  public:

  10:     int b2;

  11:  };

  12:  class Derived : public Base1, public Base2

  13:  {

  14:  public:

  15:     int d;

  16:  };

  17:  int main()

  18:  {

  19:     Derived d;

  20:     printf("Derived  = 0x%lx\n", &d);

  21:     printf("Derived.b1  = 0x%lx\n", &d.b1);

  22:     printf("Derived.b2  = 0x%lx\n", &d.b2);

  23:     printf("Derived.d  = 0x%lx\n", &d.d);

  24:     Base2* b2p = &d;

  25:     printf("Base2 pointer = 0x%lx\n", b2p);

  26:     return 0;

  27:  }

# ./a.out

Derived          =    0x7fffedfe10e0

Derived.b1      =    0x7fffedfe10e0

Derived.b2      =    0x7fffedfe10e4

Derived.d        =    0x7fffedfe10e8

Base2 pointer  =    0x7fffedfe10e4

可以看到，摆放的顺序是Base1，Base2，Derived：
对象：| 基类1的成员 | 基类2的成员 | 派生类的成员
而当我们把Derived的地址0x7fffedfe10e0赋给Base2时，变成了0x7fffedfe10e4，即Base2成员的起始位置，这样我们的b2p->b2; 可以正确的工作。是不是很神奇？=号都是不可信的！

多继承+虚函数

   1:  #include <cstdio>

   2:  class Base1

   3:  {

   4:  public:

   5:  int b1;

   6:  virtual void function1() { printf("Base1::function1\n"); }

   7:  };

   8:  class Base2

   9:  {

  10:  public:

  11:  int b2;

  12:  virtual void function2() { printf("Base2::function2\n"); }

  13:  };

  14:  class Derived : public Base1, public Base2

  15:  {

  16:  public:

  17:  int d;

  18:  void function1() { printf("Derived::function1\n"); }

  19:  void function2() { printf("Derived::function2\n"); }

  20:  };

  21:  int main()

  22:  {

  23:  Derived d;

  24:  printf("Derived = 0x%lx\n", &d);

  25:  printf("Derived.b1 = 0x%lx\n", &d.b1);

  26:  printf("Derived.b2 = 0x%lx\n", &d.b2);

  27:  printf("Derived.d = 0x%lx\n", &d.d);

  28:  Base2* b2p = &d;

  29:  printf("Base2 pointer = 0x%lx\n", b2p);

  30:  long* vtl = *(long**)b2p;

  31:  printf("0x%lx\n", *(vtl));

  32:  printf("0x%lx\n", *(vtl + 1));

  33:  vtl = *(long**)&d;

  34:  printf("0x%lx\n", *(vtl));

  35:  printf("0x%lx\n", *(vtl + 1));

  36:  return 0;

  37:  }

# ./a.out

Derived = 0x7fffa74ae400

Derived.b1 = 0x7fffa74ae408//b1没有放在最开始，因为第一个是虚表地址

Derived.b2 = 0x7fffa74ae418//b2没有放在b1后面，因为前边还有一个虚表地址

Derived.d = 0x7fffa74ae41c

Base2 pointer = 0x7fffa74ae410//base2在派生类中的起始位置，

0x4008aa//虚表2中存放的函数地址，gcc生成的中间函数

0x0//虚表2中存放的函数地址&nbsp;

0x4008c8//虚表1中存放的函数地址，function1

0x4008b0//虚表1中存放的函数地址，function2

# nm a.out |grep function

00000000004008e0 W _ZN5Base19function1Ev

00000000004008f8 W _ZN5Base29function2Ev

00000000004008c8 W _ZN7Derived9function1Ev

00000000004008b0 W _ZN7Derived9function2Ev

00000000004008aa W _ZThn16_N7Derived9function2Ev

# c++filt _ZN7Derived9function1Ev _ZN7Derived9function2Ev _ZThn16_N7Derived9function2Ev

Derived::function1()

Derived::function2()

non-virtual thunk to Derived::function2()

# objdump -d a.out | sed -n '/_ZThn16_N7Derived9function2Ev/,/00000/p'

00000000004008aa <_ZThn16_N7Derived9function2Ev>:

4008aa: 48 83 c7 f0 add $0xfffffffffffffff0,%rdi

4008ae: eb 00 jmp 4008b0 <_ZN7Derived9function2Ev>//中间函数跳转到了function2

00000000004008b0 <_ZN7Derived9function2Ev>:

了解C++内存布局的意义

意义至少有一点，让我们写出更好的C++程序。内存布局越复杂，性能越差，所以你会知道该如何选择。