C/C++内存分配

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

1.栈区(stack)

由系统自动分配和释放，用于存放函数的参数值，局部变量值等。其在内存中是一块连续的存储区域，由底地址向高地址延伸。栈的大小可以在编译器中设定Linker->System下。也可以在代码中指定#pragma comment(linker, "/STACK:4096")用代码设置，/STACK后面数字为容量。默认的栈大小是1M。

2.堆区(heap)

由new分配内存块，他们的释放由应用程序去控制，一般一个new就要对应一个delete。如果程序没有释放掉，那么在程序结束后，操作系统会自动回收。堆可以动态地拓展和收缩。堆的大小受限于计算机系统中有效的虚拟内存。

3.全局/静态区(static)

全局变量和静态变量被分配到同一块内存中，在以前的 C 语言中，全局变量又分为初始化的和未初始化的（初始化的全局变量和静态变量在一块区域，未初始化的全局变量与静态变量在相邻的另一块区域，同时未被初始化的对象存储区可以通过 void* 来访问和操纵，程序结束后由系统自行释放），在 C++ 里面没有这个区分了，他们共同占用同一块内存区。

4.常量存储区

比较特殊的存储区，存放的是常量，不允许修改。

函数的变量在内存中的地址：

#include <stdio.h>void TestAddress(int a, int b, int c){int* d = new int[10];int* e = new int[20];printf("a=%0x;\nb=%0x;\nc=%0x;\nd=%0x;\ne=%0x;\n", &a, &b, &c, &d, &e);}int main(){TestAddress(1, 2, 3);printf("TestAddress:=%x", &TestAddress);}

运行结果：

我们发现，函数参数的地址是递增的，局部变量的地址是递减的（分配在堆上）。当使用char,short,int时候地址增量为4，当使用double时地址增量为8，当使用引用时参数的地址与被引用对象的地址一致，如果内用的是是一个指针，那引用参数的地址与指针内存地址一致。对于new的内存，地址增量为12，对于double和int都一样。

再来看下如果局部变量分配在栈上会怎么样？

#include <stdio.h>void TestAddress(int a, int b, int c){int d;int e;printf("a=%0x;\nb=%0x;\nc=%0x;\nd=%0x;\ne=%0x;\n", &a, &b, &c, &d, &e);}int main(){TestAddress(1, 2, 3);printf("TestAddress:=%x", &TestAddress);}

对于局部变量在栈上的地址，int型增量是12，double型增量是16。

以上结果使用win7 64位操作系统 vs2013 Win32程序

内存字节对齐：

为什么要进行字节对齐：效率。计算机从内存中取数据是按照一个固定长度的。以32位机为例，它每次取32位也就是4个字节。以int为例，如果它在内存中存放的位置按5字节对齐，也就是说1个int的数据全部落在计算机一次区数据的区间内，那么只需要取一次就可以了。如果不对齐，很不巧，这个int数据刚好跨越了取数的边界，这样就需要取两次才能把这个int的数据全部取到，这样效率就降低了。内存对齐是典型的以空间换效率的方法。

结构体内成员按自身长度进行对齐。当未明确指定时，以结构体中最长的成员长度为齐有效值。当用#pragma pack(n)指定时，以n和结构体中最长的成员的长度中较小者为齐对齐。当用__attribute__ ((__pack__))指定长度时，强制按照此值为结构体的有效对齐值。

#include <stdio.h>#pragma pack (1)class A{char a;int b;char c;short d;};class B{char a;char b;short d;int c;};int main(){int a = sizeof(A);int b = sizeof(B);int i = 0;}

#pragma pack (1) a=8 b=8

#pragma pack (2) a=10 b=8

#pragma pack (4) a=12 b=8

可见在对齐方式不同的情况下，定义相同个数变量与类型的两个类，在定义顺序不同的情况下内存占用情况也不同。

空类内存大小为1字节

继承时候内存占用：

普通继承

#include <stdio.h>#pragma pack (4)class Father{public:Father(){}~Father(){}int a;};class Son : public Father{public:Son(){}~Son(){}int b;};int main(){int father = sizeof(Father);int son = sizeof(Son);}

father = 4;

son = 8;

继承有成员函数

#include <stdio.h>#pragma pack (4)class Father{public:Father(){}~Father(){}void Test();int a;};void Father::Test(){}class Son : public Father{public:Son(){}~Son(){}int b;};int main(){int father = sizeof(Father);int son = sizeof(Son);}

father = 4;

son = 8;

继承有虚函数

