C语言动态内存管理———超级全！快来看！

内存管理———超级全！快来看！"/>

C语言动态内存管理———超级全！快来看！

C语言动态内存管理———超级全！快来看！

文章目录

• C语言动态内存管理———超级全！快来看！
• • 一、为什么要用动态内存
  • 二、动态内存函数
  • • 1.malloc和free
    • • ①malloc
      • ②.free
      • ③举例
      • • a.内存的空间
        • b.栗子
    • 2.calloc
    • 3.realloc
  • 三、动态内存分配常见错误
  • • 1.常见错误
    • 2.经典例题
  • 四、柔性数组
  • 五、C/C++程序中内存区的划分

一、为什么要用动态内存

int i = 0;
int arr[10] = { 0 };

上述两种向内存申请空间的方式有一个很大的弊端，就是不能灵活的调整申请的内存空间的大小。C语言引入动态内存分配，让程序员可以自己申请和释放空间。

二、动态内存函数

1.malloc和free

①malloc

void* malloc(size_t sz);

这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。

如果开辟成功，则返回⼀个指向开辟好空间的指针。

如果开辟失败，则返回⼀个NULL指针，因此malloc的返回值⼀定要做检查。

返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。

如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。这样申请一个字节长度为0的内存空间毫无意义。

②.free

void free(void* ptr);

free函数用来释放动态开辟的内存。

如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。 程序会崩溃

如果参数 ptr 是NULL指针，则函数什么事都不做。

释放后的内存空间我们就没有使用权限了，但是ptr还记得这个地址，这个指针就成了野指针，我们要把他变成NULL。

③举例

a.内存的空间

动态内存的函数的头文件是<stdlib.h>

b.栗子

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
int main()
{int* p = (int*)malloc(10 * sizeof(int));//10个整型数据的空间if (p == NULL)//判断是否为空指针{perror("malloc");}int i = 0;for (i = 0; i < 10; i++){p[i] = i;printf("%d ", p[i]);}free(p);//动态内存使用后要释放p = NULL;return 0;
}

2.calloc

void* calloc (size_t num, size_t size);

函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。

int main()
{int* p = (int*)calloc(10, sizeof(int));if (p == NULL){perror("calloc");return 1;}int i = 0;for (i = 0; i < 10; i++){printf("%d ", p[i]);}return 0;
}

3.realloc

对动态开辟的内存空间进行调整

void* realloc (void* ptr, size_t size);

ptr是需要调整的动态内存空间的地址，size是想要调整到的大小，返回值为调整后的内存空间的起始地址。

realloc在调整内存空间的是存在两种情况：

情况1：原有空间之后有足够大的空间， 要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。返回的地址和ptr是一样的。

情况2：原有空间之后没有足够大的空间， 原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找⼀个合适大小的连续空间来使用。这样函数返回的是⼀个新的内存地址。

//e.g.1 验证在情况1时 p = ptr
int main()
{int* p = (int*)malloc(10 * sizeof(int));if (p == NULL){perror("malloc");return 1;}int* ptr = (int*)realloc(p, 11 * sizeof(int));if (ptr == NULL){perror("realloc");free(p);//检查如果需要结束，那么就提前把p指向的内存释放掉p = NULL;return 1;}else{printf("%p\n%p\n", p, ptr);}return 0;
}//e.g.2
int main()
{int* p = (int*)malloc(10 * sizeof(int));if (p == NULL){perror("malloc");return 1;}int* ptr = (int*)realloc(p, 11 * sizeof(int));if (ptr == NULL)//防止因为ptr是空指针直接赋给p后，就p里原先的内容弄丢。{perror("realloc");return 1;}else{p = ptr;ptr = NULL;//此处不可以free(ptr)，这样的话p也不能用了int i = 0;for (i = 0; i < 11; i++){p[i] = i;printf("%d ", p[i]);}}free(p);p = NULL;return 0;
}

补充：
当realloc第一个参数是NULL时，作用相当于malloc

int main()
{int* p = (int*)realloc(NULL, 40);//当realloc函数的第一个参数是NULL指针时，功能类似于malloc函数
}

三、动态内存分配常见错误

1.常见错误

NULL指针的解引用操作—动态内存函数申请空间失败后，会返回NULL指针，需要先检查再使用

对动态开辟空间的越界访问

对非动态开辟内存使用free释放

使用free释放⼀块动态开辟内存的一部分

对同一块动态内存多次释放—free(NULL)没事，所以free后面紧跟把指针设置成NULL

动态开辟内存忘记释放（内存泄漏）—动态开辟的空间一定要释放，并且要正确释放，内存泄漏对于一直在跑的程序来说很危险。

2.经典例题

e.g.1

void GetMemory(char* p)
{p = (char*)malloc(100);//申请的动态内存分配给了P，但是函数结束后，p直接销毁，p的地址再也没有人记得，malloc申请的空间没有机会释放，导致内存泄漏
}
void Test(void)
{char* str = NULL;GetMemory(str);strcpy(str, "hello world");对NULL指针进行解引用，访问冲突，导致程序崩溃printf(str);
}int main()
{Test();return 0;
}

e.g.2

char* GetMemory(void)
{char p[] = "hello world";return p;
}
void Test(void)
{char* str = NULL;str = GetMemory();//出了函数后p创建的空间已经被销毁了，返回栈空间（局部变量）地址，str已经是野指针 printf(str);
}int main()
{Test();return 0;
}

e.g.3

void GetMemory(char **p, int num)
{*p = (char *)malloc(num);
}
void Test(void)
{char *str = NULL;GetMemory(&str, 100);strcpy(str, "hello");//动态分配的内存空间未释放，可能会造成内存泄漏printf(str);
}int main()
{Test();return 0;
}

e.g.4

void Test(void)
{char* str = (char*)malloc(100);strcpy(str, "hello");free(str);if (str != NULL){strcpy(str, "world");//内存空间已经被释放，非法访问printf(str);}
}

四、柔性数组

C99 中，结构中的最后⼀个元素允许是未知大小的数组，这就叫做柔性数组成员。

struct Stu
{int i;char a;int arr[0];//或者是int arr[];
};

结构中的柔性数组成员前面必须至少⼀个其他成员。

sizeof 返回的这种结构大小不包括柔性数组的内存。

包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

struct Stu
{int i;char a;int arr[0];
};int main()
{printf("%zd\n", sizeof(struct Stu));//8,最大对齐数的整数倍struct Stu* p = (struct Stu*)malloc(sizeof(struct Stu) + 10 * sizeof(int));if (p == NULL){perror("malloc");return 1;}int i = 0;p->i = 100;for (i = 0; i < 10; i++){p->arr[i] = i;printf("%d ", p->arr[i]);//0-9}free(p);p = NULL;return 0;
}

其实下面的代码也能实现相同的效果

typedef struct st_type
{int i;int *p_a;
}type_a;
int main()
{type_a *p = (type_a *)malloc(sizeof(type_a));p->i = 100;p->p_a = (int *)malloc(p->i*sizeof(int));//业务处理for(i=0; i<100; i++){p->p_a[i] = i;}//释放空间free(p->p_a);p->p_a = NULL;free(p);p = NULL;return 0;
}

但是柔性数组有以下两点优势：

1.只需要free一次，方便内存释放。

2.减少内存碎片，提高访问速度。

五、C/C++程序中内存区的划分

栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。如果递归层次太深，会导致栈溢出，也就是栈区空间不够用了。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

堆区（heap）：⼀般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。

数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。

代码段：存放函数体（可执行代码和只读常量）的⼆进制代码。e.g.常量字符串

内核空间，用户不能读写，是操作系统的东西。