1. C/C++编译的程序占用的内存
1. 1 可以看出，此可执行程序在存储时（没有调入到内存）分为代码区（text）、数据区（data）和未初始化数据区（bss）3个部分。
（1）代码区（text segment）
放CPU执行的机器指令（machine instructions）。
（2）全局初始化数据区/静态数据区（initialized data segment/data segment）
该区包含了在程序中明确被初始化的全局变量、静态变量（包括全局静态变量和局部静态变量）和常量数据（如字符串常量）。
例如，一个不在任何函数内的声明（全局数据）：
int i = 0; /*变量i根据初始值存放到全局初始化数据区*
char *str = "abcd" /*abcd存放在文字常量区*/（3）未初始化数据区（uninitialized data segment），也称BSS区（block started by symbol）
该区存放程序中未初始化的全局变量。
static int i; /*假设声明在函数外*/1.2 一个正在运行着的C编译程序占用的内存分为代码区、初始化数据区、未初始化数据区、堆区和栈区5个部分。
（4）栈区
栈又称堆栈，英文statck，由编译器自动分配释放，存放函数的参数值、局部变量的值等（不包括static声明的变量，static意味着在数据段中存放变量）。除此之外，在函数被调用时，栈用来传递参数和返回值。由于栈先进先出的特点，栈特别方便的用来保存和恢复调用现场。
（5）堆区
用于动态内存分配。堆在内存中位于bss区和栈区之间。一般由程序员分配和释放，若程序员不释放，程序结束时有可能由OS回收。
C程序执行时的内存分配情况示例：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int a = 0; /*全局初始化区*/
int b; /*全局未初始化区 BSS*/
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); /*分配得来得10和20字节的区域就在堆*/
strcpy( p1, "123456"); /*123456/0在常量区，编译器可能会将p1与p3指向的"123456"优化成一个地方*/
return 0;
}2. 堆和栈的理论知识
2.1 stack和heap的概念
栈，又叫堆栈（stack）, 由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
堆，英文叫 heap, 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回 收 。注意它与数据结构中的堆是两回事，分配方式类似于链表。
2.2 stack和heap的差别
（1）申请方式
stack——由程序在执行时系统自动分配。例如:
void fun(){
int i; /*声明在函数中一个局部变量i; 系统自动在栈中为i开辟空间 */
}heap——需要程序员自己申请，并指明大小，在c中是malloc函数 。
函数原型是：void *malloc( size_t size )
void fun(){
char *p; /*p变量的地址存在在栈中*/
p =(char *) malloc( 100 ); /*从堆中申请100个字节的空间，并将该内存强制转换称char*型，首地址给p*/
}
（2）申请后系统的响应
栈——只要栈的剩余空间大于所申请的空间，系统将为程序提供内存，否则将报异常提示栈溢出。
堆——首先操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中那个删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中你给的首地址处记录本次分配的大小，这样，代码中free语句才能正确释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统自动的将多余的那部分重新放入空闲链表中。
（3）申请大小的限制
栈——在windows下，栈是向低地址扩展的数据结构，是一块连续的内存区域，栈顶的地址和栈的最大容量是系统在编译时预先规定好的，如果申请的空间超过栈的剩余空间时，将提示overflow，因此能从栈获得的空间较小。
#include <stdio.h>
#include <stdlib.h>
int i = 1; /*记录申请的次数*/
void fun()
{
char a[1024*1024] /*一次申请 1M */
printf( "NO.%d %ld 字节 地址：%p\n")，i, sizeof(a), a );
i++;
fun();
}
int main()
{
fun();
return 0;
}
共申请了7M，第8次申请失败，因为栈里面还保存了其他数据，如main函数的参数，所以第8次申请不足1M，运行结果和ulimit查看的信息吻合。
堆——堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址，堆的大小受限于计算机系统的有效虚拟内存，所以堆获得的空间比较灵活，也比较大。
（4）申请的效率
栈——由系统自动分配，速度比较快，但程序员是无法控制的。
堆——由malloc分配的内存，一般速度比较满，而且容易产生内存碎片，但用起来最方便。
（5）栈和堆存储的内容
栈——存储的主函数中函数调用后的下一条指令的地址、局部变量等。
堆——一般在堆的头部用一个字节存放堆的大小，堆的内容由程序员自行安排。
（6）是否产生碎片
对于堆来说，频繁的malloc/free势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低（虽然程序在退出后操作系统会对内存进行回收管理）。对于栈来说，则不回存在这个问题。
3. 内存分配方式
内存分配方式有两种：一种是静态分配，一种是动态分配。
3.1 静态分配与动态分配的区别
（1） 时间不同
静态分配发生在程序编译和链接的时候，动态分配则发生在程序调入和执行的时候。
（2）空间不同
堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由函数malloc进行分配，free函数进行回收。不过栈的动态分配与堆的动态分配不同，它是由编译器进行释放，无需程序员手工实现。
（3）静态对象是有名字的变量，可以直接对其进行操作，而动态对象是没有名字的变量，需要通过指针间接的对它操作。
4. 实例分析
#include<stdio.h>
#include<stdlib.h>
int a = 0; /*全局初始化区*/
int i; /*全局未初始化区 BSS*/
char *p1; /*全局未初始化区 BSS*/
void fun(); /*代码段*/
#define SHOW_ADR(ID,CATE,I) printf( "变量 %2s 存储在 %2s 中，其地址为： %8x\n", ID, CATE, &I)
#define SHOW_POINT_TO(ID,CATE,I) printf( "指针 %2s 存储在 %2s 中，它指向的地址为: %8x\n", ID,CATE, I)
#define SHOW_FUN(ID,CATE,I) printf( "函数 %2s 存放在 %2s 中，其地址为: %8x\n", ID,CATE, I )
int main()
{
SHOW_FUN("main","code segment", main);
SHOW_FUN("fun","code segment", fun);
SHOW_ADR("a","data segment",a);
SHOW_ADR("i","BSS",i);
SHOW_ADR("p1","BSS",p1);
SHOW_POINT_TO("p1","BSS",p1);
int b; /*栈区*/
SHOW_ADR("b","stack area",b);
char s[] = "abc"; /*栈区*/
SHOW_ADR("s","stack area",s);
char *p2; /*栈区*/
SHOW_ADR("p2","stack area",p2);
char *p3 = "123456"; /*栈区*/
SHOW_ADR("p3","stack area",p3);
SHOW_POINT_TO("p3","stack area",p3);
static int c =0; /*静态存储区，数据段*/
fun();
p1 = (char *)malloc(10); /*堆区*/
p2 = (char *)malloc(20);
printf( "malloc之后 %2s 它指向的堆首地址为: %8x, 尾地址是： %8x\n", "p1", p1, p1+10);
printf( "malloc之后 %2s 它指向的堆首地址为: %8x, 尾地址是： %8x\n", "p2", p2, p2+20);
free(p1); /*释放堆区内存*/
free(p2);
return 0;
}
void fun()
{
static int d = 0; /*静态存储区，数据段*/
d++;
SHOW_ADR("d","data segment",d);
}程序运行结果如下：
变量存储位置如下图所示:
5. 内存管理函数
5.1 malloc/free函数
5.1.1 函数原型及说明
（1）void *malloc( size_t size )：
该函数分配了size个字节，并返回了指向这块内存的指针。如果分配失败，则返回一个空指针（NULL）。
（2）void free(void *ptr):
该函数将之前malloc函数申请的内存重新交还给操作系统，也就是释放这块内存
5.1.2 函数的用法
int main()
{
char *ptr;
ptr = (char*)malloc(100*sizeof(char)); //申请100个字节的内存
if( NULL = ptr)
exit( 1 ); //内存分配不成功
... //使用ptr的过程
free(ptr); //释放内存
ptr = NULL; //将该ptr指向NULL，防止野指针
}5.1.3 函数使用的注意事项
（1）申请了内存空间后，必须检查是否分配成功。
（2）当不需要再使用申请的内存时，记得释放；释放后应该把指向这块内存的指针指向NULL，防止程序后面不小心使用了它。
（3）这两个函数应该是配对。如果申请后不释放就是内存泄露；如果无故释放那就是什么也没有做。释放只能一次，如果释放两次及两次以上会出现错误（释放空指针例外，释放空指针其实也等于啥也没做，所以释放空指针释放多少次都没有问题）。
（4）虽然malloc()函数的类型是(void ),任何类型的指针都可以转换成(void ),但是最好还是在前面进行强制类型转换，因为这样可以躲过一些编译器的检查。
5.2 realloc函数
5.2.1 函数原型及说明
realloc() 函数用来重新分配内存空间，其原型为：
void* realloc (void* ptr, size_t size);
其中ptr 为需要重新分配的内存空间指针，size 为新的内存空间的大小。realloc() 对 ptr 指向的内存重新分配 size 大小的空间，size 可比原来的大或者小，还可以不变（如果你无聊的话）。当 malloc()、calloc() 分配的内存空间不够用时，就可以用 realloc() 来调整已分配的内存。
5.2.2 函数的用法
int main()
{
char *ptr;
char *more_ptr;
ptr = (char*)malloc(10*sizeof(char)); //申请100个字节的内存
if( NULL = ptr)
exit( 1 ); //内存分配不成功
... //使用ptr的过程
more_ptr = realloc( ptr, 100*sizeof(char)); //重新申请100个字节的内存
if( NULL = more_ptr)
exit( 1 ); //内存分配不成功
... //使用more_ptr的过程
free(more_ptr); //释放内存
ptr = NULL; //将该ptr指向NULL，防止野指针
}5.2.3 函数使用的注意事项
(1) 指针 ptr 必须是在动态内存空间分配成功的指针，形如如下的指针是不可以的：int *i; int a[2]；会导致运行时错误，可以简单的这样记忆：用 malloc()、calloc()、realloc() 分配成功的指针才能被realloc() 函数接受。
(2) 成功分配内存后 ptr 将被系统回收，一定不可再对 ptr 指针做任何操作，包括 free()；相反的，可以对 realloc() 函数的返回值进行正常操作。
(3) 如果是扩大内存操作会把 ptr 指向的内存中的数据复制到新地址（新地址也可能会和原地址相同，但依旧不能对原指针进行任何操作）；如果是缩小内存操作，原始据会被复制并截取新长度。
(4) 如果 ptr 为 NULL，它的效果和 malloc() 相同，即分配 size 字节的内存空间。如果 size 的值为 0，那么 ptr 指向的内存空间就会被释放，但是由于没有开辟新的内存空间，所以会返回空指针；类似于调用 free()。
5.3 calloc函数
5.3.1 函数原型及说明
函数原型：void *calloc(size_t n, size_t size)；
calloc函数在内存的动态存储区中分配n个长度为size的连续空间，函数返回一个指向分配起始地址的指针；如果分配不成功，返回NULL。
calloc类似于malloc函数，只是calloc在动态分配完内存后，自动初始化该内存空间为零，而malloc不初始化，里边数据是随机的垃圾数据。
5.3.2 函数的用法
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
char*str = NULL;
str = (char*)calloc(10,sizeof(char)); /*分配内存空间*/
if( NULL == str)
exit(1);
strcpy(str, "Hello"); /*将hello写入*/
printf("String is %s\n",str); /*显示变量内容*/
free(str); /*释放空间*/
return 0;
}5.3.3 函数使用的注意事项
函数的返回值类型是 void *，void 并不是说没有返回值或者返回空指针，而是返回的指针类型未知。所以在使用 calloc() 时通常需要进行强制类型转换，将 void 指针转换成我们希望的类型，例如：
char *ptr = (char *)calloc(10, 10); // 分配100个字节的内存空间5.4 alloca函数
这个函数的作用是可以从栈里动态分配内存，如果函数A中的某个局部变量在定义时并不知道它有多大，那么就可以将需要使用的空间大小通过函数A的某个参数传递进来，在函数A内部使用alloca分配一块栈内存，alloca函数返回的是这块内存的首指针；不用担心内存泄露问题，因为在函数A返回时，通过alloca申请的内存就会被自动释放掉。