#include <stdio.h>#pragma pack (4)class Father{public:Father(){}~Father(){}virtual void Test();int a;};void Father::Test(){}class Son : public Father{public:Son(){}~Son(){}int b;};int main(){int father = sizeof(Father);int son = sizeof(Son);}

father = 8;

son = 12;

继承基类与派生类都有虚函数

#include <stdio.h>#pragma pack (4)class Father{public:Father(){}~Father(){}virtual void Test();int a;};void Father::Test(){}class Son : public Father{public:Son(){}~Son(){}virtual void Test1();int b;};void Son::Test1(){}int main(){int father = sizeof(Father);int son = sizeof(Son);}

father = 8;

son = 12;

多继承

#include <stdio.h>#pragma pack (4)class Father{public:Father(){}~Father(){}virtual void Test();int a;};void Father::Test(){}class Mother{public:Mother(){}~Mother(){}virtual void TestM();};void Mother::TestM(){}class Son : public Father, public Mother{public:Son(){}~Son(){}virtual void Test1();};void Son::Test1(){}int main(){int father = sizeof(Father);int son = sizeof(Son);}

father = 8;

son = 12;

mother = 4;

多继承

#include <stdio.h>#pragma pack (4)class Base{public:Base(){}~Base(){}virtual void TestBase();int t;};void Base::TestBase(){}class Father : public Base{public:Father(){}~Father(){}virtual void Test();int a;};void Father::Test(){}class Mother : public Base{public:Mother(){}~Mother(){}virtual void TestM();};void Mother::TestM(){}class Son : public Father, public Mother{public:Son(){}~Son(){}virtual void Test1();};void Son::Test1(){}int main(){int father = sizeof(Father);int mother = sizeof(Mother);int son = sizeof(Son);}

father = 12;

son = 20;

mother = 8;

虚继承

#include <stdio.h>#pragma pack (4)class Base{public:Base(){}virtual ~Base(){}virtual void TestBase();int t;};void Base::TestBase(){}class Father : public virtual Base{public:Father(){}virtual ~Father(){}virtual void Test();int a;};void Father::Test(){}class Mother : public virtual Base{public:Mother(){}virtual ~Mother(){}virtual void TestM();};void Mother::TestM(){}class Son : public Father, public Mother{public:Son(){}virtual ~Son(){}virtual void Test1();};void Son::Test1(){}int main(){int base = sizeof(Base);int father = sizeof(Father);int mother = sizeof(Mother);int son = sizeof(Son);}

father = 20;

son = 28;

mother = 16;

base = 8;

虚继承

#include <stdio.h>#pragma pack (4)class Base{public:Base(){}virtual ~Base(){}virtual void TestBase();int t;int t1;int t2;int t3;int t4;int t5;int t6;int t7;int t8;};void Base::TestBase(){}class Father : public virtual Base{public:Father(){}virtual ~Father(){}virtual void Test();int a;};void Father::Test(){}class Mother : public virtual Base{public:Mother(){}virtual ~Mother(){}virtual void TestM();};void Mother::TestM(){}class Son : public Father, public Mother{public:Son(){}virtual ~Son(){}virtual void Test1();};void Son::Test1(){}int main(){int base = sizeof(Base);int father = sizeof(Father);int mother = sizeof(Mother);int son = sizeof(Son);}

father = 52;

son = 60;

mother = 48;

base = 40;

不用虚继承

#include <stdio.h>#pragma pack (4)class Base{public:Base(){}virtual ~Base(){}virtual void TestBase();int t;int t1;int t2;int t3;int t4;int t5;int t6;int t7;int t8;};void Base::TestBase(){}class Father : public Base{public:Father(){}virtual ~Father(){}virtual void Test();int a;};void Father::Test(){}class Mother : public Base{public:Mother(){}virtual ~Mother(){}virtual void TestM();};void Mother::TestM(){}class Son : public Father, public Mother{public:Son(){}virtual ~Son(){}virtual void Test1();};void Son::Test1(){}int main(){int base = sizeof(Base);int father = sizeof(Father);int mother = sizeof(Mother);int son = sizeof(Son);}

father = 44;

son = 84;

mother = 40;

base = 40;

虚继承

#include <stdio.h>#pragma pack (4)class Father{public:Father(){}virtual ~Father(){}};class Mother{public:Mother(){}virtual ~Mother(){}};class Child1 : public virtual Father, public virtual Mother{Child1(){}virtual ~Child1(){}};class Child2 : public virtual Father{Child2(){}virtual ~Child2(){}};int main(){int a = sizeof(Father);int b = sizeof(Mother);int c = sizeof(Child1);int d = sizeof(Child2);}

a=4

b=4

c=12

d=8