C++之内存分布(对于堆栈空间的剖析)

C++程序在执行时，将内存大致划分为四个区域代码区存放函数体的二进制代码，由操作系统进行管理数据区存放全局变量和静态变量以及常量栈区由编译器自动分配释放，存放函数的参数值，局部变量等堆区由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

当我们程序运行前可以分为两个区域分别是:

代码区:

• 存放 CPU 执行的机器指令
• ​ 代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
• ​ 代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令

全局区:

• 全局变量和静态变量存放在此.
• ​ 数据区还包含了常量区, 字符串常量和其他常量也存放在此.
• ​ 该区域的数据在程序结束后由操作系统释放

当程序运行开始:

栈区：

• ​ 由编译器自动分配释放, 存放函数的参数值,局部变量等
• ​ 注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放

int * func()
{
    int a = 10;
    return &a;
}

int main() {

    int *p = func();
    cout << *p << endl; //系统只会保存一次数据（这个正常打印）
    cout << *p << endl; //数据是随机的，因为局部变量已经被释放，系统只保留一次值（相当于标记一次，后面在使用的话，就是随机数）

    return 0;
}

在vs中会打印一次
在vc中报错
提示: address of local variable 'a' returned [-Wreturn-local-addr]
int a = 10;
因为如果函数返回的是局部变量的地址(指针)的话，程序运行就会报错。由于只是把指针（地址）复制后返回了，而指针指向的内存（存储的内容）已经被释放了，这样指针无访问该内存的权限，调用后就会报错。准确的说，函数不能通过返回指向栈内存的指针(注意这里指的是栈，返回指向堆内存的指针是可以的（因为堆内存里面的内容是在整个程序结束才释放，static存在data区里面，也是在整个程序结束才释放）)。

堆区:

• 由程序员分配释放,若程序员不释放,程序结束时由操作系统回收
• ​ 在C++中主要利用new在堆区开辟内存

eg1：

由下面这一段代码来说明每个变量存储的地方：

int a=1;//a为全局变量，放在全局去
const char* str  = "abc";//*str是常量字符串放在文字常量区，str指针放在全局区
class Obj {};

int f(int lhs,int rhs){
    Obj* obj = new Obj();//new开辟的新内存，放在堆区，指针obj放在栈区
    Obj* obj2;//obj2是局部变量，放在栈区
    int aa = a;//aa是局部变量，放在栈区
    delete obj;
    return aa + lhs + rhs;//lhs和rhs都是函数参数值，都放在栈区
}
int main(){
    int *b = new int(2);//new开辟的新内存，放在堆区，指针b放在栈区
    int c = f(a,*b);//局部变量，放在栈区
    delete b;
}

eg2图示:

明确区分栈与堆

首先，我们举一个例子：

void f()
{
    int *p=new int [5];
}

这条短短的一句话就包含了堆与栈，看到 new，我们首先就应该想到，我们分配了一块堆内存，那么指针 p 呢？他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针 p。在程序会先确定在堆中分配内存的大小，然后调用 operator new 分配内存，然后返回这块内存的首地址，放入栈中，他在 VC6 下的汇编代码如下：

这里，我们为了简单并没有释放内存，那么该怎么去释放呢？

是 delete p 么？噢，错了，应该是 delete [ ]p，这是为了告诉编译器：我删除的是一个数组，VC6 就会根据相应的 Cookie 信息去进行释放内存的工作。

堆和栈的区别

好了，我们回到我们的主题：堆和栈究竟有什么区别？

主要的区别由以下几点：

1、管理方式不同；

**　　2、空间大小不同；**

**　　3、能否产生碎片不同；**

**　　4、生长方向不同；**

**　　5、分配方式不同；**

**　　6、分配效率不同；**

管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。

空间大小：一般来讲在 32 位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲，一般都是有一定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M（好像是）。当然，我们可以修改：打开工程，依次操作菜单如下：Project->Setting->Link，在 Category 中选中 Output，然后在 Reserve 中设定堆栈的最大值和 commit。注意：reserve 最小值为 4Byte；commit 是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。

碎片问题：对于堆来讲，频繁的 new/delete 势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的可以参考数据结构，这里我们就不再一一讨论了。

生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。

分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由 malloc 函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。

分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是 C/C++ 函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。

　　从这里我们可以看到，堆和栈相比，由于大量 new/delete 的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址，EBP 和局部变量都采用栈的方式存放。所以，我们推荐大家尽量用栈，而不是用堆。

　　虽然栈有如此众多的好处，但是由于和堆相比不是那么灵活，有时候分配大量的内存空间，还是用堆好一些。

　　无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生以想不到的结果,就算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，说不定什么时候就崩掉，那时候 debug 可是相当困难的）

内存分配中的栈和堆

一般情况下程序存放在Rom（只读内存，比如硬盘）或Flash中，运行时需要拷到RAM（随机存储器RAM）中执行，RAM会分别存储不同的信息，如下图所示：

内存中的栈区处于相对较高的地址，以内存地址的增长方向为上的话，栈地址是向下增长的（即Push压栈时栈顶指针从最高内存地址向下移动）

注意:栈顶是朝着低内存地址方向增长的

栈中分配局部变量空间，堆区是向上增长的用于分配程序员申请的内存空间。另外还有静态区是分配静态变量，全局变量空间的；只读区是分配常量和程序代码空间的；以及其他一些分区。

 int a = 0; //全局初始化区 
 char *p1; //全局未初始化区 
 int main() 
  { 
    int b; //栈 
    char s[] = "abc"; //栈 
    char *p2; //栈 
    char *p3 = "123456"; //123456\0在常量区，p3在栈上。 
    static int c =0； //全局（静态）初始化区 
    p1 = (char *)malloc(10); //堆 
    p2 = (char *)malloc(20);  //堆 
  }

