C语言----动态内存管理

北航最菜大学生

已于 2024-07-06 15:30:37 修改

阅读量547

点赞数 23

分类专栏： C语言进阶文章标签： c语言

于 2024-07-03 10:04:27 首次发布

本文链接：https://blog.csdn.net/weixin_73579966/article/details/137913397

版权

C语言进阶专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1.为什么要进行动态内存管理

我们之前开辟内存的方式包括

int a=10;
float arr[20]={0};

这些都是在栈空间开辟的，在栈空间开辟的内存有很多局限性：

1.空间开辟大小是固定的。

2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

但是在很多问题中我们的需求不仅于此，很多时候我们需要多大空间可能在程序运行的时候才知道，此时用数组就不太方便，于是动态内存开辟就派上用场了。

2.动态内存函数

头文件：<stdlib.h>

1.malloc、free

C语言提供了一个动态内存开辟的函数：

void * malloc(size_t size);

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

如果开辟成功，返回一个指向开辟好的空间的指针；

如果开辟失败，返回NULL指针，因此malloc的返回值需要进行检查。

开辟成功后返回的是void*类型的指针，因为malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。

如果参数的size为0，malloc行为是未定义的，取决于编译器。

C语言还提供了另外一个函数free，是专门用来做动态内存的回收和释放的：

void free(void *ptr);

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

如果参数ptr指向的内存不是动态开辟的，free函数的行为是为定义的。

如果ptr为NULL，函数什么事也不做。

#include <stdio.h>
#include <stdlib.h>
int main()
{
 //代码1
 int num = 0;
 scanf("%d", &num);
 int arr[num] = {0};
 //代码2
 int* ptr = NULL;
 ptr = (int*)malloc(num*sizeof(int));
 if(NULL != ptr)//判断ptr指针是否为空
 {
 int i = 0;
 for(i=0; i<num; i++)
 {
 *(ptr+i) = 0；
 }
 }
 free(ptr);//释放ptr所指向的动态内存
 ptr = NULL;//是否有必要？
 return 0;
}

2.calloc

calloc函数也可以用来进行动态内存分配，函数原型：

void* calloc (size_t num, size_t size);

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

与函数malloc的区别只在于是否初始化。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int *)calloc(10, sizeof(int));
	free(p);
	p = NULL;


	return 0;
}

3.realloc

realloc可以更灵活地使用动态内存，当申请的空间太大或者太小的时候，需要对动态内存空间进行调整，此时realloc函数就可以做到对动态开辟内存大小的调整，函数原型：

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

ptr是需要调整的旧空间，size是调整之后新的大小，返回值为调整之后新空间的起始位置，这个函数在调整新空间的同时还会把原来内存中的数据移动到新的空间。

由于堆区中的空间在开辟时可能是离散的，这就会导致原ptr空间后面可能有充足的空间也可能没有充足的空间，如果是前者，ptr地址不变，如果是后者，realloc函数会新找一块足够大的空间，此时ptr地址会变。

如果size太大，可能会开辟失败，此时realloc返回NULL。

#include <stdio.h>
#include <stdlib.h>

int main()
{
 int *ptr = (int*)malloc(100);
 if(ptr != NULL)
 {
     //业务处理
 }
 else
 {
     exit(EXIT_FAILURE);    
 }
 //扩展容量
 //代码1
 ptr = (int*)realloc(ptr, 1000);//这样可以吗？(如果申请失败会如何？)
 
 //代码2
 int*p = NULL;
 p = realloc(ptr, 1000);
 if(p != NULL)
 {
 ptr = p;
 }
 //业务处理
 free(ptr);
 return 0;
}

代码1中，如果开辟失败，ptr会置空，在解引用时会出错。

3.常见动态内存错误

1.对NULL指针解引用

void test1()
{
	int* p = (int*)malloc(INT_MAX / 4);
	*p = 20;//如果上面开辟失败这里就会显示错误
	free(p);
}

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

void test2()
	{
		int i = 0;
		int* p = (int*)malloc(10 * sizeof(int));
		if (NULL == p)
		{
			exit(EXIT_FAILURE);
		}
		for (i = 0; i <= 10; i++)
		{
			*(p + i) = i;//当i是10的时候越界访问
		}
		free(p);
	}

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

void test()
{
    int a=10;
    int *p=&a;
    free(p);
}

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

void test()
{
    int *p=(int *)malloc(100);
    p++;
    free(p);
}

5.对同一块动态内存多次释放

void test()
{
 int *p = (int *)malloc(100);
 free(p);
 free(p);//重复释放
}

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

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

这里函数test调用结束之后p被销毁但是p申请的内存没有释放。

此后这块空间就难以找到了

动态开辟的内存空间不释放就会造成内存泄漏，因此需要正确释放。

下面是几个经典的问题：

试问下面代码有什么问题？

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

问题1：函数传参而不是传址，str未分配内存，因此后面的操作中包含空指针解引用；

问题2：p在开辟动态内存后没有释放便销毁了，造成内存泄漏。

可以在函数中返回开辟的地址：（也可以用二级指针，读者可以自行思考实现）

char* GetMemory(char *p)
{
 p = (char *)malloc(100);
 return p;
}
void Test(void)
{
 char *str = NULL;
 str = GetMemory(str);
 strcpy(str, "hello world");
 printf(str);
}

下面这个呢？？

char *GetMemory(void)
{
 char p[] = "hello world";
 return p;
}
void Test(void)
{
 char *str = NULL;
 str = GetMemory();
 printf(str);
}

这个确实返回了p的地址，但是这块地址是在栈区开辟的，在GetMemory函数结束之后被回收了，因此地址里的内容也已经不属于p了，所以p为野指针，所以这个代码是对野指针解引用了

这个？

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 Test(void)
{
 char *str = (char *) malloc(100);
 strcpy(str, "hello");
 free(str);
 if(str != NULL)
 {
 strcpy(str, "world");
 printf(str);
 }
}

free之后就不能copy啦，因为是野指针，所以应该先置空

结论：见malloc必须要找free，需不需要置空要看后面是否还用。（最好每次都置空）

鲁棒性改进：判断malloc返回值看是否成功。

4.C/C++程序的内存开辟

C/C++程序内存分配的几个区域：栈区、堆区、数据段、代码段

1. 栈区（ stack ）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结

束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是

分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返

回地址等。

2. 堆区（ heap ）：一般由程序员分配释放，若程序员不释放，程序结束时可能由 OS 回收。分

配方式类似于链表。

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

4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

5.柔性数组成员

柔性数组成员在C99中提出，是指在一个结构体中，允许结构最后一个元素是一个未知大小的数组，这个就叫柔性数组成员。

typedef struct st_type
{
 int i;
 int a[];//柔性数组成员
}type_a;

在某些编译器上也可能是

typedef struct st_type
{
 int i;
 int a[0];//柔性数组成员
}type_a;

特点（要求）：

前面必须至少一个成员，sizeof这个结构返回的值不包括柔性数组的内存。

包含柔性数组的结构应该由malloc等动态开辟内存，且分配的内存值应该更大以适应柔性数组的预期

//代码1
int i = 0;
type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));
//业务处理
p->i = 100;
for(i=0; i<100; i++)
{
 p->a[i] = i;
}
free(p);

此时a 相当于获得了100个整型元素空间

优势：

//代码2
typedef struct st_type
{
    int i;
 int *p_a;
}type_a;
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;

用指针表示的柔性数组优势更多，代码2中没有使用柔性数组，而是为结构体中的数字开辟了空间所以第一个代码的优势在于：

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

另外连续的内存有利于提高访问速度，减少内存碎片。