笔记22-1（C语言进阶动态内存管理）

w_pab

已于 2022-06-25 14:32:06 修改

阅读量359

点赞数 2

分类专栏：笔记文章标签： c语言开发语言

于 2022-05-31 21:59:57 首次发布

本文链接：https://blog.csdn.net/w_pab/article/details/124974016

版权

笔记专栏收录该内容

29 篇文章 2 订阅

订阅专栏

3.使用free函数释放了非动态开辟的空间

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

5.对同一块动态开辟的空间，多次释放

6.动态开辟的内存忘记释放（内存泄漏 - 比较严重）

经典的笔试题（可供参考：《高质量C++/C 编程指南》）

题目1：运行Test函数的结果？（p = (char*)malloc(100)）

题目2：运行Test函数的结果？(返回栈空间地址的问题)

注

本笔记参考：B站up：鹏哥C语言

为什么存在动态内存分配

我们已经掌握的内存开辟方法有：

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

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

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

但是在上一篇笔记中我们提到，有时候我们需要的空间大小只有在运行程序时才能知道，这时候在编译时开辟空间的方法就不能满足我们的需求了。

而这种时候，就需要动态内存开辟。

动态内存函数的介绍

复习知识点：内存区域的划分

malloc和free

malloc - 负责动态内存开辟的函数

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

如果开辟成功，返回一个指向已开辟空间的指针；
如果开辟失败，则返回一个NULL指针（因此 malloc函数的返回值一定要做检查）。

返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，类型是在具体使用的时候由使用者自己决定的。
如果参数 size 为 0 ，malloc函数的行为是标准未定义的，这时候就取决于编译器了。（参数size - 需要开辟的字节数）

free - 负责释放和回收动态内存的函数

如果参数 ptr 正常指向malloc函数开辟的动态内存空间，则将空间还给操作系统；
如果参数 ptr 指向的空间不是动态开辟的，则会导致未定义的行为；
如果参数 ptr 是NULL指针，则函数什么事都不做。

malloc函数和free函数都在头文件 stdlib.h 中被声明（这两个函数总是成对使用）。

简单的使用例

#include<stdlib.h>
#include<stdio.h>
int main()
{
	//假设开辟10个整型的空间
	int arr[10];//在栈区上开辟

	//如果使用动态内存开辟：
	int* p = malloc(10*sizeof(int));

	return 0;
}

注：

    如果是接收的指针是void*的指针，则无法解引用，故不使用void*进行接收；
   之所以使用int*，是为了以整型指针的方式使用传回来的指针（因为要求是开辟10个整型的空间）；
   在一些编译器上，为了防止出现警告，最好在malloc函数前面加上一个强制类型转换，如：

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

如果空间开辟成功，相当于在堆区上找了一块40个字节的空间，返回了这块空间的起始地址：

所以如果要使用 malloc函数开辟的这40个字节的空间时，应该：

//接之前的代码
	if (p == NULL)//判断空间是否开辟失败
	{
		perror("main");
		//perror函数会以 main:xxxxxxxx 的格式打印
	}
	//可以使用
	int i = 0;
	for ( i = 0; i < 10; i++)
	{
		*(p + i) = i;
		//以整型指针的方式往后逐个访问每一个元素
	}
	for ( i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);//p[i] 等价于 *(p + i)
	}

	//当不需要使用以开辟的空间时，需要回收空间
	free(p);
	p = NULL;//自己动手，把指针p设置为空指针
//……（之后的代码）

其中，对于 free(p);

这种写法把指针p指向的空间还给了操作系统，但此时指针p依然保存着原空间的地址（存在非法访问风险）

ps：如果写入诸如 int* p = malloc(100000000000*sizeof(int)); 这样的代码，有可能开辟空间失败：

没有足够空间。

calloc

calloc函数也是用于动态内存分配的。

函数的功能是在堆区上开辟元素个数为 num，每个元素的长度为 size（单位为字节）的一块连续空间，并且把空间的每个字节初始化为0。
与malloc函数的区别在于calloc函数会在返回地址之前把申请的空间的每个字节初始化为0。

如果使用malloc函数开辟空间，打印发现：

对于所开辟的空间内部到底有什么，这是我们无法得知的。

但是如果使用calloc函数开辟空间：

调试：

这时所开辟空间的内存全部都被初始化成了0。

使用例

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int* p = (int*)calloc(10, sizeof(int));
    if (p != NULL)
    {
        //使用空间
    }
    free(p);
    p = NULL;
    return 0;
}

realloc

realloc - 改变所开辟的动态内存大小的函数

