C语言动态内存管理深度解剖

首先我们来解释一下为什么需要有动态内存分配
我们已经掌握的内存开辟方式有：

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

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

1. 空间开辟大小是固定的。
2. 数组在声明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

3.但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，
那数组在编译时开辟空间的方式就不能满足了。
所以我们要用到动态内存开辟
下面我们来介绍一下动态开辟内存常用的几个函数
malloc,free,calloc,realloc

一:malloc

1.介绍

void* malloc (size_t size);

1.这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
2.如果开辟成功，则返回一个指向开辟好空间的指针。
3.如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。

4.返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，使用时需要进行强制类型转换后再赋值
5.如果参数 size 为 0，malloc的行为是标准未定义的，取决于编译器。

6.请注意:malloc申请出来的空间是没有被初始化的,与下面要讲的calloc在这方面有很大区别
7.malloc函数申请完的空间要及时回收,并将指针置空
8.malloc的参数为要申请的总字节大小

2.实例

int main()
{
	int* p = (int*)malloc(sizeof(int) * 10);
	//有效性检查
	if (p == NULL)//开辟失败
	{
		perror("malloc");//报错
		return 1;
	}
	//开辟成功
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", *(p + i));
	}
	//释放空间,下面会具体介绍free这个函数
	free(p);
	//指针置空
	p = NULL;
	return 0;
}

可见malloc申请出来的空间是没有被初始化的

二.free

1.介绍

free是专门是用来做动态内存的释放和回收的

void free (void* ptr);

free函数用来释放动态开辟的内存。
1.如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
2.如果参数 ptr 是NULL指针，则函数什么事都不做。
3.malloc和free都声明在 stdlib.h 头文件中。

2.注意事项

1.不要对非动态开辟内存使用free释放
反例:
void test()
{
	int a = 10;
	int* p = &a;
	free(p);//err
	p = NULL;
}
2.不要对同一块动态内存多次释放
void test5()
{
	int* p = (int*)malloc(100);
	free(p);
	free(p);//重复释放
}

//这么改就改对了
void test6()
{
	int* p = (int*)malloc(100);
	free(p);
	p = NULL;
	free(p);//传入NULL的话,free也不会执行,所以完全可以这么传入,见上述第二条

三.calloc

1.介绍

void* calloc (size_t num, size_t size);
1.函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
2.与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。
3.注意calloc与malloc的参数并不相同

2.使用

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\n", p[i]);
	}
	free(p);
	p = NULL;
	return 0;
}

四.realloc

realloc是这三个函数中最重要的函数

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

有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了
那为了合理地使用内存，我们一定会对内存的大小做灵活的调整。
而realloc函数就可以做到对动态开辟内存大小的调整。

1.介绍

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

1.ptr 是要调整的内存地址
2.size 调整之后新大小
3.返回值为调整之后的内存起始位置。
4.这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新 的空间。
5.realloc开辟出的空间也同malloc一样,未经初始化

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

情况1：原有空间之后有足够大的空间
此时realloc函数将直接在原有空间进行扩容,即:
扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。

情况2:原有空间之后没有足够大的空间
1.开辟新的空间
2.会将旧的空间中的数据拷贝到新的空间
3.释放旧的空间
//所以旧空间无需我们去关心释放与否,因为realloc已经帮助我们完成释放了
4.返回新空间的起始地址

2.实例

1.在原有空间扩容

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//初始化为1~10
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		p[i] = i + 1;
	}
	//增加一些空间
	int* ptr = (int*)realloc(p, 80);
	if (ptr != NULL)
	{
		p = ptr;//为了在下面继续利用p这个指针,所以令p指向新(开辟新空间后)/旧(扩容旧空间)的空间
		ptr = NULL;
	}
	else
	{
		perror("realloc");
		return 1;
	}
	//打印数据
	for (i = 0; i < 20; i++)
	{
		printf("%d\n", p[i]);
	}
	free(p);
	p = NULL;
}

