C语言中堆和栈的区别
一.引言：
可执行程序在存储时（没有调到内存）分为代码区（text）、数据区（data）和未初始化数据区（bss）3个部分。
（1）代码区（text segment）。存放CPU执行的机器指令。通常，代码区是可共享的（即另外的执行程序可以调用它），因为对于频繁被执行的程序，只需要在内存中有一份代码即可。代码区通常是只读的，使其只读的原因是防止程序意外地修改它的指令。另外，代码区还规划了局部变量的相关信息。
（2）全局初始化数据区/静态数据区（initialized data segment/data segment）。该区包含了在程序中明确被初始化的全局变量、静态变量（包括全局静态变量和局部静态变量）和常量数据（如字符串常量）。
（3）未初始化数据区（BSS区，uninitialized data segment），存入的是全局未初始化变量、未初始化的静态变量。BSS区的数据在程序开始执行之前被内核初始化为0或者空指针（NULL）。
上图表示可执行代码存储时结构和运行时结构的对照图。一个正在运行着的C编译程序占用的内存分为代码区、初始化数据区、未初始化数据区、堆区和栈区5个部分。
（1）代码区，代码区指令根据程序设计流程依次执行，对于顺序指令，则只会执行一次（每个进程），如果反复，则需要使用跳转指令，如果进行递归，则需要借助栈来实现。
代码区的指令中包括操作码和要操作的对象（或对象地址引用）。如果是立即数（即具体的数值），将直接包含在代码中；如果是局部数据，将在栈区分配空间，然后引用该数据地址；如果是BSS区和数据区，在代码中同样将引用该数据地址。
（2）全局初始化数据区/静态数据区：只初始化一次。
（3）未初始化数据区（BSS）：在运行时改变其值。
（4）栈区(stack)：由编译器自动分配释放，存放函数的参数值、局部变量的值等。其操作方式类似于数据结构中的栈。
每当一个函数被调用，该函数返回地址和一些关于调用的信息，比如某些寄存器的内容，被存储到栈区。然后这个被调用的函数再为它的自动变量和临时变量在栈区上分配空间，这就是C实现函数递归调用的方法。每执行一次递归函数调用，一个新的栈框架就会被使用，这样这个新实例栈里的变量就不会和该函数的另一个实例栈里面的变量混淆。
函数调用时计算机会分配一块内存，这个内存就是调用栈。函数调用都会使用栈内存。栈区的局部变量在函数调用结束后会被释放，函数中的局部变量会随函数的销毁而销毁。
（5）堆区（heap）：用于动态内存分配。堆在内存中位于BSS区和栈区之间。一般由程序员分配和释放，若程序员不释放，则可能会引起内存泄漏。注:堆和数据结构中的堆栈不一样，其类似于链表。
之所以分成这么多个区域，主要基于以下考虑：
1、一个进程在运行过程中，代码是根据流程依次执行的，只需要访问一次，当然跳转和递归有可能使代码执行多次，而数据一般都需要访问多次，因此单独开辟空间以方便访问和节约空间。
2、临时数据及需要再次使用的代码在运行时放入栈区中，生命周期短。
3、全局数据和静态数据有可能在整个程序执行过程中都需要访问，因此单独存储管理。
4、堆区由用户自由分配，以便管理。
下面是网上一个典型的例子来帮助理解C程序内存分配：
int a = 0; //a在全局已初始化数据区
char *p1; //p1在BSS区（未初始化全局变量）
void main()
{
int b; //b在栈区
char s[] = "abc"; //s为数组变量，存储在栈区，“abc”为字符串常量，存储在已初始化数据区
char *p1, p2; //p1、p2在栈区 这里我觉得p2不是指针类型，下面直接malloc有问题,用dev C显示不是指针，VC编译器下也不是指针类型
char *p3 = "123456"; //123456\0在已初始化数据区，p3在栈区
static int c = 0; //c为全局（静态）数据，存在于已初始化数据区
//另外，静态数据会自动初始化
p1 = (char *)malloc(10); //分配得来的10个字节的区域在堆区
p2 = (char *)malloc(20); //分配得来的20个字节的区域在堆区
free(p1);
free(p2);
}内存分配方式：
在C语言中，对象可以使用静态或动态的方式分配内存空间。
1.静态分配：编译器在处理程序源代码时分配。
动态分配：程序在执行时调用malloc库函数申请分配。
2.静态对象的分配与释放由编译器自动处理；
动态对象的分配与释放必须由程序员显式地管理，它通过malloc()和free()两个函数（C++中为new和delete运算符）来完成。
3.静态内存分配是在程序执行之前进行的，因而效率比较高，
而动态内存分配则可以灵活处理数据。
静态与动态内存分配的主要区别如下：
静态对象是有名字的变量，可以直接对其进行操作；
动态对象是没有名字的变量，需要通过指针间接地对它进行操作。
注：如果我们在程序中有写malloc，它是静态对象还是动态对象（这是针对“动态对象是没有名字的变量”）
解答，malloc出来的就是在堆中开辟内存空间，是没有名字的。
如：p1 = (char *)malloc(sizeof(int)); //此行代码分配了一个int类型大小的区域在堆区（对象），然后返回对象在内存中的地址，接着这个地址被用来初始化指针对象p1,对于动态分配的内存唯一的访问方式是通过指针间接地访问。
int *p; //p中的地址所指向的内容
p; //p这个变量的内容，这里p存的是地址，则为地址
&p; //取p的地址二.堆和栈的区别
1.申请方式
(1)栈（satck）:由系统自动分配。例如，声明在函数中一个局部变量int b; 系统自动在栈中为b开辟空间，函数返回后，b的内存被释放。
(2)堆（heap）:需程序员自己申请（调用malloc,realloc,calloc）,并指明大小，并由程序员手动进行释放。注：操作不当，容易产生memory leak.
eg: char *p;
p = (char *)malloc(sizeof(char));
但是，p本身是在栈中。
2.申请大小的限制
（1）栈：在windows下，栈是向低地址扩展的数据结构，是一块连续的内存区域(它的生长方向与内存的生长方向相反)。栈的大小是固定的。如果申请的空间超过栈的剩余空间时，将提示overflow。
（2）堆：堆是高地址扩展的数据结构（它的生长方向与内存的生长方向相同），是不连续的内存区域。这是由于系统使用链表来存储空闲内存地址的，自然是不连续的，而链表的遍历方向是由底地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。
3.系统响应：
（1）栈：只要栈的空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。
（2）堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的free语句才能正确的释放本内存空间。另外，找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。
说明：对于堆来讲，对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，
4.申请效率
（1）栈由系统自动分配，速度快。但程序员是无法控制的
（2）堆是由malloc分配的内存，一般速度比较慢，而且容易产生碎片，不过用起来最方便。
5.堆和栈中的存储内容
（1）栈：在函数调用时，第一个进栈的是主函数中函数调用后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续执行。
（2）堆：一般是在堆的头部用一个字节存放堆的大小。
6.存取效率
（1）堆：char *s1=”hellow tigerjibo”;是在编译时就确定的
（2）栈：char s1[]=”hellow tigerjibo”;是在运行时赋值的；用数组比用指针速度更快一些，指针在底层汇编中需要用edx寄存器中转一下，而数组在栈上读取。
补充：
栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。
7.分配方式：
（1）堆都是动态分配的，没有静态分配的堆。
（2）栈有两种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的。它的动态分配是由编译器进行释放，无需手工实现。
三、我们说一下JAVE中的堆和栈 (与C/C++类似)：
栈内存:栈内存首先是一片内存区域，存储的都是局部变量，凡是定义在方法中（函数中）的都是局部变量（方法外的是全局变量），for循环内部定义的也是局部变量，是先加载函数才能进行局部变量的定义，所以方法先进栈，然后再定义变量，变量有自己的作用域，一旦离开作用域，变量就会被释放。栈内存的更新速度很快，因为局部变量的生命周期都很短。
堆内存:存储的是数组和对象（其实数组就是对象），凡是new建立的都是在堆中，堆中存放的都是实体（对象），实体用于封装数据，而且是封装多个（实体的多个属性），如果一个数据消失，这个实体也没有消失，还可以用，所以堆是不会随时释放的，但是栈不一样，栈里存放的都是单个变量，变量被释放了，那就没有了。堆里的实体虽然不会被释放，但是会被当成垃圾，Java有垃圾回收机制不定时的收取。
所以堆与栈的区别很明显：
1.栈内存存储的是局部变量而堆内存存储的是实体；
2.栈内存的更新速度要快于堆内存，因为局部变量的生命周期很短；
3.栈内存存放的变量生命周期一旦结束就会被释放，而堆内存存放的实体会被垃圾回收机制不定时的回收(Java有一个自动内存回收机制)。
四、return返回指向局部变量的指针或引用
在C语言中，局部变量的作用域只在函数内部，在函数返回后，局部变量的内存就会被释放。如果函数只是返回局部变量，那么这个局部变量会被复制一份传回被调用处。但是如果函数返回的是局部变量的地址，那么就会报错，因为函数只是把指针复制后返回了，但是指针指向的内容已经被释放，这样指针指向的内容就是不可预料的内容，程序就会出错。准确的来说，函数不能通过返回指向栈内存的指针（返回指向堆内存的指针是可以的）。
所谓函数的返回值，在编译器生成的汇编实现层面看，一般是被调函数在返回前，最后放到EAX寄存器中的值。函数调用者读取EAX，就得到了所谓的函数返回值。函数中return 返回啥其实都是返回值的拷贝！ 返回整数就是整数的拷贝，指针就是指针值拷贝，但不会拷贝被指向的内容。函数中的局部变量是存于栈中，函数结束后会释放栈中内容，指针指向的值也就被释放了，访问时是错误的值。但如果是堆内存空间，可以返回，即在函数中用new申请的空间，是可以返回的。
永远不要从函数中返回局部自动变量的地址。如果你真的需要这样操作。你可以在函数的参数表中传入一个指针变量，然后将需要写入的数据写入到该指针变量指向的地址。由于该指针指向的变量的作用域在函数体 之外。因此不会在函数结束结束时被回收。
C++/C不可以返回局部变量的引用或指针，所谓的不可以返回局部变量的引用或指针，指的是不能返回局部变量的引用或地址给引用或指针。返回引用事实上是返回变量的地址。
在C语言中为什么说绝不能返回函数内局部变量的地址？
在程序中，只在特定的过程或函数中可以访问的变量，是相对与全局变量而言的。
全局变量也称为外部变量，是在函数的外部定义的，它的作用域为从变量定义处开始，到本程序文件的末尾。全局变量全部存放在静态存储区，在程序开始执行时给全局变量分配存储区，程序行完毕就释放。
局部变量可以和全局变量重名，但是局部变量会屏蔽全局变量。在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。
局部变量的特点是：是在函数内部定义的变量，随函数调用时创建 随函数结束时析构（销毁）。
设想，如果返回了一个局部变量的指针，而恰好局部变量偏偏又在函数结束后销毁，但指针并没有被销毁，而是被返回，那也就是说，指针指向的正是一个被销毁了的对象。
一般的来说，函数是可以返回局部变量的。 局部变量的作用域只在函数内部，在函数返回后，局部变量的内存已经释放了。因此，如果函数返回的是局部变量的值，不涉及地址，程序不会出错。但是如果返回的是局部变量的地址(指针)的话，程序运行后会出错。因为函数只是把指针复制后返回了，但是指针指向的内容已经被释放了，这样指针指向的内容就是不可预料的内容，调用就会出错。准确的来说，函数不能通过返回指向栈内存的指针(注意这里指的是栈，返回指向堆内存的指针是可以的)。
函数中定义的变量(包括数组都是局部变量，都存在栈中)，不能返回指向局部变量的指针。
函数中定义的数组是在栈中，是局部变量，在函数结束后会释放。不能直接返回函数中定义的数组，会被释放掉。
函数内部的字符串存放在数组中是局部变量；而字符串字面量”abc”是静态变量，会一直保存到程序结束，可以返回指向这个字符串常量的指针。
注：C语言自定义函数如何返回数组：1、直接声明全局变量的数组；2、通过堆区用malloc动态开辟内存解决；3、传入指向函数外的数组的指针；4、函数中数组在声明时候加static，改变数组的存储属性；
下面以函数返回局部变量的指针举几个典型的例子来说明：
1、返回一个指向字符串常量的指针。
#include <stdio.h>
char *returnStr()
{
char *p="hello world!";
return p;
}
int main()
{
char *str;
str=returnStr();
printf("%s\n", str);
return 0;
}这个没有任何问题，因为"hello world!"是一个字符串常量，存放在只读数据段，把该字符串常量存放的只读数据段的首地址赋值给了指针，所以returnStr函数退出时，该该字符串常量所在内存不会被回收，故能够通过指针顺利无误的访问。
2、
#include <stdio.h>
char *returnStr()
{
char p[]="hello world!";
return p;
}
int main()
{
char *str;
str=returnStr();
printf("%s\n", str);
return 0;
}数组p中的"hello world!"是局部变量存放在栈中。当returnStr函数退出时，栈要清空，局部变量的内存也被清空了，所以这时的函数返回的是一个已被释放的内存地址，所以有可能打印出来的是乱码。
3、
int func()
{
int a;
....
return a; //允许
}
int * func()
{
int a;
....
return &a; //无意义，不应该这样做
} 局部变量也分局部自动变量和局部静态变量，由于a返回的是值，因此返回一个局部变量是可以的，无论自动还是静态，因为这时候返回的是这个局部变量的值，但不应该返回指向局部自动变量的指针，因为函数调用结束后该局部自动变量被抛弃，这个指针指向一个不再存在的对象，是无意义的。但可以返回指向局部静态变量的指针，因为静态变量的生存期从定义起到程序结束。
4、如果函数的返回值非要是一个局部变量的地址，那么该局部变量一定要申明为static类型。即：使用静态数组，如下：
#include <stdio.h>
char *returnStr()
{
static char p[]="hello world!";
return p;
}
int main()
{
char *str;
str=returnStr();
printf("%s\n", str);
return 0;
}5： 数组是不能作为函数的返回值的，原因是编译器把数组名认为是局部变量（数组）的地址。返回一个数组一般用返回指向这个数组的指针代替，而且这个指针不能指向一个自动数组，因为函数结束后自动数组被抛弃，但可以返回一个指向静态局部数组的指针，因为静态存储期是从对象定义到程序结束的。如下：
int* func( void )
{
static int a[10];
........
return a;
}6：返回指向堆内存的指针是可以的
char *GetMemory3(int num)
{
char *p = (char *)malloc(sizeof(char) * num);
return p;
}
void Test3(void)
{
char *str = NULL;
str = GetMemory3(100);
strcpy(str, "hello");
cout<< str << endl;
free(str);
}程序在运行的时候用 malloc 申请任意多少的内存,程序员自己负责在何时用 free释放内存。动态内存的生存期由程序员自己决定,使用非常灵活。
参考博客：
------1------- 原文：https://blog.csdn.net/tigerjibo/article/details/7423728
------2------- 原文：https://blog.csdn.net/pt666/article/details/70876410
------3------- 原文：https://blog.csdn.net/x_chengqq/article/details/51190678
------4------ 原文：https://blog.csdn.net/u012317833/article/details/40779297
------5------ 原文：https://blog.csdn.net/yang382197207/article/details/25873039
