来自：漫谈C语言内存管理_c语言内存管理机制-CSDN博客

C语言学习笔记 —— 内存管理_c语言内存管理-CSDN博客

C语言是音视频开发所必须的。

变量是一段连续内存空间的别名。变量的类型是固定内存大小的别名。但是类型不是只确定了变量内存大小，还确定了变量是小数、整数还是字符。

linux32下的C的内存模型：

解释这些区：

代码区属于存放程序指令，常量区、全局数据区、堆区、栈区属于存放程序数据。程序代码区、常量区、全局数据区在程序加载到内存后就分配好了，并且在程序运行期间一直存在，大小固定，只能等到程序运行结束后由操作系统收回。栈区、堆区在程序运行时动态开辟。

数据区域可读写，代码区域只可读，所以分区之后呢，可以将程序指令区域和数据区域分别设置成可读可写或只读。这样分有利于防止代码篡改。

• 程序指令区域：多个同样的程序一起运行的话，可以共享存储在指令区域的那一份程序代码，只是每一个程序运行中的数据不一样而已，这样可以节省大量的内存。
• 数据区域：下面的1、2、3、4.

1、全局数据区

存储定义在函数外部的变量，可；

以被全局（其他文件）访问到。（一个区域的边界是一对花括号{}）

2、常量区

存储字符串常量和const修饰的变量。

3、栈（stack）

（1）栈由系统进行内存的管理。函数被调用时（一开始被调用就压入，而不是遇到递归函数的时候压入），会将参数、局部变量/临时变量/栈变量、返回地址、保存的上下文等与函数相关的信息压入栈中，函数执行结束后，系统自行释放栈区内存，不需要编程人员管理，这些信息都将被销毁。所以局部变量、参数只在当前函数中有效（函数中使用参数本质也是在函数栈中创建一块内存把参数拷贝过来(好像有误)，所以两块区域，一个实参，一个形参。传递参数的方式可以是传值、传引用或传指针），不能传递到函数外部，因为它们的内存不在了。另外栈属于线程私有。

这里每个函数栈都会保存自己的栈底指针ebp，一边在下一个函数栈被回收之后，ebp可以指到自己函数栈的栈底，以便恢复现场。

（2）程序启动时会为栈区分配一块大小适当的内存，对于一般的函数调用这已经足够了，函数进栈出栈只是 ebp、esp 寄存器指向的变换，或者是向已有的内存中写入数据，不涉及内存的分配和释放。我们经常听说“栈内存的分配效率要高于堆”就是这个道理，因为大部分情况下并没有真的分配栈内存，仅仅是对已有内存的操作。

linux的栈默认大小8M，用ulimit -s查看。

$ ulimit -s
8192

（3）特点：

• 运行时自动分配和自动回收（和堆不一样，栈是自动管理的，程序员不需要手工干预）；
• 脏内存（内存优先，回收后不会清理那一块用过内存区，因此分配到时如果没有初始化会保留原来的值）
• 临时性。函数不能返回局部变量的指针，因为返回后局部变量的空间被回收，指针变成了野指针。
• 栈会溢出。

4、堆（heap）

（1）堆的大小不定，可以动态扩张（用malloc/new）或缩减（用free/delete）

（2）手动申请，手动释放；malloc/new申请堆；堆完全由程序员掌控（也是唯一由程序员完全控制的内存区域），想分配多少就分配多少（用malloc/new），想什么时候释放就什么时候释放（用free/delete）；

（3）堆和栈比，区别：容量没有固定；容量大于栈；分配效率比栈低；要手动释放，引入了内存泄漏问题（所以一个malloc后面必须有一个free来释放）。

内存泄漏问题：

例1：

int main()
{
    char *p;
    p = (char *)malloc(100);
    p = "hello world"; // p指向其他地方，把字符串的首地址赋给p；这样子导致原本堆区的空间找不到了
    //从此刻起，再也找不到申请的100个字节的空间，动态申请的100个字节被泄漏了
    return 0;
}

（4）堆跟全局数据区比，区别：生命周期不一样，堆内存的生命周期是从malloc开始到free结束，而全局变量是从整个程序一开始执行就开始，直到整个程序结束才会消灭，伴随程序运行的一生。堆的使用比全局变量广泛。

（5）跟堆相关的几个函数：

① malloc():

注意：

• 使用malloc()开辟空间需要保存开辟好的地址空间的首地址，在调用free()归还这段内存之前，指向这段内存的指针p一定不能丢，也就是不能给p另外赋值。因为p一旦丢失这段malloc()来的内存就永远的丢失了，就会造成内存泄漏，直到当前程序结束时操作系统才会回收这段内存。
• 由于不确定空间用于做什么，所以malloc()返回值为void *类型的指针，所以在调用函数时根据接收者的类型对其进行强制转换。实质上malloc()返回的是堆管理器分配给本次申请的那段内存空间的首地址，也就是一个数字，这个数字表示一个内存地址。