int* ptr = (int*)realloc(p, 80);

此时realloc的处理方式是直接在原有空间上进行扩容操作,
图中ptr与p所指向的空间的地址相同,即所指向的空间相同

2.开辟新空间
还是上面那个代码,只不过是修改了realloc开辟后的字节大小

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//初始化为1~10
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		p[i] = i + 1;
	}
	//增加一些空间
	int* ptr = (int*)realloc(p, 800);
	if (ptr != NULL)
	{
		p = ptr;//为了在下面继续利用p这个指针,所以令p指向新(开辟新空间后)/旧(扩容旧空间)的空间
		ptr = NULL;
	}
	else
	{
		perror("realloc");
		return 1;
	}
	//打印数据
	for (i = 0; i < 20; i++)
	{
		printf("%d\n", p[i]);
	}
	free(p);
	p = NULL;
}

int* ptr = (int*)realloc(p, 800);

此时realloc的处理方式是开辟了新的空间,
图中ptr与p所指向的空间的地址不同,即所指向的空间不同

无论是在原有空间上扩容还是在新空间上开辟空间,realloc都完成了任务:

五.常见的动态内存错误

1.对空指针的解引用操作

void test()
{
	int* p = (int*)malloc(INT_MAX);
	*p = 20;//如果p的值是NULL，就会有问题,需要加以判断
	free(p);
	p=NULL;
}
更改为:
void test()
{
	int* p = (int*)malloc(INT_MAX);
	if(NULL==p)
	{
		perror("malloc");
		return;
	}
	else
	{
		*p = 20;
		free(p);
		p=NULL;
	}
}

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

void test()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));
	if (NULL == p)
	{
		perror("malloc");
		return 1;
	}
	for (i = 0; i < 20; i++)
	//明明只申请了10个int类型大小的空间,却想访问20个int类型大小的空间
	{
		*(p + i) = i;//越界访问
	}
	free(p);
	p = NULL;
}
改为:
void test()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));
	if (NULL == p)
	{
		perror("malloc");
		return 1;
	}
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
}

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

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

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

void test()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*p = i;
		p++;//p发生了改变
	}
	//注意:因为p改变了,所以无法释放所申请的全部空间,而只能释放部分空间,所以这么做就错了
	free(p);
	p = NULL;
}

应改为
void test()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i;
		//即:p[i]=i;
	}
	free(p);
	p = NULL;
}

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

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

//这么改就改对了
void test()
{
	int* p = (int*)malloc(100);
	free(p);
	p = NULL;
	free(p);//传入NULL的话,free也不会执行,所以完全可以这么传入
}

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

int main()
{
	int* p = (int*)malloc(sizeof(int) * 10);
	//有效性检查
	if (p == NULL)//开辟失败
	{
		perror("malloc");//报错
		return 1;
	}
	//开辟成功
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", *(p + i));
	}
	return 0;
}
乍一看,挺好的啊,该检查的都检查了,p指针也没有修改,但是却忘了释放空间...

六.典型题解析

1.

void GetMemory(char* p)
{
	p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
}
int main()
{
	Test();
}
核心:
程序崩溃,形参的改变不会影响实参
也就是说str还是空指针,无法进行strcpy拷贝

错误点：
1.对空指针进行了解引用操作,程序会崩溃
2. GetMemory函数中已经开辟的p指针指向的空间没有被free释放掉,而且又因为局部变量出了作用域后会自动销毁,便无法找到所开辟出的空间了,所以出现了内存泄漏
---------------------------------------------------------------
注意:printf那一行代码没有写错!!!!!!!!!!!!!!!
int main()
{
	char* str = "hello";
	printf(str);//hello
	//等价于
	printf("hello");
	//两种printf本质上都是传入字符串"hello"的首元素'h'的地址
}
---------------------------------------------------------------
第一题改为

void GetMemory(char** p)
{
	*p = (char*)malloc(100);
}

