C语言—动态内存管理

最新推荐文章于 2024-08-04 00:15:00 发布

The August

最新推荐文章于 2024-08-04 00:15:00 发布

阅读量1.1k

点赞数 21

分类专栏： C语言文章标签： c语言 c++ 算法经典面试题

本文链接：https://blog.csdn.net/ai_elf/article/details/130780453

版权

C语言专栏收录该内容

30 篇文章 0 订阅

订阅专栏

本文详细介绍了C/C++中的动态内存管理函数，如malloc,free,calloc,realloc的使用，以及常见的动态内存错误，如对NULL指针的解引用、越界访问和重复释放等问题。此外，还讨论了柔性数组的概念、特点和优势，以及如何利用它们进行更高效的空间管理。

摘要由CSDN通过智能技术生成

动态内存分配的意义

内存开辟方式：

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

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

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

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

动态内存函数的介绍

malloc

malloc函数的介绍：

malloc函数用于开辟（申请）内存块（动态内存开辟）

void* malloc (size_t size);

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

注：

如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

malloc函数的使用：

实例一：

//动态内存开辟
#include <stdlib.h>

int main()
{
	//假设开辟10个整形的空间 - 10* sizeof(int)
	//int arr[10];//栈区
	
	//动态内存开辟的
	int* p = (int*)malloc(10*sizeof(int));//void*
	//使用这些空间的时候
	if (p == NULL)
	{
		//printf  + strerror
		perror("main");//main: xxxxxxxxx
		return 0;
	}
	//使用
	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置为NULL

	return 0;
}

free

free函数的介绍：

free函数用来做动态内存的释放和回收的

void free (void* ptr);

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

注：

如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
如果参数 ptr 是NULL指针，则函数什么事都不做。

free函数的使用：

实例一：

//动态内存开辟
#include <stdlib.h>

int main()
{
	//假设开辟10个整形的空间 - 10* sizeof(int)
	//int arr[10];//栈区
	
	//动态内存开辟的
	int* p = (int*)malloc(10*sizeof(int));//void*
	//使用这些空间的时候
	if (p == NULL)
	{
		//printf  + strerror
		perror("main");//main: xxxxxxxxx
		return 0;
	}
	//使用
	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置为NULL

	return 0;
}

实例二：

在这里插入图片描述

实例三：

在这里插入图片描述

calloc

calloc函数的介绍：

calloc 函数用来动态内存分配。

void* calloc (size_t num, size_t size);

注：

函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

calloc函数的使用：

实例一：

在这里插入图片描述

注：所以如何程序员对申请的内存空间的内容要求初始化，那么可以很方便的使用calloc函数来完成任务。

realloc

realloc函数的介绍：

realloc函数的出现让动态内存管理更加灵活。
有时会发现过去申请的空间太小了，有时候又会觉得申请的空间过大了，那为了合理的时候内存，程序员一定会对内存的大小做灵活的调整。那realloc 函数就可以做到对动态开辟内存大小的调整。

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

ptr是要调整的内存地址
size调整之后新大小
返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
realloc在调整内存空间的是存在两种情况：
1. 原有空间之后有足够大的空间
1. 原有空间之后没有足够大的空间

在这里插入图片描述

情况1 当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。情况2 当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。由于上述的两种情况realloc函数的使用就要注意一些。
1. realloc有可能找不到合适的空间来调整大小，这时就返回NULL
realloc在调整内存空间时后面空间如果足够它会返回旧的地址，如果后面的空间增加的时候发现不够用它会在内存中找一块新的空间并把内容拷贝下来，把那块空间释放掉，最后把新的地址返回去

realloc函数的使用：

实例一：

int main()
{
	int* p = (int*)calloc(10, sizeof(int));

	if (p == NULL)
	{
		perror("main");
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = 5;
	}
	//这里需要p指向的空间更大，需要20个int的空间
	//realloc调整空间

	int*ptr = (int*)realloc(p, 20*sizeof(int));
	if (ptr != NULL)
	{
		p = ptr;
	}

	free(p);
	p = NULL;

	return 0;
}

实例二：

