关于栈与堆的区分

妖狐艹你老母 2022-07-27 14:37 185阅读 0赞

一个由C/C++编译的程序占用的内存分为以下几个部分：

1、栈区（stack）：又编译器自动分配释放，存放函数的参数值，局部变量的值等，其操作方式类似于数据结构的栈。

2、堆区（heap）：一般是由程序员分配释放，若程序员不释放的话，程序结束时可能由OS回收，值得注意的是他与数据结构的堆是两回事，分配方式倒是类似于数据结构的链表。

3、全局区（static）：也叫静态数据内存空间，存储全局变量和静态变量，全局变量和静态变量的存储是放一块的，初始化的全局变量和静态变量放一块区域，没有初始化的在相邻的另一块区域，程序结束后由系统释放。

4、文字常量区：常量字符串就是放在这里，程序结束后由系统释放。

5、程序代码区：存放函数体的二进制代码。

堆和栈的区别：

1、由以上综述就可以得知，他们程序的内存分配方式不同。

2、申请和响应不同：

（1）申请方式：

stack由系统自动分配，系统收回；heap需要程序员自己申请，C中用函数malloc分配空间，用free释放，C++用new分配，用delete释放。

（2）申请后系统的响应：

栈：只要栈的剩余空间大于所申请的空间，体统将为程序提供内存，否则将报异常提示栈溢出。

堆：首先应该知道操作系统有一个记录内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请的空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样代码中的delete或free语句就能够正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会将多余的那部分重新放入空闲链表中。

3、申请的大小限制不同：

栈：在windows下，栈是向低地址扩展的数据结构，是一块连续的内存区域，栈顶的地址和栈的最大容量是系统预先规定好的，能从栈获得的空间较小。

堆：堆是向高地址扩展的数据结构，是不连续的内存区域，这是由于系统是由链表在存储空闲内存地址，自然堆就是不连续的内存区域，且链表的遍历也是从低地址向高地址遍历的，堆得大小受限于计算机系统的有效虚拟内存空间，由此空间，堆获得的空间比较灵活，也比较大。

4、申请的效率不同：

栈：栈由系统自动分配，速度快，但是程序员无法控制。

堆：堆是有程序员自己分配，速度较慢，容易产生碎片，不过用起来方便。

5、堆和栈的存储内容不同：

栈：在函数调用时，第一个进栈的是主函数中函数调用后的下一条指令的地址，然后是函数的各个参数，在大多数的C编译器中，参数是从右往左入栈的，当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令。

堆：一般是在堆得头部用一个字节存放堆得大小，具体内容由程序员安排

起初刚学C++时，很不习惯用new，后来看老外的程序，发现几乎都是使用new，想一想区别也不是太大，但是在大一点的项目设计中，有时候不使用new的确会带来很多问题。

当然这都是跟new的用法有关的。new创建类对象，使用完后需使用delete删除，跟申请内存类似。所以，new有时候又不太适合，比如在频繁调用场合，使用局部new类对象就不是个好选择，使用全局类对象或一个经过初始化的全局类指针似乎更加高效。

## 一、new创建类对象与不new区别    ##

下面是自己总结的一些关于new创建类对象特点：

*  new创建类对象需要指针接收，一处初始化，多处使用
 *  new创建类对象使用完需delete销毁
 *  new创建对象直接使用堆空间，而局部不用new定义类对象则使用栈空间
 *  new对象指针用途广泛，比如作为函数返回值、函数参数等
 *  频繁调用场合并不适合new，就像new申请和释放内存一样

## 二、new创建类对象实例    ##

### 1、new创建类对象例子：    ###

CTest\* pTest = new CTest();

delete pTest;

pTest用来接收类对象指针。

不用new，直接使用类定义申明：

CTest mTest;

此种创建方式，使用完后不需要手动释放，该类析构函数会自动执行。而new申请的对象，则只有调用到delete时再会执行析构函数，如果程序退出而没有执行delete则会造成内存泄漏。

### 2、只定义类指针    ###

这跟不用new申明对象有很大区别，类指针可以先行定义，但类指针只是个通用指针，在new之前并为该类对象分配任何内存空间。比如：

CTest\* pTest = NULL;

但使用普通方式创建的类对象，在创建之初就已经分配了内存空间。而类指针，如果未经过对象初始化，则不需要delete释放。

### 3、new对象指针作为函数参数和返回值    ###

下面是天缘随手写一个例子，不太严谨。主要示意一下类指针对象作为返回值和参数使用。

**示例：**