realloc函数的出现让动态内存管理更加灵活。
有时候我们发现曾经申请的空间太小了，有时候我们又会觉得申请的空间过大了。为了合理地使用内存，就需要对内存的大小做灵活的调整，而 realloc 函数就可以做到对开辟的动态内存的大小进行调整。
ptr 是要调整的内存地址；
size 是动态内存调整后的大小；
返回值为调整后的内存的起始地址。
这个函数在调整动态内存大小的同时，还会将原来在这块动态内存空间中的数据移动到新的空间内。

        ◆realloc函数在调整内存空间的大小时存在两种情况：

                ◇情况1：原有空间之后有足够大的空间

                        这时realloc函数像malloc函数一样会申请空间，并返回这块空间的起始地址。

                ◇情况2：原有空间之后没有足够空间

                        这时候realloc函数会在内存中重新寻找一块空间：

                        （这块空间的大小可以满足要求）

                        ①realloc函数会把原本空间内的内容拷贝到新的空间里；

                        ②然后返回新空间的起始地址，同时把原本开辟的空间还给操作系统。

ps：如果realloc函数始终无法找到合适的空间来调控大小，这时函数就会返回一个NULL指针。这也是为什么不可以用指向原本空间的指针接收realloc函数的返回值，这可能会导致指针连原本的空间都无法找到。

通常会拿一个临时指针接收realloc的返回值，进行判断，如果不是空指针，再将临时指针的地址赋给原本的指针。

如：

执行代码

观察内存

可以发现，ptr 和 p 指向的地址是不同的。

使用例

realloc函数在单独使用时可以达到和malloc函数相似的功能 - 直接在堆区中开辟空间

#include<stdlib.h>
int main()
{
    int* p = (int*)realloc(NULL, 40);
    return 0;
}

补充：

参数 size 如果是 0 ：

在C90中，参数 ptr 所指向的空间会被还给操作系统（类似于free），同时返回NULL指针。

在C99或者C11中，函数的执行取决于特定的库的实现。

常见的动态内存错误

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

int main()
{
	int* p = (int*)malloc(1000000000);
	int i = 0;
	for ( i = 0; i < 10; i++)
	{
		*(p + i) = i;
		//万一指针 p 指向的空间开辟失败，就会出现空指针，
		//这时候的操作是对空指针而言的，就是非法访问内存了。
	}
	return 0;
}

需要对malloc函数的返回值进行判断。

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

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
		return 1;

	int i = 0;
	for (i = 0; i < 40; i++)
	{
		*(p + i) = i;
	}
	return 0;
}

越界访问了：

只开辟了40个字节的空间，
而下面的循环认为开辟了40个整形的空间。

3.使用free函数释放了非动态开辟的空间

int main()
{
	int arr[10] = { 0 };//在栈区上开辟了空间
	int* p = arr;

	//使用 省略代码

	free(p);//使用free函数释放了非动态开辟的空间
	p = NULL;
	return 0;
}

这里演示在VS2022下强行执行该代码的结果：

代码挂掉了。

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

int main()
{
	int* p = malloc(10 * sizeof(int));
	if (p == NULL)
		return 1;
	
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*p++ = i;
		//这种写法确实可以把 i 填入前5个元素
		//但是这时候指针 p 的位置也往前走了5个元素
	}

	free(p);
	//这时候就会出现问题
	return 0;
}

这种写法会出现：

导致指针 p 不在起始位置，从而存在两个风险：

不能中途释放；
指针 p 原本指向空间的起始位置将无法得知（这意味着这块空间很可能再也无法被找到，即存在内存泄漏的风险）。

如果强制执行，代码也会卡死：

5.对同一块动态开辟的空间，多次释放

int main()
{
	int* p = (int*)malloc(100);

	//使用代码的部分省略

	//释放
	free(p);

	//再次释放
	free(p);

	return 0;
}

这种写法还是会有问题。

如何防止？只要在free函数使用后，将指针 p 置为NULL指针即可（当一个NULL指针被传入free函数时，什么事也不会发生）。

//释放
free(p);
p = NULL;

//再次释放
free(p);

6.动态开辟的内存忘记释放（内存泄漏 - 比较严重）

void test()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return;
	}
	//使用代码的部分 - 省略
}
int main()
{
	test();
	//之后的代码部分 - 也省略
	return 0;
}

malloc函数开辟的空间由指针p维护；
而指针p的生命周期在函数内部；
一旦函数结束，指针p就会被销毁，此时原本被开辟的空间就无法被维护和寻找了。这就是内存泄漏了。

注意：malloc函数开辟的空间只有两种情况可以销毁

通过free函数主动释放；
程序结束，生命周期结束。

经典的笔试题（可供参考：《高质量C++/C 编程指南》）

题目1：运行Test函数的结果？（p = (char*)malloc(100)）

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

void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "Hello Word");
	printf(str);
}

int main()
{
	Test();
	return 0;
}

结果：

代码挂了。

分析：

那么如何改正？

一种改法：

注意：和栈区不同，堆区开辟的空间是不会自动销毁的，所以才可以进行诸如 return p 的操作。

补充：

在上面的代码中，出现了这种写法：printf(str); 其实这种写法是可行的。

