C语言之动态内存管理

目录

为什么存在动态内存管理

动态内存函数

malloc和free函数

calloc

realloc

动态内存的常见错误

1对空指针的解引用操作

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

3使用free来释放非动态开辟的空间

4用free释放动态内存的一部分

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

6动态内存开辟忘记释放

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

柔性数组

什么是柔性数组

柔性数组的特点

柔性数组的使用

---

为什么存在动态内存管理

我们之前已经掌握的内存使用方法

1创建一个变量    

int a=10;//局部变量--放在栈区
int Ag_a=10;//全局变量，放在静态区

 动态内存是在堆区开辟内存

2创建一个数组 是在创建一个连续的内存空间

但是上述开辟内存的方法有缺陷

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

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

动态内存函数

malloc和free函数

malloc 开辟堆区的内存空间

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

如果开辟成功，就会返回开辟好的内存空间的指针

如果开辟失败，就会返回一个空指针

因为返回值是void*,所以malloc并不知道开辟空间的类型，这个由使用者决定

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

#include
#include
#include
#include
int main()
{
	//向内存申请十个整型的空间
	int *p=(int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		//打印错误原因的一个方式
		printf("%s\n", strerror(errno));
	}
	else
	{
		//正常使用空间
		int i = 0;
		for ( i = 0; i <10; i++)
		{
			*(p + i)=i;
		}
		for ( i = 0; i < 10; i++)
		{
			printf("%d\n", *(p + i));
		}
	}
	return 0;
}

free 释放申请的空间

当动态申请的空间不在再使用的时候，就应该通过free函数来还给操作系统

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

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

#include
#include
#include
#include
int main()
{
	//向内存申请十个整型的空间
	int *p=(int*)malloc(10 * sizeof(int));
	free(p);//释放动态分配的空间
    p=NULL;//这一步是必要的，断开这个p和这个内存空间的联系，防止出错
	return 0;
}

calloc

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

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

#include
#include
#include
#include
int main()
{    
    int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		//打印错误原因的一个方式
		printf("%s\n", strerror(errno));
	}
	else
	{
		//正常使用空间
		int i = 0;
		for ( i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
            //输出10个零 因为calloc会初始化
		}
	}
	free(p);
	p = NULL;
	return 0;
}

realloc

1 ptr 是要调整的内存地址

2 size 调整之后新大小

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

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

int *p=(int*)malloc(20);
	if (p == NULL)
	{
		//打印错误原因的一个方式
		printf("%s\n", strerror(errno));
	}
	else
	{
		//正常使用空间
		int i = 0;
		for ( i = 0; i <5; i++)
		{
			*(p + i)=i;
		}
		//只是再使用malloc开辟的20个字节的空间
		//假设这里20个字节不够我们使用了
		//如果我想使用40个字节
		//就可以使用realloc来调整动态开辟的内存
		int* p2 =(int*) realloc(p, 40);
		for (i = 5; i < 10; i++)
		{
			*(p2 + i) = i;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", * (p2 + i));
		}
	}
	free(p);//释放动态分配的空间
	p = NULL;

使用注意点

1当后面的内存足够大，则直接在后面追加，后返回p

2当后面的内存不够大,则realloc会重新找一块新的内存区域，开辟一块满足需求的空间，并且把原来内存中的数据拷贝过来，释放旧的内存空间，最后返回新开辟的内存空间地址

3需要一个新的变量来接受realloc的返回值

#include
#include
#include
#include
int main()
{    
   int *p=(int*)malloc(20);
	if (p == NULL)
	{
		//打印错误原因的一个方式
		printf("%s\n", strerror(errno));
	}
	else
	{
		//正常使用空间
		int i = 0;
		for ( i = 0; i <5; i++)
		{
			*(p + i)=i;
		}
		//只是再使用malloc开辟的20个字节的空间
		//假设这里20个字节不够我们使用了
		//如果我想使用40个字节
		//就可以使用realloc来调整动态开辟的内存
		int* p2 =(int*) realloc(p, 40);
		if (p2!=NULL)
		{
			p = p2;
			for (i = 5; i < 10; i++)
			{
				*(p + i) = i;
			}
			for (i = 0; i < 10; i++)
			{
				printf("%d ", * (p2 + i));
			}
		}
	}
	free(p);//释放动态分配的空间
	p = NULL;
	return 0;
}

动态内存的常见错误

1对空指针的解引用操作

#include
#include
#include
#include
int main()
{
	int* p = (int*)malloc(1000000000000);//肯定会开辟失败
	//一定要对malloc的返回值做空指针判断
	int i = 0;
	for ( i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}

	return 0;
}

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

#include
#include
#include
#include
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;
	}
    free(p);
	p = NULL;
	return 0;
}

3使用free来释放非动态开辟的空间

#include
#include
#include
#include
int main()
{    
	int arr[10] = { 0 };//这个数组的内存空间在栈区
	int* p = arr;
	free(p);
	p = NULL;
	return 0;
}

4用free释放动态内存的一部分

