【C语言】—— 动态内存管理

 

目录

一、为什么会存在动态内存管理

二、动态内存函数的介绍

1.malloc和free函数

2.calloc函数 

3.realloc函数

三、常见的动态内存错误 

例题1 

例题2 

---

一、为什么会存在动态内存管理

我们常见的内存开辟方式：

int a = 10;//在栈区上开辟4个字节的空间
char str[10] = { 1,2,3,4,5,6,7,8,9,10 };//在栈区上开辟10个字节连续的空间

以上的开辟方式有连个特点：

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

        2.数组在开辟空间时需给定大小；

对于空间的要求不仅仅只是上述两种情况，以通讯录（后期会做介绍）为例，存储联系人信息时，需要向内存申请空间，如果一次性申请很大的空间，联系人很少，就会导致空间的浪费，如果一次性申请很小的空间，联系人很多，就会导致空间不够；此时就利用到动态内存了，需要多少个字节的空间，就向内存申请多少，实现了内存空间的有效利用。

二、动态内存函数的介绍

1.malloc和free函数

malloc函数 ：

函数原型：void *malloc( size_t size );

头  文  件：<stdlib.h>

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

参数解读：size_t size: 向内存申请size个字节的空间；

注意事项：

        1. 如果开辟成功，则返回一个指向开辟好空间的指针。

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

        3. 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定（意为：将返回的指针强转类型）。

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

        5. 每次开辟完空间后，都需要对其进行释放；

free函数：

函数原型：void free( void *memblock );

头  文  件：<stdlib.h>

函数功能：用来释放之前开辟的空间；

注意事项：

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

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

        3. free之后要将指针置为空；

#include <stdio.h>
#include <stdlib.h>
int main()
{
    //申请空间
	int* ptr = (int*)malloc(40);
	if (ptr == NULL)
	{
		return -1;
	}
    //申请成功
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(ptr + i) = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(ptr + i));
	}
	printf("\n");
    //释放空间
	free(ptr);
	ptr = NULL;//让ptr找不到那块空间
	return 0;
}

2.calloc函数 

函数原型：void *calloc( size_t num, size_t size ); 

头  文  件：<stdlib.h>

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

注意事项：每次开辟完空间后，都需要对其进行释放（free）；

malloc和calloc的区别：

        malloc函数只负责在堆区开辟空间，并且返回起始地址，不初始化内存空间；

        calloc函数在堆区上申请空间，并且初始化为0，返回起始地址；

malloc和calloc区别代码实现：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* ptr = (int*)calloc(10, sizeof(int));
	//申请空间
	if (ptr == NULL)
	{
		return -1;
	}
	//是否初始化？来判断一下
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(ptr + i));
	}
	//释放空间
	free(ptr);
	ptr = NULL;
	return 0;
}

 

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* ptr = (int*)malloc(40);
	//申请空间
	if (ptr == NULL)
	{
		return -1;
	}
	//是否初始化？来判断一下
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(ptr + i));
	}
	//释放空间
	free(ptr);
	ptr = NULL;
	return 0;
}

 

从运行结果来看，calloc函数可以将申请的空间进行初始化，而malloc函数不可以，其打印的结果是随机值； 

3.realloc函数

函数原型： void *realloc( void *memblock, size_t size );

头  文  件：<stdlib.h>

函数功能：相比malloc和calloc函数而言，realloc函数会更灵活；

参数解读：

        1. memblock 是要调整的内存地址；

        2. size 调整之后新大小；

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

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

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

        1.原有空间之后有足够大的空间 ----直接扩大

        2.原有空间之后没有足够大的空间 ----重新找一块新的2倍大的空间，并将原来的数据拷贝过去

举例：

#include <stdlib.h>
#include <string.h>
int main()
{
	//申请空间
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		return -1;
	}
	//申请成功，开始赋值
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	//打印数据
	printf("增加空间前：");
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	printf("\n");
	//此时需要存入10~19这些数据，就需要增加空间
	int* ptr = realloc(p, 20 * sizeof(int));
	if (ptr != NULL)
	{
		p = ptr;
	}
	else
	{
		return -1;
	}
	for (i = 10; i < 20; i++)
	{
		*(p + i) = i;
	}
	printf("增加空间后：");
	for (i = 0; i < 20; i++)
	{
		printf("%d ", *(p + i));
	}
	printf("\n");
    //释放空间
	free(p);
	p = NULL;
	return 0;
}

三、常见的动态内存错误 

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

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

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

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

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

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

例题1 

//请问运行Test 函数会有什么样的结果
#include <stdio.h>
#include <stdlib.h>
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;
}

存在的问题： 

        1. malloc申请的空间，没有释放；

        2. malloc开辟的空间是存在形式参数p中的，一旦这段程序运行结束，想要销毁都来不及，所以存在内存泄露；

        3. 程序崩溃；

强调：

        1.str传给p的时候，是值传递，p是str的临时拷贝，所以当malloc开辟的空间起始地址放在p中的时候，不会影响str。str仍为NULL;

        2.当str是NULL，strcpy想把hello world拷贝到str指向的空间时，程序崩溃了。因为NULL指针指向的空间是不能被访问的

例题2 

//请问运行Test 函数会有什么样的结果
#include <stdio.h> 
#include <stdlib.h> 
char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
int main()
{
	Test();
	return 0;
}

 存在的问题：

        p数组是局部变量，它的生命周期出大括号结束；虽然str拿到了p数组的地址，但是p数组所在的那块空间已经销毁了，此时str就是野指针了；再对它进行打印就会造成非法访问；