c++类实例在内存中的分配

c++类实例在内存中的分配 

转自http://www.cnblogs.com/bizhu/archive/2012/09/25/2701691.html

关于结构体和C++类的内存地址问题

今天终于有时间写点 东西了~ 太爽了  *_*  很多人都知道C++类是由结构体发展得来的，所以他们的成员变量（C语言的结构体只有成员变量）的内存分配机制是一样的。下面我们以类来说明问题，如果 类的问题通了，结构体也也就没问题啦。 类分为成员变量和成员函数，我们先来讨论成员变量。 一个类对象的地址就是类所包含的这一片内存空间的首地址，这个首地址也就对应具体某一个成员变量的地址。（在定义类对象的同时这些成员变量也就被定义了）我们来以一段代码说明问题： //类的定义

class K{
public:
 K(){k = 12;}
 ~K(){}
 int k;
}; 

//类的使用//... K kTemp;
 printf("%d--%d\n",&kTemp,&kTemp.k);
 printf("%d--%d\n",sizeof(K),sizeof(kTemp.k));
 int *i = (int*)(&kTemp);
 int w = *i;
 printf("%d\n",w); 运行上面的代码，结果如下：1310588--1310588
4--4
12
很明显,类的内存大小和其唯一的成员变量的内存大小是一致的。内存地址也是一致的。他们甚至可以相互转换。换成结构体结果也是一样。网友可以自己运行上面代码来进行确认。 这个时候，可能有人会提出疑问了。那么成员函数又如何？上面得代码就好像类没有任何成员函数一样，根本说明不了问题。 呵呵，所有的函数都是存放在代码区的, 不管是全局函数，还是成员函数。要是成员函数占用类的对象空间,那么将是多么可怕的事情:定义一次类对象就有成员函数占用一段空间。 我们再来补充一下静 态成员函数的存放问题吧：静态成员函数与一般成员函数的唯一区别就是没有this指针，因此不能访问非静态数据成员，就像我前面提到的，所有函数都存放在代码区，静态函数也不例外。所有有人一看到 static 这个单词就主观的认为是存放在全局数据区，那是不对的

 

c++是一种面向对象的编程语言，它向下保持了对c的兼容，同时也允许程序员能够自由的操控内存，虽然会带来一些问题，但这不是我们要探讨的问题，略过不 表。类是对某种对象的定义，包含变量和方法，也可以理解为现实生活中一类具有共同特征的事务的抽象，他是面向对象语言的基础。所以类是不占有内存的，可是 如果类生成实例那么将会在内存中分配一块内存来存储这个类。

    类的实例在内存中是如何分配内存的，有什么需要我们注意的，下面将慢慢到来。

    比如下面一个类：

    class A

    {};

    从形式上看，它似乎什么有没有，事实上它不止隐含了一个构造函数和一个析构函数，还有一些操作符重载函数，比如“=”。如果类A被实例话，如A a;在内存会占据多大的空间呢？有人可能会说4，也有人会说0，还有人会说1，说1的就对了，为什么会是1呢？原因有很多，如果我们定义一个数组A b[10];如果上面是0，这样的局面将会很尴尬，所以A这样一个空类，编译器会给它一个字节来填充。  

    增加一个变量，（字节对齐默认都是4）

    class  A

   {

     public：

          int i;

   }

  

   类A的实例将占据4个字节的内存，sizeof(A) = 4

   变量i 的初值被编译器指定位0xcdcdcdcd。

    再增加一个变量，

   class A

   {

      public：

      int  i;

      int  l;

   }

   此时按照变量生命的先后顺序，i被放在低地址上，l紧随其后。

   实例占用8个字节，sizeof(A) = 4*2 = 8

   如果累里面含有函数：

  class A

 {

     public:

      int i;

      int l;

      int add(int x,int y){return (x+y);}

 };

 有些人可能会说类的大小是12，事实上sizeof(A) = 8；

 为什么会这样，这是因为sizeof访问的程序的数据段，而函数地址则被保存在代码段内，所以最后的结果是8.

 再看下面这个情况

 class A

 {

      public:

         int i;

         int l;

         static int s;

         int add(int x,int y){return (x+y)};

 };

此时sizeof(A)大小仍为8，这里留给读者去思考为什么？（^-^）。

static int s 放在bss段里的，sizeof算data段，

当类里面含有虚函数时，情况会如何呢？

 class A

 {

      public:

         int i;

         int l;

         static int s;

         virtual void Say(){};

         int add(int x,int y){return (x+y)};

 };

 因为含有虚函数，所以类里面将含有一个虚指针vptr，指向该类的虚表vtbl，一个指针占用四字节的地址，所以sizeof(A) = 12

 虚指针放在类实例地址的最低位置，

 比如 A *a = new A;

 我们可以这样给变量i赋值

int *p = (int *)a;
 p++;
 *p = 1;//把i的值赋为1.

