动态内存管理-c语言

阅读本书更多章节>>>>

目录

1.为什么要有动态内存分配

2.malloc函数和free函数

malloc

函数原型

栗子

free

函数原型

栗子

3.calloc和***realloc***

3.1calloc函数

原型如下：

栗子

3.2***recalloc***

第一种情况

第二种情况

第三种情况

recalloc模拟实现calloc函数

4.六大常⻅的动态内存的错误

4.1对NULL指针的解引⽤操作

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

 4.3对⾮动态开辟内存使⽤free释放

 4.4使⽤free释放⼀块动态开辟内存的⼀部分

 4.5对同⼀块动态内存多次释放

4.6 动态开辟内存忘记释放（内存泄漏）

 5.动态内存经典笔试题分析

5.1题目一

正确解法

5.2题目二

正确解法

5.3题目三

正确解法

5.4题目四

正确解法

6. 柔性数组

6.1什么是柔性数组

栗子

6.2柔性数组的使用

6.3柔性数组的优势

---

1.为什么要有动态内存分配

int val = 20;//在栈空间上开辟四个字节 char arr[10] = {0};//在栈空间上开辟10个字节的连续空间

但是上述的开辟空间的⽅式有两个特点：

• • 空间开辟⼤⼩是固定的。

* *数组在申明的时候，必须指定数组的⻓度，数组空间⼀旦确定了⼤⼩不能调整

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间⼤⼩在程序运⾏的时候才能知 道，那数组的编译时开辟空间的⽅式就不能满⾜了。 C语⾔引⼊了动态内存开辟，让程序员⾃⼰可以申请和释放空间，就⽐较灵活了。

2.malloc函数和free函数

malloc

是c语言用于动态内存开辟的函数

函数原型

void* malloc (size_t size);

说明：malloc向系统申请分配指定size个字节的内存空间。返回类型是void *类型。void *类型表示未确定类型的指针。C、C++规定，void *类型可以强制转换为任何其他类型的指针。

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

******#include<stdlib.h>//malloc头文件

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

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

*******void* 所以malloc函数并不知道开辟空间的类型，具体在使⽤的时候⾃⼰来绝定。

********如果参数 size 为0，malloc的⾏为是标准是未定义的，取决于编译器

栗子

因为malloc（）返回值是返回函数开辟空间的地址，类型是void，所以p应该是要用void * p来接收，但是void类型的指针，是不能进行解引用的，所以这个方法行不通。

解决办法

int* p = (int *)malloc();

要把malloc返回值进行强制转换成你要开辟空间用于什么数据类型的类型。

比如这里我需要int类型的内存，所以这里要转换成int类型。

重要一步检查是否内存开辟成功也莫忘：

如果开辟失败，则返回⼀个 返回值的类型是 NULL 指针