void Test(void)
{
	char* str = NULL;
	GetMemory(&str);
	strcpy(str, "hello world");
	printf(str);
	free(str);
	str = NULL;
}
int main()
{
	Test();
}

改之前:
程序直接崩溃

改之后:
成功运行

2.

char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
//局部变量除了作用域后会被销毁
即:str变为野指针,非法访问了
属于返回栈空间(局部变量/临时变量)地址的问题
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
//可以正常运行,但不会打印hello world

第2题改为
法一:
将数组p设为静态成员,生命周期持续到整个程序结束
char* GetMemory(void)
{
	static char p[] = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
int main()
{
	Test();
}

改之前:
打印乱码

改之后:

附加题:关于局部变量与函数栈帧之间的关系

int* test()
{
	int a = 10;
	return &a;
}
int main()
{
	int* p = test();
	//p:野指针
	printf("*p=");
	printf("%d\n", *p);
	//情况一:没有写printf(("*p=");这一条语句时,
	10 运气好而已,因为此时还未开辟其他战帧
	//情况二:*p=-858993460
	//因为:调用printf函数时为printf函数开辟了新的栈帧,新开辟的战帧覆盖了函数test的栈帧
}

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();
}

可以正常运行,也可以打印hello
不过没有free

应改为
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(str);
	str = NULL;
}
int main()
{
	Test();
}

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没有置空,导致str为野指针

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

七.柔性数组

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。
在c99中，结构体中的最后一个元素允许是未知大小的数组，这就叫做柔性数组成员。

1.含义

柔性数组的特点：
1.结构体中的柔性数组成员前面必须至少一个其他成员。
2.sizeof 返回的这种结构大小不包括柔性数组的内存。
3.包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

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

//有些编译器会报错无法编译可以改成：

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

printf("%d\n",sizweof(type_a2))//答案是:4

2.使用实例

2.1

代码1:应用柔性数组
一次malloc

struct S
{
	int n;
	int arr[0];//柔性数组
};

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 40);
	//这个单独加上的40个字节就是给柔性数组开辟的空间
	if (NULL == ps)
	{
		perror("malloc");
		return 1;
	}
	ps->n = 100;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i + 1;
	}

	//空间不够,需要增容
	struct S* ptr = realloc(ps, sizeof(struct S) + 60);
	if (ptr == NULL)
	{
		perror("realloc");
		return 1;
	}
	ps = ptr;
	ps->n = 15;
	for (i = 0; i < 15; i++)
	{
		printf("%d\n", ps->arr[i]);
	}
	//释放
	free(ps);
	ps = NULL;
	return 0;
}

2.2

代码2:应用指针类型
两次malloc

struct S
{
	int n;
	int* arr;
};

int main098()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
	{
		perror("malloc->ps");
		return 1;
	}
	ps->n = 100;
	ps->arr = (int*)malloc(40);
	if (ps->arr == NULL)
	{
		perror("malloc->arr");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i + 1;
	}

	//调整,增容
	int* ptr = (int*)realloc(ps->arr, 60);
	if (ptr != NULL)
	{
		ps->arr = ptr;
	}
	else
	{
		perror("realloc");
		return 1;
	}
	//打印
	for (i = 0; i < 15; i++)
	{
		printf("%d\n", ps->arr[i]);
	}
	//释放
	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;
	return 0;
}

2.3

跟上面的柔性数组的功能相同
不过柔性数组只需malloc一次,而下面这种方法需要malloc两次
只malloc一次的好处:提高内存利用率,避免内存碎片化

上述代码1和代码2可以完成同样的功能,但是方法1的实现有两个好处：

1:方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。

用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。

所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针
用户做一次free就可以把所有的内存也给释放掉。

2:这样有利于访问速度.
连续的内存有益于提高访问速度，也有益于减少内存碎片.主要是为了减少内存碎片

以上就是C语言动态内存管理深度解剖,希望能对大家有所帮助,谢谢大家