使用举例。向堆申请了 n个int 大小的空间，经过malloc()返回的是这个空间的首地址，类型是void *，再经过(int *)强制类型转换变成了int型指针。

arr = (int *)malloc(n * sizeof(int));

② calloc()：

注意：

• malloc()申请的内存，内存中存放的内容是随机的，不确定的，而calloc()函数申请的内存中的内容为0。

③ realloc()：

注意：

• malloc()、calloc()、realloc()动态申请的内存，都只有在free()或程序结束时才被释放。

④ free()

注意：

• free()后，因为没有给p赋值，所以p还是指向原先动态申请的内存，但内存已经不能再使用了，p变成野指针。一般为了防止野指针，会在free()完毕之后对p赋为NULL。
• 一块动态申请的内存，只能free一次，不能多次free。

以上①、②、③、④的头文件都是#include<stdlib.h>。都在C里面使用。

全局数据区、常量区、堆区、栈区的区分。区分下面的char *str2和char arr[]。在函数里面，静态变量和常量（一般的字符串）不在栈里面。

#include <stdio.h>
char *str1 = "c.biancheng.net";  //字符串在常量区，str1在全局数据区
int n;  //全局数据区
char* func(){
    char *str = "C语言";  //字符串在常量区，str在栈区
    return str;
}
int main(){
    int a;  //栈区
    char *str2 = "01234";  //字符串在常量区，str2在栈区
    char arr[] = "hello world!"; //注意字符数组存放的字符串不是常量，是可读可写的
    char  arr[20] = "56789";  //字符串和arr都在栈区
    char *pstr = func();  //栈区
    int b;  //栈区  
    int *ip = (int*)malloc(N * sizeof(int) //ip 在栈区，指向的内存在堆区
    return 0;
}

栈分配的内存在函数执行后释放：

char* testStack(){
    char p[] = "hello world!"; //字符串在栈区存储 
    printf("in testStack %s\n", p);
    return p;
}

int main() {
    char* p = NULL;
    p = testStack();
    printf("out of testStack %s\n",p); //返回的是函数中的字符串的地址

    return 0;
}

对比：

char* testStack(){
    char *p = "hello world!"; //在常量区存储 
    printf("in testStack %s\n", p);
    return p;
}

堆的变量在手动释放前不会被释放，get()结束之后p的空间没有被回收。下面p指针和p指向的对象都存储在堆空间里面。

int *get()
{
    int *p = (int *)malloc(sizeof(int));//申请了一个堆空间
    *p = 10;
    return p;
}

int main(){
    int *x = get();
    printf("x: %d\n", *x);
}

static变量是全局的。无论定义在全局还是函数局部。

全局static就不需要证明了，看下static局部变量的情况：

int testStatic() {
    static int s = 0;
    s = s + 1;
    return s;
}

int main() {

    for (int i = 0;i<=10;i++){
        int a = testStatic();
        printf("a = %d\n", a);
    }
}

内存对齐：

为什么要内存对齐？如32位CPU指的是寄存器32位，所以一次可以处理4个字节的数据，这4个字节是一个字。步长可以是一个 字、半字、字节（可多选），每次就从内存里面读取一个步长的数据。cpu寻址采用了步长进行寻址，并且只对编号为一定数据量的倍数的内存寻址（下面图中的步长是4个字节，不一定严格为4倍数，假如最起始的地址不是0）。解释就是：选择了按字寻址（步长是一个字）的话，字地址一定是4的整数倍；选择了按半字寻址的话，半字地址一定是2的整数倍。

一个变量（≤一个步长的话）最好位于一个步长里面，编译器会自动将一个数据尽量放在一个步长之内，避免跨步长存储。这就是内存对齐。

证明内存对齐：

struct {
    int a;
    char b;
    double c;
} t = {10, 'C', 20.1};

int main() {
	//先打印出当前环境每种类型的大小
    printf("int length: %d\n", sizeof(int));
    printf("char length: %d\n", sizeof(char));
    printf("double length: %d\n", sizeof(double));
	//打印出结构体的大小
    printf("struct length: %d\n", sizeof(t));
    printf("&a: %X\n&b: %X\n&c: %X\n", &t.a, &t.b, &t.c);
    return 0;
}

结构体修改后对比：

struct {
    char a;
    short b;
    int c;
} t = {'C', 10, 20};

b是一个半字，所以地址是2的倍数。c是一个字，所以地址是4的倍数。

内存越界

• 访问到野指针指向的区域，越界访问
• 数组下标越界访问
• 使用已经释放的内存
• 企图访问一段释放的栈空间
• 容易忽略字符串后面的’\0’

忽略了字符串后面的'\0'——为指针分配了内存，但是内存大小不够，导致出现越界错误。

char *p1 = “abcdefg”;
char *p2 = (char *)malloc(sizeof(char)*strlen(p1));
strcpy(p2,p1);