#include
#include
#include
#include
int main()
{    
    int* p = (int*)malloc(10 * sizeof(int));
	if (p==NULL)
	{
		return 1;
	}
	int i = 0;
	for ( i = 0; i < 5; i++)
	{
		*p++ = i;//这样写非常不好，因为p的指针指向的位置发生变化
	}
	free(p);//这样p是指向原来p指向地址往
	//后4个int型地址的地址，只释放了部分空间
	p = NULL;
	return 0;
}

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

#include
#include
#include
#include
int main()
{       
    int* p = (int*)malloc(100);
	free(p);
    //如果加上p=NULL;就不会发生任何事，
	//因为free(NULL),free函数不会有任何处理
	free(p);
	return 0;
}

6动态内存开辟忘记释放

#include
#include
#include
#include
void test()
{
	int* p = (int*)malloc(100);
	if (p==NULL)
	{
		return;
	}
	//使用
}
int main()
{       
    test();//出了这函数p销毁了，所以在test中不销毁这个动态内存空间，
    //那那一段空间就永远不能销毁
	return 0;
}

动态开辟的空间，有两种回收方式

1主动free

2程序结束

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

切记：

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

面试题 

第一题

 在调用GetMemory时，传的是str的值，所以传p接收到的是空指针，然后在GetMemory函数内将开辟空间的地址给p，由于p只是str的一份临时拷贝，所以出了这个函数p这个临时变量就销毁了，所以str还是一个空指针，把hello world放入空指针所以strcpy会失败，而且p这个指向的动态开辟空间在函数内没有释放，所以出了GetMemory这块动态内存无法释放，所以会导致内存泄漏

printf(str)没有错误，因为可以想printf("hello world"),"hello world"这一个字符串产生的是h的地址，而str也是一个字符指针，里面装的也是地址

正确代码

#include
#include
#include
#include
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;
}
void GetMemory1(char** p)
{
	*p = (char*)malloc(100);
}
void Test1(void) {
	char* str = NULL;
	GetMemory1(&str);
	strcpy(str, "hello world");
	printf(str);
	free(str);
	str = NULL;
}    
int main()
{
	Test();
    Test1();
	return 0;
}

第二题

因为在GetMeomory中的p数组是一个局部变量，存在栈区，出了GetMeomory函数，这个p之前指的地址可能已经被覆盖了

第三题

 没有free，因为对开辟的动态内存空间释放

第四题

 非法访问，因为已经释放空间，还去使用这块空间（释放后，虽然这块空间还在，但是已经不属于str了，就像开酒店，你今天开了一个房间，但是你明天不能继续住了，因为房费到期了）

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

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

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

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

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

 

所以普通局部变量都是在栈区分配空间，栈区的特点是在上面创建的变量出了作用域就销毁，但是在static修饰的变量放在数据段，数据段上的变量，直到程序结束才销毁，所以生命周期变长

柔性数组

什么是柔性数组

在c99的规定中，允许在结构体的最后一个成员变量是一个未知大小的数组，被称为柔性数组 

#include
struct S
{
	int a;
	int arr[];//柔性数组成员
};
struct S1
{
	int a;
	int arr[0];//柔性数组成员
};
int main()
{
	struct S s = { 0 };
	printf("%d\n", sizeof(S));//4
	return 0;
}

柔性数组的特点

1结构体中的柔性数组成员前面必须含一个其他的成员

2sizeof返回结构体大小不含这种柔性数组

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

柔性数组的使用

#include
#include
#include
#include
struct S
{
	int a;
	int arr[];//柔性数组成员
};
int main()
{
	/*struct S s = { 0 };
	printf("%d\n", sizeof(S));*///4
	//期望arr大小是10个整型
	struct S* p = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	p->a = 10;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		p->arr[i]=i;
	}
	//realloc
	struct S* ptr =(struct S*) realloc(p, sizeof(struct S) + 20 * sizeof(int));
	if (ptr != NULL)
	{
		p = ptr;
	}

	free(p);
	p = NULL;
	return 0;
}

非柔性数组实现柔性数组功能

#include
#include
#include
#include
struct S1
{
	int a;
	int* arr;
};
int main()
{
	struct S1* p =(struct S1*)malloc(sizeof(struct S1));
	if (p = NULL)
	{
		return 1;
	}
	p->a = 10;
	p->arr = (int*)malloc(10 * sizeof(int));
	if (p->arr == NULL)
	{
		return 1;
	}
	int i = 0;
	for ( i = 0; i < 10; i++)
	{
		p->arr[i] = i;
	}
//增加
	int* ptr = (int*)realloc(p->arr, 20 * sizeof(int));
	if (ptr != NULL)
	{
		p->arr = ptr;
	}
	free(p->arr);
	p->arr = NULL;
	free(p);
	p = NULL;
	return 0;
}

虽然代码一和代码二实现的功能一模一样，但是代码一有两个好处 

首先代码一开辟的堆空间是连续的，更加容易访问，访问速度更快，因为局部性原理（空间局部性），而且连续的空间不会造成内存碎片，如果太多次malloc可能会造成内存碎片，降低内存的利用率

1方便内存释放

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

2有利于提高访存速度

连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正 你跑不了要用做偏移量的加法来寻址