int main()
{
	int* p = (int*)realloc(NULL, 40);//这里功能类似于malloc（realloc函数中的第一个参数传NULL），就是直接在堆区开辟40个字节

	return 0;
}

总结：
realloc函数调整动态内存大小的时候会有三种情况：

原有空间之后有足够大的空间。
原有空间之后没有足够大的空间。
整个堆区上没有合适的空间

在这里插入图片描述

常见的动态内存错误

对NULL指针的解引用操作

实例一：

#include<stdio.h>
int main()
{
	int* p = (int*)malloc(10000000000);
	int i = 0;
	for (i = 0;i < 10;i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
	return 0;
}

注：

如果p的值是NULL，上段代码就会有问题（会出现对NULL的解引用操作）
对malloc函数的返回值进行判空处理

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

实例一：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(10*sizeof(int));
	if (p == NULL)
	{
		perror("main");
		return 1;
	}
	int i = 0;

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

注：当i是10的时候指针会发生越界访问

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

int main()
{
	int arr[10] = { 0 };
	int* p = arr;
	free(p);
	p = NULL;
	return 0;
}

注：

使用free对p进行非动态内存的释放（p是局部变量，是在栈上开辟的）
在VS编译器中使用对非动态开辟内存使用free释放程序会挂掉

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

实例一：

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("main");
		return 1;
	}
	int i = 0;
	for (i = 0;i < 5;i++)
	{
		*p++ = i;
	}
	free(p);
	p = NULL;
	return 0;
}

注：

p指针这样走的话会释放空间的一部分，但是这种写法本身是错误的（p不再指向动态内存的起始位置，而是从p+4的位置开始释放内存空间）
不知道这块空间的起始位置，会存在内存泄漏的风险（而起始位置到p+4是没有被释放的，这样会产生内存泄漏的问题）
在VS编译器中使用free释放一块动态开辟内存的一部分会出现程序挂掉（程序走起来会报错）

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

实例一：

int main()
{
	int* p = (int*)malloc(sizeof(100));
	free(p);
	free(p);
	return 0;
}

注：

避免对同一块动态内存多次释放可以将p进行释放后，手动将p置成空指针
在VS编译器中使用对同一块动态内存多次释放会出现程序挂掉

int main()
{
	int* p = (int*)malloc(sizeof(100));
	free(p);
	p = NULL;
	free(p);
	return 0;
}

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

实例一：

void test()
{
	int* p = (int*)malloc(sizeof(100));
	if (p == NULL)
	{
		return;
	}
}
int main()
{
	test();
	return 0;
}

注：

动态内存开辟的空间有两种情况会进行销毁：主动销毁（主动free）；程序结束
如果一个服务器程序（7*24），动态开辟内存忘记释放那么就找不到这块空间，这块空间就永远无法释放，这时就会形成内存泄漏的问题

总结：忘记释放不再使用的动态开辟的空间会造成内存泄漏。

切记：动态开辟的空间一定要释放，并且正确释放。

经典的笔试题

实例一：

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

运行结果：程序挂掉

解析：
str传给GetMemory函数的时候是值传递，所以GetMemory函数的形参p是str的一份临时拷贝。
在GetMemory函数内部动态申请空间的地址，存放在p中，不会影响外边str，所以当GetMemory函数结束之后，str依然是NULL。所以strcpy会失败.
当GetMemory函数返回之后，形参p销毁，使得动态开辟的100个字节存在内存泄漏。无法释放。

修改一：

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); //printf函数可以打印字符串的首字符的地址所指向的字符串，printf函数的参数可以是字符串首字符的地址
	//printf函数打印字符串本质上传参传递的时字符串的首字符的地址并不是字符串
	free(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

修改二：

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);
	free(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

实例二：

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

注：

像上面GetMemory 这样的函数—返回栈空间地址的问题

解释：
GetMemory 函数内部创建的数组是在栈区上创建的出了函数，p数组的空间就还给了操作系统返回的地址是没有实际的意义，如果通过返回的地址，去访问内存就是非法访问内存的。
解决方法：
在堆上创建一块空间并赋给p，这样GetMemory 函数的返回地址赋给str，这样访问的内存是有效的。

实例三：

int* f1(void)
{
	int x = 10;
	return &x;
}

解释： fi函数内部创建的整形是在栈区上创建的出了函数，整形x的空间就还给了操作系统返回的地址是没有实际的意义，如果通过返回的地址，去访问内存就是非法访问内存的。

实例四：

int* f2(void)
{
	int* ptr;
	*ptr = 10;
	return ptr;
}

解释： f2函数内部创建的ptr指针未定义（未初始化），造成野指针问题，接下来*ptr = 10;这步系统就会报错。
解决方法： 将ptr初始化或将ptr置成空指针

实例五：

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

注：

这段代码出现的问题是没有将释放动态内存开辟的空间
解决方法：释放str，将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;
}
int main()
{
	Test();
	return 0;
}