**0.**申请方式和回收方式不同

不知道你是否有点明白了。

堆和栈的第一个区别就是申请方式不同：栈（英文名称是stack）是系统自动分配空间的，例如我们定义一个 char a；系统会自动在栈上为其开辟空间。而堆（英文名称是heap）则是程序员根据需要自己申请的空间，例如malloc（10）；开辟十个字节的空间。

由于栈上的空间是自动分配自动回收的，所以栈上的数据的生存周期只是在函数的运行过程中，运行后就释放掉，不可以再访问。而堆上的数据只要程序员不释放空间，就一直可以访问到，不过缺点是一旦忘记释放会造成内存泄露。还有其他的一些区别我认为网上的朋友总结的不错这里转述一下：

**1.**申请后系统的响应

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

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

也就是说堆会在申请后还要做一些后续的工作这就会引出申请效率的问题。

**2.**申请效率的比较

根据第0点和第1点可知。

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

堆：是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便。

**3.**申请大小的限制

栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。

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

**4.**堆和栈中的存储内容

由于栈的大小有限，所以用子函数还是有物理意义的，而不仅仅是逻辑意义。

栈： 在函数调用时，第一个进栈的是主函数中函数调用后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。

堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

**5.**存取效率的比较

char s1[] = "abcdefg"; 
char *s2 = "hijklo"; 

**abcdefg是在运行时刻赋值的；放在栈中。
而hijklo是在编译时就确定的；放在堆中。 **
**但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。 **

入栈顺序的讲解：

1.函数参数的入栈顺序：自右向左

函数参数的入栈顺序和具体编译器的实现有关。有些参数是从左向右入栈，如：Pascal语言从左到右入栈(不支持变参)，被调用者清栈；有些语言还可以通过修饰符进行指定，如：Visual C++；但是C语言（cdecl）采用自右向左的方式入栈,调用者清栈，通常情况下c/c++默认入栈方式

：__cdel

，也就是以右到左将参数压入堆栈，Windows api使用的是

__stdcall

方式，

__fastcall

适用于对性能要求较高的场合。
这是因为自右向左入栈顺序的好处就是可以动态的变化参数个数。通过堆栈分析可知，自左向右入栈方式中，最前面的参数会被压入栈底。除非知道参数个数，否则无法通过栈指针的相对位移求得最左边的参数。这样就无法实现可变参数。

因此，c/c++采用自右向左入栈顺序，主要是因为实现可变长参数形式

#include<iostream>
using namespace std;
void fun(int a,int b,int c)
{
    cout<<a<<&a<<endl;
    cout<<b<<&b<<endl;
     cout<<c<<&c<<endl;
}
int main()
{
    fun(1,2,3);
    exit(0);
}

我们会发现a->b->c的地址从小到大，栈地址向下增长即a为栈顶，后入栈，c为栈底，先压栈进入

2.局部变量的入栈顺序

在没有栈溢出保护机制下编译时，所有局部变量按系统为局部变量申请内存中栈空间的顺序，即：先申请哪个变量，哪个先入栈，正向的。也就是说，编译器给变量空间的申请是直接按照变量申请顺序执行的。

int main()
{
   int a[]{1,2,3,4,5};
   int b[]{6,7,8,9,10};
   char *arr="love you";
   char *brr="oorik!";
   int m=20;
   int n=30;
   cout<<"a[0]="<<a[0]<<"  "<<"地址="<<&a[0]<<endl;
   cout<<"b[0]="<<b[0]<<"  "<<"地址="<<&b[0]<<endl;
   cout<<"arr="<<arr<<"  "<<"地址="<<static_cast<void*>(&arr)<<endl;//指针所在的地址
   cout<<"arr[0]="<<*arr<<"  "<<"地址="<<static_cast<void*>(arr)<<endl;//字符串首地址

   cout<<"arr[0]="<<arr[0]<<"  "<<"地址="<<static_cast<void*>(&arr[0])<<endl;
   cout<<"arr[0]="<<arr[2]<<"  "<<"地址="<<static_cast<void*>(&arr[2])<<endl;
   
   cout<<"brr="<<brr<<"  "<<"地址="<<static_cast<void*>(&brr)<<endl;
   cout<<"brr[0]="<<brr[0]<<"  "<<"地址="<<static_cast<void*>(&brr[0])<<endl;
   cout<<"brr[0]="<<brr[3]<<"  "<<"地址="<<static_cast<void*>(&brr[3])<<endl;
   cout<<"m="<<m<<"  "<<"地址="<<&m<<endl;
   cout<<"n="<<n<<"  "<<"地址="<<&n<<endl;
}

可以看出入栈顺序：a -> b -> arr->brr -> m -> n(先定义，先压栈)

注意:在C++中，如果cout一个字符数组的话，那么它会沿着这个地址，一直输出这个字符串，直到遇到'\0'

实际上，C++标准库中I/O类对输出操作符<<重载，在遇到字符型指针时会将其当做字符串名来处理，输出指针所指的字符串。既然这样，我们就别让他知道那是字符型指针，所以得进行类型转换，即：希望任何字符型的指针变量输出为地址的话，都要作一个转换，即强制char *转换成void *，如上所示：

在栈溢出保护机制下的编译：

出入栈顺序：brr->arr -> n -> m -> b -> a（char类型先入栈，int类型后入栈；先定义，后压栈）

对于如何区分栈顶栈底:推荐下面的文章

“栈”顶到底是上面还是下面？高地址还是低地址？

栈的生长方向和内存存放方向
栈的生长方向以及内存存储方式

爆肝完工!ヾ(◍°∇°◍)ﾉﾞ加油！