例如：
printf("Hello World");
打印这样的一串字符串，实际上是存在一个指针p，有：
char* p = "Hello World";
即把字符'H'的地址放入p中，printf函数再从指针p指向的这个地址向后打印。

另一种改法：

题目2：运行Test函数的结果？(返回栈空间地址的问题)

char* GetMemory(void)
{
	char p[] = "Hello World";
	return p;
}

void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}

int main()
{
	Test();
	return 0;
}

运行结果：

分析：

补充：野指针问题

int* f2(void)
{
    int* ptr;
    *ptr = 10;
    return ptr;
}
在里面指针ptr没有初始化，就是个野指针。

3.程序存在问题 - 无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");
}

int main()
{
	Test();
	return 0;
}

4.程序存在问题 - 空间提前释放

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

int main()
{
	Test();
	return 0;
}

分析：

如果提前所以free函数，会出现：

这题告诉我们：free函数后面一定要进行置为空指针的操作。

内存区域划分

栈区（stack）：在执行函数时，函数内部的局部变量的存储单元可以在栈上创建，函数执行结束时执行存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
堆区（heap）：一般由程序员分配及释放，若程序员不释放，程序结束时可能由OS回收。分配方式类似于链表。
数据段（静态区）：（static）存放全局变量、静态数据。程序结束后由系统释放。
代码段：存放函数体（类成员变量和全局函数）的二进制代码。

解释static关键字修饰局部变量：

普通的局部变量是在栈区上分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。

但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁。

所以可以使用static关键字延长局部变量的生命周期。

柔性数组（flexible array）

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

例如：

struct S
{
	int n;
	int arr[];//这个数组的大小是未知的
};

其中的数组arr就是柔性数组。另外还有一种写法：

struct S
{
	int n;
	int arr[0];
};

其中的arr同样是柔性数组，这两种写法根据编译器的不同而不同。

柔性数组的特点

结构中的柔性数组的成员前面必须包含至少一个其他成员。
sizeof 返回的这种结构大小不包括柔性数组的内存。例如：上面所举的结构S所占空间大小就是4。
包含柔性数组成员的结构用 malloc函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

例如：

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

int main()
{
	//期望数组arr的大小是10个整型
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));

	return 0;
}

这时候指针ps指向的空间：

使用开辟的柔性数组：

通过调试可以看到arr数组的变化：

完整的使用例：

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

int main()
{
	//期望数组arr的大小是10个整型
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));

	ps->n = 10;
	int i = 0;
	for ( i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	//增加空间
	struct S* ptr = realloc(ps, sizeof(struct S) + 20 * sizeof(int));
	if (ptr != NULL)
	{
		ps = ptr;
	}

	//使用 - 省略
	 
	free(ps);
	ps = NULL;

	return 0;
}

存在疑问：

只要这样创建数组

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

之后对指针arr进行动态内存开辟似乎也可以达到同样的效果，那为什么还需要柔性数组呢？

也就是说，此时如果arr还需要指向一块空间，就还需要一个malloc函数专门为arr进行动态开辟。只有这样，才能保证ps指向的空间和arr指向的空间都开辟在堆上。

可以这样使用：

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

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
		return 1;
	ps->n = 10;
	ps->arr = (int*)malloc(10 * sizeof(int));
	if (ps->arr == NULL)
		return 1;

	int i = 0;
	for ( i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}

	int* ptr = realloc(ps->arr, 20 * sizeof(int));
	if (ptr != NULL)
	{
		ps->arr = ptr;
	}

	//使用 - 使用

	//释放
	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;

	return 0;
}

还需要注意释放问题：

似乎这种方法也可以达成目的。但是，这种方法存在缺点：

多次释放，容易出错；
在堆区上多次申请空间，容易在空间与空间之间留下空间碎片，而空间碎片被利用的概率较低。一旦空间碎片多了，对于内存的利用率就降低了；
内存池 —— 统一申请空间，统一使用与维护空间，维护内存的效率就高了。

空间局部性：当使用了某个位置的内存时，接下来有80%的概率使用这个位置周边内存的数据。

所以如果使用上面所述的做法，n 和 arr 可能在空间上不是连续的，当需要访问时，效率就可能受到影响。

柔性数组的优点

方便内存释放；
有利于访问速度（同时有益于减少内存碎片）。

w_pab

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
笔记22-1（C语言进阶动态内存管理）

为什么存在动态内存分配动态内存函数的介绍malloc和freecallocrealloc常见的动态内存错误1.对NULL指针的解引用操作2.对动态开辟空间的越界访问3.使用free函数释放了非动态开辟的空间4.使用free函数释放一块动态开辟的内存的一部分5.对同一块动态开辟的空间，多次释放6.动态开辟的内存忘记释放（内存泄漏 - 比较严重）经典的笔试题（可供参考：《高质量C++/C 编程指南》）题目1：运行Test函数的结果？（p = (char*)ma
复制链接

扫一扫