如果类作为派生类，内存将如何分配呢？

这种情况虽然有些复杂，但并不是说不好理解。

他有多少个父类每个父类的大小加起来在加上自身就是sizeof的大小。

 

//-----C++类对象内存结构[讲得很好] -------

首先介绍一下C++中有继承关系的类对象内存的布局： 
在C++中，如果类中有虚函数，那么它就会有一个虚函数表的指针__vfptr，在类对象最开始的内存数据中。之后是类中的成员变量的内存数据。 
对于子类，最开始的内存数据记录着父类对象的拷贝（包括父类虚函数表指针和成员变量）。 之后是子类自己的成员变量数据。 
对于子类的子类，也是同样的原理。但是无论继承了多少个子类，对象中始终只有一个虚函数表指针。 
 
 
 
为了探讨C++类对象的内存布局，先来写几个类和函数 
首先写一个基类： 
class Base 
{ 
public: 
virtual void f() { cout << "Base::f" << endl; } 
virtual void g() { cout << "Base::g" << endl; } 
virtual void h() { cout << "Base::h" << endl; } 
int base; 
protected: 
private: 
}; 
然后，我们多种不同的继承情况来研究子类的内存对象结构。 
1. 无虚函数集继承 
 
//子类1，无虚函数重载 
class Child1 : public Base 
{ 
public: 
virtual void f1() { cout << "Child1::f1" << endl; } 
virtual void g1() { cout << "Child1::g1" << endl; } 
virtual void h1() { cout << "Child1::h1" << endl; } 
int child1; 
protected: 
private: 
}; 
这个子类Child1没有继承任何一个基类的虚函数，因此它的虚函数表如下图： 
 
 
我们可以看出，子类的虚函数表中，先存放基类的虚函数，在存放子类自己的虚函数。 
 
2. 有一个虚函数继承 
//子类2，有1个虚函数重载 
class Child2 : public Base 
{ 
public: 
virtual void f() { cout << "Child2::f" << endl; } 
virtual void g2() { cout << "Child2::g2" << endl; } 
virtual void h2() { cout << "Child2::h2" << endl; } 
int child2; 
protected: 
private: 
}; 
 
当子类重载了父类的虚函数，则编译器会将子类虚函数表中对应的父类的虚函数替换成子类的函数。 
3. 全部虚函数都继承 
//子类3，全部虚函数重载 
class Child3 : public Base 
{ 
public: 
virtual void f() { cout << "Child3::f" << endl; } 
virtual void g() { cout << "Child3::g" << endl; } 
virtual void h() { cout << "Child3::h" << endl; } 
protected: 
int x; 
private: 
}; 
 
 
 
4. 多重继承 
多重继承，即类有多个父类，这种情况下的子类的内存结构和单一继承有所不同。 
 
我们可以看到，当子类继承了多个父类，那么子类的内存结构是这样的： 
子类的内存中，顺序 
 
5. 菱形继承 
 
 
6. 单一虚拟继承 
 
 
虚 拟继承的子类的内存结构，和普通继承完全不同。虚拟继承的子类，有单独的虚函数表， 另外也单独保存一份父类的虚函数表，两部分之间用一个四个字节的0x00000000来作为分界。子类的内存中，首先是自己的虚函数表，然后是子类的数据 成员，然后是0x0，之后就是父类的虚函数表，之后是父类的数据成员。 
如果子类没有自己的虚函数，那么子类就不会有虚函数表，但是子类数据和父类数据之间，还是需要0x0来间隔。 
因此，在虚拟继承中，子类和父类的数据，是完全间隔的，先存放子类自己的虚函数表和数据，中间以0x分界，最后保存父类的虚函数和数据。如果子类重载了父类的虚函数，那么则将子类内存中父类虚函数表的相应函数替换。 
 
7. 菱形虚拟继承 
 
结论： 
(1) 对于基类，如果有虚函数，那么先存放虚函数表指针，然后存放自己的数据成员；如果没有虚函数，那么直接存放数据成员。 
(2) 对于单一继承的类对象，先存放父类的数据拷贝(包括虚函数表指针)，然后是本类的数据。 
(3) 虚函数表中，先存放父类的虚函数，再存放子类的虚函数 
(4) 如果重载了父类的某些虚函数，那么新的虚函数将虚函数表中父类的这些虚函数覆盖。 
(5) 对于多重继承，先存放第一个父类的数据拷贝，在存放第二个父类的数据拷贝，一次类推，最后存放自己的数据成员。其中每一个父类拷贝都包含一个虚函数表指 针。如果子类重载了某个父类的某个虚函数，那么该将该父类虚函数表的函数覆盖。另外，子类自己的虚函数，存储于第一个父类的虚函数表后边部分。 
(6) 当对象的虚函数被调用是，编译器去查询对象的虚函数表，找到该函数，然后调用。

来源：http://blog.csdn.net/jimmy54/archive/2010/03/26/5418766.aspx