在这里插入图片描述

实例五：

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

解释：在Test函数将str释放完之后，如果接下来没有将释放的指针置为空指针，那么将造成越界访问
解决方法：将释放的指针立刻置为空指针

注：这道题考察的重点并不是动态申请空间释放过早而是free释放掉空间之后一定要将指针置空否则后面的代码就会出问题。如果将free这段代码放到后面逻辑就不通了，free这段代码拿到后面if判断就很诡异在拷贝hello字符串时都没有判断指针是否为空，反而在后面拷贝时判断指针是否为空，逻辑就不通了。

修改：

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

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

在这里插入图片描述
注：

代码编译完之后的可执行代码（二进制代码）都是放在代码段的
全局变量和静态变量（无论是全局还是局部）是存放在数据段的
常量字符串是存放在代码段中的
实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁所以生命周期变长。

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

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

柔性数组

柔性数组的定义

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

实例一：

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

实例二：

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

注：

在各种编译器中以上两种形式可能会支持其中一种也有可能都支持
VS2019编译器是支持这个特性的

柔性数组的特点

柔性数组的特点：

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

实例一：

struct S
{
	int n;
	int arr[];//大小是未知
};


int main()
{
	
	struct S s = {0};  //这样创建的arr是无法使用的
	printf("%d\n", sizeof(s));//4

	return 0;
}

实例二：

struct S
{
	int n;//4
	int arr[0];//大小是未知
};

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 = (struct S*)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[0];
};
int main()
{
	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=(struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
	if (ptr != NULL)
	{
		ps = ptr;
	}
	free(ps);
	ps = NULL;
	return 0;
}

//结构体S也可以设计成：

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(struct S));
	if (ps->arr == NULL)
	{
		return 1;
	}
	int i = 0;
	for (i = 0;i < 10;i++)
	{
		ps->arr[i] = i;
	}
	int* ptr = (int*)realloc(ps->arr, 20 * sizeof(int));
	if (ptr != NULL)
	{
		ps->arr = ptr;
	}
	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;
	return 0;
}

上述版本一和版本二可以完成同样的功能，但是版本一的实现有两个好处：

第一个好处是：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
第二个好处是：这样有利于访问速度
连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）

总结：

malloc、free次数少不易出错
malloc次数较少内存碎片较少内存利用率较高
空间的连续较差会导致访存的效率方面降低

补充：

采用分区式存储管理的系统，在储存分配过程中产生的、不能供用户作业使用的主存里的小分区称成“内存碎片”。内存碎片分为内部碎片和外部碎片。
内存池（Memory Pool）是一种动态内存分配与管理技术。通常情况下习惯使用new/delete/malloc/free等API申请分配和释放内存，这样导致的后果是：当程序长时间运行时，由于所申请的内存块大小不定，频繁使用时会造成大量的内存碎片从而降低程序和操作系统的性能。内存池则是在真正使用内存之前，先申请分配一大块内存(内存池)留作备用，当我们申请内存时，从池中取出一块动态分配的内存，释放内存时，再将我们使用的内存释放到我们申请的内存池内，再次申请内存池也可以再取出来使用。并且，尽量与周边的内存块合并。若内存池不够时，则自动扩大内存池，从操作系统中申请更大的内存池。
局部性原理是指CPU访问存储器时，无论是存取指令还是存取数据，所访问的存储单元都趋于聚集在一个较小的连续区域中。
空间局部性（Spatial Locality）：在最近的将来将用到的信息很可能与正在使用的信息在空间地址上是临近的。