掌握动态内存管理：做内存的主人

编程版小新

已于 2024-04-04 15:58:10 修改

阅读量881

点赞数 19

分类专栏： C语言经典例题 C语言文章标签：动态内存开辟 malloc calloc realloc 柔性数组内存在空间的分配 free

于 2024-04-02 09:45:00 首次发布

本文链接：https://blog.csdn.net/Zhihuiguoz/article/details/137205797

版权

C语言同时被 2 个专栏收录

14 篇文章 0 订阅

订阅专栏

C语言经典例题

7 篇文章 0 订阅

订阅专栏

✨✨小新课堂开课了，欢迎欢迎~✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：http://t.csdnimg.cn/Oytke

小新的主页：编程版小新-CSDN博客

一：静态内存开辟

通过前面基础知识的学习，我们已经掌握了开辟内存的方法:

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

但是通过这种方式开辟的内存空间有很大的局限性

• 空间开辟大小是固定的

• 数组在声明的时候，必须指定数组的长度，数组空间一旦确定了大小不能调整

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组在编译时开辟空间的方式就不能满足了。

二：动态内存开辟

C语言引入了动态内存开辟，让程序员自己可以申请和释放空间，就比较灵活了。

接下里让我们学习几个用于开辟动态内存的函数。

1.动态内存开辟函数

（1）malloc

void* malloc (size_t size);

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

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

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

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

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

在介绍这个函数以及其他动态内存开辟的函数之前，这里要先穿插两个其他的函数。

（1）free（动态内存的释放）

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

void free (void* ptr);

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

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

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

malloc和free都声明在 stdlib.h 头文件中。

下面要介绍的几个开辟动态内存的函数的声明都在stdlib.h头文件中

（2）perror

void perror ( const char * str );

在不同的系统和C语言标准库的现实中规定了一些错误码，一般放在<errno.h>这个头文件中说明的，C语言程序启动的时候会使用一个全面的变量来记录程序中当前的错误，只不过程序在刚启动的时候errno是0，表示没有错误，但当我们使用标准库中的函数又出现了某种错误的时候，就会将对应的错误码存放在errno中，而一个错误码的数字又很难理解是什么意思，所以每一个错误码都是有对应的错误信息的。perror函数就能将错误信息的字符串的地址返回来。

下面我们举个例子：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<errno.h>
#include<string.h>
int main()
{
	//fopen以读的形式打开文件，如果文件不存在，就打开失败
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		perror("xiaoxin");
		return 1;
	}
	//读文件
 
	//关闭文件
	fclose(pf);
	
	return 0;
}

运行结果：

这里要注意的是在使用perror函数的时候要给函数传参，如果不知道传什么就可以传空字符串，但不能不传。

接下来我们回归主线，继续学习malloc函数

举个例子吧

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

int main()
{
	//20个字节——存放5个整型
	int* p = (int*)malloc(20);//注意强制类型转化
	if (p == NULL)//判断p指针是否为空 
	{
		perror("malloc");
		return 1;
	}

	//使用空间
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}

	//释放p所指向的动态内存空间
	free(p);//传递给free函数的是要释放的内存空间的起始地址
	p = NULL;//这里要置为NULL,是为了防止p成为野指针

	return 0;
}

运行结果：

代码返回0说明运行正常。

小新：大家在使用动态内存的时候，事后一定要释放动态内存空间，并将其置为NULL。可以简单的理解为，动态内存函数和free函数是成对出现的，不然的会就会造成内存泄漏，这个后面会讲到。

（2）calloc

C语言还提供了⼀个函数叫 calloc ， calloc 函数也用来动态内存分配。原型如下：

void* calloc (size_t num, size_t size);

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

• 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

证明：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)calloc(5, sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", *(p + i));
	}
	free(p);
	p = NULL;
	return 0;
}

运行结果：

所以如果我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloc函数来完成任务。

（3）realloc

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

• 有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的使用内存，我们一定会对内存的大小做灵活的调整。

那 realloc 函数就可以做到对动态开辟内存大小的调整。

函数原型如下：

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

• ptr 是要调整的内存地址

• size 调整之后新大小

• 返回值为调整之后的内存起始位置。

• 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。

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

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

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

我们来看realloc的用法：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)calloc(5, sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}
	//希望将空间调整为40个字节
	int* ptr = (int*)realloc(p, 40);
	if (ptr != NULL)//调整成功
	{
		p = ptr;
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p + i) = i + 1;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
		free(p);
		p = NULL;
	}
	else//调整不成功
	{
		perror("realloc");
		free(p);
		p = NULL;;
	}
	return 0;
}

这种就属于是情况1。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)calloc(5, sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}
	//希望将空间调整为40个字节
	int* ptr = (int*)realloc(p, 400000);//这里相对上一个有所不同
	if (ptr != NULL)//调整成功
	{
		p = ptr;
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p + i) = i + 1;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
		free(p);
		p = NULL;
	}
	else//调整不成功
	{
		perror("realloc");
		free(p);
		p = NULL;
	}
	return 0;
}

这种就属于情况2。

2.常见的动态内存错误

（1）对NULL指针的解引用操作

void test()
 {
 int *p = (int *)malloc(INT_MAX/4);
 *p = 20;//如果p的值是NULL，就会有问题 
 free(p);
 }