类的内存分配简单总结，代码片段如下：

测试环境：

Ubuntu 12.04.5 LTS   x86\_64 GNU/Linux

g++ (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3 编译参数 \-m64

结果是

homer@homer-pc:~/Desktop$ g++ testMem.c -o testMem && ./testMem  
16  
24

结果为什么是这样？

32位系统int占4个字节，64位系统int也占4个字节（不是8个字节），而一个类中所有的虚函数通过一个虚函数指针管理，类对象的大小只包含这个vptr指针（在64位机器上指针sizeof为8个字节），其他虚函数是放在别的内存空间中管理，vptr指针在64位机器上是8个字节大小（32位机器上是4个字节）。注意到普通成员函数并不占类对象的大小空间，因为普通成员函数通过this指针管理，一个对象的this指针并不是对象本身的一部分，不会影响sizeof(对象)的结果。

**sizeof(ClassA)**

1）int A 和 int B 各占4个字节，考虑64位机器编译器对其规则，合并为8个字节

2）virtual void prin3() 虚函数的vptr指针，在64位机器编译器上占8个字节

3）合计 sizeof(ClassA）为 8 + 8 = 16个字节

this作用域是在类内部，当在类的非静态成员函数中访问类的非静态成员的时候，编译器会自动将对象本身的地址作为一个隐含参数传递给函数。这个this指针会因编译器不同而有不同的放置位置，可能是栈，也可能是寄存器，甚至全局变量。

子类其实不管如何继承，用sizeof（）算该类的大小都会把父类中的私有成员变量所占的空间算进去，也就是说，私有变量也在子类中分配了内存，但你却不可以直接访问，这起到一个保护作用，这如同一个珠宝，共有继承就是开放性的展览，而私有继承是把珠宝锁起来，你却不能动，要动珠宝如果有管家（基类的public中定义了一些对其私有变量操作的成员函数，）只能让管家帮你代劳。

**sizeof(ClassB)**

1）int A 和 int B 各占4个字节，是父类ClassA中的私有变量，合并占用8个字节

2）virtual void prin3() 虚函数的vptr指针，父类ClassA在子类中不会分配空间

3）int C 和 int D 各占4个字节，在子类中会分配空间，合并占用8个字节

4）virtual void prin6() 虚函数的vptr指针，在64位机器编译器上占8个字节

5）合计 sizeof(ClassB）为 8 + 8 + 8 = 24个字节

**注明**： 上述示例在32位编译器上测试，sizeof(ClassA)和sizeof(ClassB）分别为12和20字节（虚函数指针占用空间少了4字节）

只有虚函数会占用一个指针大小的内存，原因是系统用一个指针维护这个类的虚函数表，并且注意这个虚函数无论含有多少项（类中含有多个虚函数）都不会影响类的大小。

**知识延伸：**

1） 空 ClassA（验证空Class占用空间大小）

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> 
    <div>
      11 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>class</code> 
      <code>ClassA { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>private</code> 
      <code>:</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>void</code> 
      <code>prin1() { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>void</code> 
      <code>prin2() { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div> 
      <code>};</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>cout&lt;&lt;</code> 
      <code>sizeof</code> 
      <code>(ClassA)&lt;&lt;endl;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>// 1</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

2） ClassA 只有一个char（验证编译器对其规则）

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> 
    <div>
      11 
    </div> 
    <div>
      12 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>class</code> 
      <code>ClassA { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>private</code> 
      <code>:</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>char</code> 
      <code>C;</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>void</code> 
      <code>prin1() { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>void</code> 
      <code>prin2() { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div> 
      <code>};</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>cout&lt;&lt;</code> 
      <code>sizeof</code> 
      <code>(ClassA)&lt;&lt;endl;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>// 1</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

3）ClassA 有一个char和一个虚函数（或一个long型）（验证编译器对其规则二）

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> 
    <div>
      11 
    </div> 
    <div>
      12 
    </div> 
    <div>
      13 
    </div> 
    <div>
      14 
    </div> 
    <div>
      15 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>class</code> 
      <code>ClassA { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>private</code> 
      <code>:</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>char</code> 
      <code>C;</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>void</code> 
      <code>prin1() { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>void</code> 
      <code>prin2() { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>virtual</code> 
      <code>void</code>&nbsp; 
      <code>prin3() { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div> 
      <code>};</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>cout&lt;&lt;</code> 
      <code>sizeof</code> 
      <code>(ClassA)&lt;&lt;endl;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>// 16</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

4）ClassA 有一个char和一个虚函数（或一个long型），且对调char和虚函数的先后顺序（验证编译器对其规则三）

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> 
    <div>
      11 
    </div> 
    <div>
      12 
    </div> 
    <div>
      13 
    </div> 
    <div>
      14 
    </div> 
    <div>
      15 
    </div> 
    <div>
      16 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>class</code> 
      <code>ClassA { </code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>void</code> 
      <code>prin1() { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>void</code> 
      <code>prin2() { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>virtual</code> 
      <code>void</code>&nbsp; 
      <code>prin3() { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>private</code> 
      <code>:</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>char</code> 
      <code>C;</code> 
     </div> 
     <div> 
      <code>};</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>cout&lt;&lt;</code> 
      <code>sizeof</code> 
      <code>(ClassA)&lt;&lt;endl;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>// 16</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

5）ClassA 有一个char，一个int，一个虚函数（或一个long型）（验证编译器对其规则四）

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> 
    <div>
      11 
    </div> 
    <div>
      12 
    </div> 
    <div>
      13 
    </div> 
    <div>
      14 
    </div> 
    <div>
      15 
    </div> 
    <div>
      16 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>class</code> 
      <code>ClassA { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>private</code> 
      <code>:</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>char</code> 
      <code>C;</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>int</code> 
      <code>A;</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>void</code> 
      <code>prin1() { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>void</code> 
      <code>prin2() { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>virtual</code> 
      <code>void</code>&nbsp; 
      <code>prin3() { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div> 
      <code>};</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>cout&lt;&lt;</code> 
      <code>sizeof</code> 
      <code>(ClassA)&lt;&lt;endl;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>// 16</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

6）ClassA 有一个char，一个int（验证编译器对其规则五）

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> 
    <div>
      11 
    </div> 
    <div>
      12 
    </div> 
    <div>
      13 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>class</code> 
      <code>ClassA { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>private</code> 
      <code>:</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>char</code> 
      <code>C;</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>int</code> 
      <code>A;</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>void</code> 
      <code>prin1() { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>void</code> 
      <code>prin2() { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div> 
      <code>};</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>cout&lt;&lt;</code> 
      <code>sizeof</code> 
      <code>(ClassA)&lt;&lt;endl;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>// 8</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

7）ClassA 只有一个int（验证编译器对其规则六）

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> 
    <div>
      11 
    </div> 
    <div>
      12 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>class</code> 
      <code>ClassA { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>private</code> 
      <code>:</code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>int</code> 
      <code>A;</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>void</code> 
      <code>prin1() { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>void</code> 
      <code>prin2() { </code> 
     </div> 
     <div> 
      <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>}</code> 
     </div> 
     <div> 
      <code>};</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>cout&lt;&lt;</code> 
      <code>sizeof</code> 
      <code>(ClassA)&lt;&lt;endl;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code>// 4</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

总结如下：

1） 空类的 sizeof 为1个字节

2） 只有一个char的类，sizeof为一个字节

3） 类中含有char和虚函数，将以最大的变量或指针为编译器对齐规则，例如：虚函数指针占8个字节（64位编译器），则char虽然只占1个字节，但对齐后空余了7个字节，合并类占8（指针） + 1（char） + 7（对齐的空字节） = 16个字节

4） 对齐规则，跟变量或虚函数的先后顺序无关，只跟最大变量类型或函数指针有关，函数指针跟编译器最大对齐位数有关（不太好理解，请继续往下看）

5） char和int合占8个字节，虚函数指针占8个字节，且以最大的虚函数指针的8字节对其，其中char占一个空余3个字节合并占4个，int占4个字节，按8位规则对齐，合计16字节

6） 一个char和int合并占8个字节，无虚函数，此时以最大变量类型int对齐，因此char占1字节空3字节占4字节

7）一个int占4位，自己便是最大的对齐规则； 2）一个char同理也占1个字节，此处跟编译器最大64位对齐规则无关（即一个int或一个char，不会拓展到占用8字节）

这里，又延伸出了一个很有意思的问题，**空类sizeof为什么不为0，而为1？**

回答这个问题，需要回到编译器和类的实例化问题上来，在学校看过《深度探索C++对象模型》，类分抽象类和普通类，空类属于普通类，是可以被实例化的。

每个类的实例，在内存中都有一个独一无二的地址，为了达到这个目的，编译器往往会给一个空类隐含的加一个字节，这样空类在实例化后在内存得到了独一无二的地址，因此1）中的空类ClassA默认会占用1个字节。