int* p = (int *)malloc(40);if (p == NULL){perror("malloc");//报错return 1;}//使用开好的内存for (int i = 0; i < 10; i++){/**p = i;p++;*///上面写法，写到后面。p位置不好找回来*(p + i) = i;//这样写p就不会动了}for (int i = 0; i < 10; i++){printf("%d ", *(p+i));}

free

函数原型

void free (void* ptr);

free参数是动态内存申请好返回的指针变量。

函数free，专⻔是⽤来做动态内存的释放和回收的

**free函数必须和malloc函数同时使用不然会报错

**free函数无法释放栈内存的变量

**free只能释放动态内存申请的空间

栗子

int* p = (int *)malloc(40);if (p == NULL){perror("malloc");//报错return 1;}//使用开好的内存for (int i = 0; i < 10; i++){/**p = i;p++;*///上面写法，写到后面。p位置不好找回来*(p + i) = i;//这样写p就不会动了}for (int i = 0; i < 10; i++){printf("%d ", *(p+i));}free(p);p = NULL;//因为释放了内存，但是 p指向的位置还是内存的起始地址，避免成为野指针，要指向空。

3.calloc和***realloc***

3.1calloc函数

原型如下：

void* calloc (size_t num, size_t size);

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

***malloc与calloc区别就是malloc不会初始化，而calloc初始化为0
***第二就是，参数不一样，calloc可以输入指定个数，和大小

栗子

//使用calloc函数进行动态内存申请int* p = (int*)calloc(10, sizeof(int));

3.2***recalloc***

realloc函数可以做到对动态开辟内存⼤小调整；

realloc函数的出现让动态内存管理更加灵活。

函数原型

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

realloc分为三种情况，

第一种情况

申请空间失败；

第二种情况

申请成功，但开辟空间的时候后面没有足够的空间，在这种情况下，realloc函数会在内存的堆区重新找一个空间（这个空间满足新的申请空间大小需求），同时会把旧的数据拷贝到新的空间，然后释放旧的空间，同时返回新的空间的起始地址。

第三种情况

也是成功情况，但是这次后面的空间是足够的情况，可以直接进行扩大，扩大空间后，直接返回旧的空间的起始地址。

//要用一个临时变量存储申请的空间，防止申请失败而置为nullint* p = (int*)calloc(10, sizeof(int));int ptr = (int*)reallco(p, 10 * sizeof(int));if (ptr != NULL){p = ptr;}else{perror("realloc");return 1;}

recalloc模拟实现calloc函数

int* p = (int *)realloc(NULL,40);if (p == NULL){perror("malloc");//报错return 1;}//使用开好的内存for (int i = 0; i < 10; i++){/**p = i;p++;*///上面写法，写到后面。p位置不好找回来*(p + i) = i;//这样写p就不会动了}for (int i = 0; i < 10; i++){printf("%d ", *(p+i));}free(p);p = NULL;//因为释放了内存，但是 p指向的位置还是内存的起始地址，避免成为野指针，要指向空。

4.六大常⻅的动态内存的错误

4.1对NULL指针的解引⽤操作

没有进行判断是否申请内存成功而直接使用

int a = 20;int* p = (int*)malloc(40);*p = a;

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

int* p = (int*)malloc(40);//类似于数组的越界访问if (NULL == p){exit(EXIT_FAILURE);}for (int i = 0; i <= 10; i++){//i<=10,就是越界访问了，因为申请的大小才10个int大小//i<10才行。*(p + i) = i;}free(p);p = NULL;

 4.3对⾮动态开辟内存使⽤free释放

int a = 0;int* p = (int*)malloc(40);if (NULL == p){exit(EXIT_FAILURE);}//这里就出错了p = &a;//p指向a地址，此时就丢失了开辟的空间，形成空间泄露的情况。free(p);p = NULL;

 4.4使⽤free释放⼀块动态开辟内存的⼀部分

//只释放一部分的动态内存，也会错误，free只能放内存的首地址。int* p = (int*)malloc(40);if (NULL == p){exit(EXIT_FAILURE);}p ++;free(p);p = NULL;

 4.5对同⼀块动态内存多次释放

 int *p = (int *)malloc(100); free(p); free(p);//重复释放 

4.6 动态开辟内存忘记释放（内存泄漏）

:malloc/calloc/realloc 申请的空间如果不主动释放，出了作用域是不会销毁的
释放的方式:
1.free主动释放

2.直到程序结束，才由操作系统回收

 void test() { int *p = (int *)malloc(100); if(NULL != p) { *p = 20; } } int main() { test(); while(1); }

 5.动态内存经典笔试题分析

5.1题目一

void GetMemory(char* p){p = (char*)malloc(100);//而这里申请的空间是p的，//后面这个函数运行结束，p就会消失，申请的内存也就会泄露，导致程序崩溃}int main(){char* str = NULL;GetMemory(str);//传过去的是str，并不是地址strcpy(str, "hello world");//str并没有申请有内存，却直接进行解引用，会导致程序崩溃。printf(str);free(str);str = NULL;}

str并没有申请有内存，却直接进行解引用，会导致程序崩溃。

正确解法

void GetMemory(char** p){*p = (char*)malloc(100);}int main(){char* str = NULL;GetMemory(&str);//这里传地址过去就好了strcpy(str, "hello world");printf(str);free(str);str = NULL;}

5.2题目二

char* GetMemory(void){char p[] = "hello world";//这里创建的内存，如果函数运行完成就会自动销毁了return p;//那么此时p就是野指针。}void Test(void){char* str = NULL;str = GetMemory();printf(str);}int main(){Test();return 0;}

static用法讲解

正确解法

char* GetMemory(void){    //static修饰局部变量时，会改变局部变量的存储位置，从而使得局部变量的生命周期变长。static char p[] = "hello world";//这里创建的内存，如果函数运行完成就会自动销毁了return p;//那么此时p就是野指针。}void Test(void){char* str = NULL;str = GetMemory();printf(str);}int main(){Test();return 0;}

5.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); }

这里就是缺少了free销毁申请的内存，会造成内存泄露

正确解法

void GetMemory(char** p, int num){*p = (char*)malloc(num);if (*p == NULL){return 0;}}void Test(void){char* str = NULL;GetMemory(&str, 100);strcpy(str, "hello");printf(str);free(str);str = NULL;}int main(){printf("韦坤四战\n");Test();return 0;}

5.4题目四

 void Test(void) { char *str = (char *) malloc(100); strcpy(str, "hello"); free(str); if(str != NULL) { strcpy(str, "world"); printf(str); } }

这里错的是free释放掉str后，并没有手动把str指向null;

正确解法

void Test(void){char* str = (char*)malloc(100);strcpy(str, "hello");free(str);str = NULL;if (str != NULL){strcpy(str, "world");printf(str);}}

6. 柔性数组

6.1什么是柔性数组

满足下面三个条件即是柔性数组：

1.在结构体中

2.结构体中最少两个成员，并且它是最后一个成员

3.是一个未知大小的数组

柔性数组的特点：

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

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

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

栗子

struct st_type{int i;/*1.在结构体中2.结构体中最少两个成员，并且它是最后一个成员3.是一个未知大小的数组*/int a[0];//柔性数组成员}type_a;int main(){printf("%d\n", sizeof(type_a));//只会计算i的大小为4，数组a[0]是未知的无法计算。return 0;}

6.2柔性数组的使用

//申请动态内存struct st *ps  = (struct st*)malloc(sizeof(struct st) + 10 * sizeof(int));//10 * sizeof(int)这里就是给柔性数组开的内存。if (ps = NULL){perror("ps");return 0;}//赋值ps->i = 10;for (int i = 0; i < 10; i++){ps->a[i] = i;}

6.3柔性数组的优势

//柔性数组的优势//就是可以随时扩大柔性数组的大小。//申请动态内存struct st *ps  = (struct st*)malloc(sizeof(struct st) + 10 * sizeof(int));//10 * sizeof(int)这里就是给柔性数组开的内存。if (ps = NULL){perror("ps");return 0;}//赋值ps->i = 10;for (int i = 0; i < 10; i++){ps->a[i] = i;}struct st *ptr = (struct st*)realloc(ps, sizeof(struct st) + 15 * sizeof(int));if (ps = NULL){perror("ps");return 0;}else{ps = ptr;}

第⼀个好处是：⽅便内存释放

 如果我们的代码是在⼀个给别⼈⽤的函数中，你在⾥⾯做了⼆次内存分配，并把整个结构体返回给⽤ ⼾。⽤⼾调⽤free可以释放结构体，但是⽤⼾并不知道这个结构体内的成员也需要free，所以你不能 指望⽤⼾来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存⼀次性分配好了，并返 回给⽤⼾⼀个结构体指针，⽤⼾做⼀次free就可以把所有的内存也给释放掉。

第⼆个好处是：这样有利于访问速度. 连续的内存有益于提⾼访问速度，也有益于减少内存碎⽚。（其实，我个⼈觉得也没多⾼了，反正你 跑不了要⽤做偏移量的加法来寻址

阅读本书更多章节>>>>

本文链接：https://www.kjpai.cn/xuetang/2024-03-24/147805.html，文章来源：网络cs，作者：晨起，版权归作者所有，如需转载请注明来源和作者，否则将追究法律责任！