INT_MAX是一个宏定义，他表示整型的最大值，值为2147483647。
当malloc申请的空间太大时存在失败的情况，失败返回NULL指针。
而系统无法访问NULL指针指向的地址，这时编译器会报一个警告

要先对其进行判断，不是NULL的情况下才能解引用

修正版：

#include<stdio.h>
#include<stdlib.h>
void test()
{
	int* p = (int*)malloc(INT_MAX / 4);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	*p = 20;//如果p的值是NULL，就会有问题 
	free(p);
	p = NULL;
}

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

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

void test()
 {
 int i = 0;
 int *p = (int *)malloc(10*sizeof(int));
 if(p == NULL)
 {
 perror("malloc");
 return 1;
 }
 for(i=0; i<=10; i++)
 {
 *(p+i) = i;//当i是10的时候越界访问 
 }
 free(p);
 p=NULL;
 }

这里只需要将i<=10改为i<10即可。

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

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

不能够正常运行

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

void test()
{
	int* p = (int*)malloc(100);
	p++;
	free(p);//p不再指向动态内存的起始位置 
}

这种情况下有一个整型空间的内存大小没有被释放，造成内存泄露。

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

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

还是像上面的几个错误一样，都不能正常运行

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

#include<stdio.h>
#include<stdlib.h>
void test()
{
	int* p = (int*)malloc(100);
	if (p != NULL)
	{
		*p = 20;
	}
}

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

小新：大家一定要记得用完之后，手动释放，虽然在程序结束之后，操作系统会自行释放，但我们还是要养成好的习惯，在使用完之后手动释放，避免内存泄漏。

动态开辟的空间⼀定要释放，并且正确释放

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

题目一：

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

这段短短的代码存在两个典型的错误：

1.内存的非法访问：我们能到看出这里的函数调用是传值调用，这样我们就会联想到形参只是实参的一份临时拷贝，改变形参不会影响实参，所有str还是NULL，strcpy函数的使用相当于是对NULL解引用，这样是会使程序崩溃的。

2.内存泄漏：我们想开辟一块空间，在把hello world拷贝进去，但是p在使用完之后内存空间就还给操作系统了，出了{}已经是找不到了，做不到而且也没有对动态内存进行释放。这样就会导致内存泄漏。

既然已经找到了错误，那我们该怎么改呢，其实这里采用传址调用就行了，用二级指针进行接收，然后再对动态内存进行释放。

改正之后：

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

题目二：

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

运行结果：

其实这是一个很经典的野指针的问题，在出了作用域{}之后，其内存空间就还给操作系统了，但是后来printf又去访问这个空间，这不就是变相对NULL 解引用。

这里只要不把那块空间还给操作系统其实就能解决这个问题了，我们知道存放在栈上数据，在出了作用域之后就会被销毁，那我们不把数据放在栈上，而是放在静态区上就行了，这有两种方式：static修饰与const修饰。

 const char* GetMemory1(void)
{
	const char* p = "hello world";
	return p;
}
 char* GetMemory2(void)
 {
	 static char p[] = "hello world";
	 return p;
 }
 
void Test(void)
{
	char* str = NULL;
	str = GetMemory1();
	printf(str);
	printf("\n");
	str = GetMemory2();
	printf(str);
}
 
int main()
{
	Test();
	return 0;
}

题目三：

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

这个除了没有释放内存，一切完美。没有释放内存就会存在内存泄漏的问题。

修正后：

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

题目四：

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

这里错略一看好像没有什么问题，但是大家会不会以为用free函数释放动态内存之后，要释放的那块内存就会自动变为NULL，其实是不会的，这里在释放之后，还要手动的将其置为NULL，没有置为NULL，这样就相当于是野指针。置为NULL后就不在进行后面的操作。

改正之后：

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

三.柔性数组

1.什么是柔性数组

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

例如：

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

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

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

2.柔性数组的特点

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

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

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

3.柔性数组的大小

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

typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员 
}type_a;
int main()
{
	printf("%d\n", sizeof(type_a));
	return 0;
}

运行结果：

由此可见，结构体大小是不包括柔性数组的。

4.柔性数组的使用

#include <stdio.h>
#include <stdlib.h>
typedef struct st_type
{
	int i;
	int a[]; //柔性数组成员
}type_a;
int main()
{
	int i = 0;
	type_a* p = (type_a*)malloc(sizeof(type_a) + 100 * sizeof(int));
	//包含柔性数组成员的结构⽤malloc()函数进⾏内存的动态分配，
	//分配的内存应该⼤于结构的⼤⼩，以适应柔性数组的预期⼤⼩。
	p->i = 100;
	for (i = 0; i < 100; i++)//存放数据
	{
		p->a[i] = i;
	}
	free(p);
    p = NULL;
	return 0;
}

这样柔性数组成员a，相当于获得了100个整型元素的连续空间。

5.柔性数组的优势

上述的 type_a 结构也可以设计为下面的结构，也能完成同样的效果。

#include <stdio.h>
#include <stdlib.h>
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和代码2可以完成同样的功能，但是方法1（柔性数组）的实现有两个好处：

第一个好处是：方便内存释放

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

第二个好处是：这样有利于访问速度.

连续的内存有益于提高访问速度，也有益于减少内存碎片。

四.内存的空间分布

C/C++程序内存分配的几个区域：

1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

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

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

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

下课了~