c语言之动态内存管理篇

动态内存管理

1.为什么存在动态内存分配

int a=10;//固定向内存申请了4个字节
int arr[10];//向内存申请了连续的空间
//c99规定的变长数组
int n=0;
int arr[n]；//一旦申请空间后就不能改变了

我们不难发现以上这些一旦向内存申请好空间就不能改变了，c语言中有没有某种东西，当我申请完空间后可以随时变大变小？这就是我们今天要介绍的动态内存管理，它相比于静态的更加灵活。

2.动态内存函数的介绍

在介绍动态内存分配函数前，我们了解过：

2.1malloc函数

堆区内存申请函数，这个函数申请的是连续的空间

头文件：#include

void* malloc (size_t size);

size：申请多少字节
void*：返回指向那块空间的起始地址
申请失败：返回NULL，比如INT_MAX
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器（vs上是不报错的）
注意：这个函数只是申请了多少字节，但是没标明申请的是什么类型，所以这个需要我们来定义

//动态内存管理
#include
#include//注意头文件
int main()
{
	//申请40个字节，存放10个int
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//存放1~10
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}
	//打印1~10
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

但是这段代码还有问题，就是你向堆区申请了空间，但是你又占着空间不用，虽然操作系统会在程序结束后回收，但是我们最好还是主动去还，以免造成不必要的麻烦

2.2free

这就是释放动态开辟内存的函数

头文件：#include

如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的，就是说它只是作用于堆区，对其他区是未定义的。
如果参数 ptr 是NULL指针，则函数什么事都不做。

void free (void* ptr);

ptr：指向开辟空间的起始地址

//动态内存管理
#include
#include
int main()
{
	//申请40个字节，存放10个int
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//存放1~10
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}
	//打印1~10
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//释放堆区开辟的空间
	free(p);
	return 0;
}

这段代码还是有风险的，free函数只会释放空间，但不会改变p的地址，那么问题就来了，万一有人通过p非法访问怎么办？这就需要将p置为NULL。

//动态内存管理
#include
#include
int main()
{
	//申请40个字节，存放10个int
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//存放1~10
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}
	//打印1~10
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//释放堆区开辟的空间
	free(p);
	p=NULL;//注意
	return 0;
}

2.3calloc函数

用来开辟一个数组，并将这个数组每一个元素初始化为0

头文件：#include

void* calloc (size_t num, size_t size);

num：数组元素个数
size：每个元素大小
申请失败：返回NULL
注意：这个函数没标明申请的是什么类型，所以这个需要我们来定义

//}
#include
#include
int main()
{
	//申请一个整型数组，10个元素，每个元素大小为int
	int* p = (int*)calloc(10,sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	//直接打印10个元素
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//释放开辟的空间
	free(p);
	//防止非法访问
	p = NULL;
	return 0;
}

运行结果：
0 0 0 0 0 0 0 0 0 0

2.4realloc函数

动态内存调整函数

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

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

ptr：指向开辟的空间，如果传NULL，功能相当于malloc函数
size：调整为多少字节
调整失败：返回NULL
注意：这个函数会将调整后的地址返回来，但是也没说是什么类型，所以类型需要我们来定义

#include
#include
int main()
{
	//向堆区开辟空间
	int* p = (int*)calloc(5, sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	//初始化为1
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = 1;
	}
	//调整为10个元素
	p = realloc(p, 10 * sizeof(int));//？
	//释放空间大小
	free(p);
	//防止非法访问
	p = NULL;
	return 0;
}

上面的代码还是有点小问题，就是能不能用p来接收新调整的空间的起始地址，这里分为两种情况


如果直接用p去接收，如果扩容失败，返回NULL，那么你就会把原数据弄丢，所以要用新指针接收。

#include
#include
int main()
{
	//向堆区开辟空间
	int* p = (int*)calloc(5, sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	//初始化为1
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = 1;
	}
	//调整为10个元素
	int* ptr = realloc(p, 10 * sizeof(int));
	if (ptr != NULL)
	{
		p = ptr;
	}
	//初始化为1
	for (i = 0; i < 10; i++)
	{
		*(p + i) = 1;
	}
	//打印
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//释放空间大小
	free(p);
	//防止非法访问
	p = NULL;
	return 0;
}

3.常见的动态内存错误

3.1对空指针的解引用操作

#include
#include
int main()
{
	int* p = (int*)malloc(100);
	//如果不判断，万一为NULL
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		//如果为NULL，那么对NULL加i为野指针，对野指针操作是危险的
		printf("%d ", *(p + i));
	}
	free(p);
	p = NULL;
	return 0;
}

3.2对内存开辟的空间进行越界访问

#include
#include
int main()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return 1;
	}
	//越界访问
	int i = 0;
	for (i = 0; i < 100; i++)
	{
		*(p + i) = 1;
	}
	free(p);
	p = NULL;
	return 0;
}

3.3对非动态内存开辟使用free函数

#include
#include
int main()
{
	//局部变量是存放在栈区的
	int a = 10;
	int* p = &a;
	//free函数只能释放堆区的空间
	free(p);
	p = NULL;
	return 0;
}

3.4使用free释放动态开辟空间的一部分

#include
#include
int main()
{
	int* p = (int*)malloc(100);
	int i = 0;
	for (i = 0; i < 25; i++)
	{
		*p = i;
		p++;
	}
	//注意结束后，p不指向开辟空间的起始位置
	//那么free就只会释放一部分空间
	free(p);
	p = NULL;
	return 0;
}

3.5对同一块动态内存多次free

#include
#include
int main()
{
	int* p = (int*)calloc(10, 4);
	if (p == NULL)
	{
		return 1;
	}
	free(p);
	//...
	//p为野指针了
	//但是p=NULL就不会出错，因为free（NULL）；什么也不做
	//有进行一次free
	free(p);
	return 0;
}

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

#include
#include
void test()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return 1;
	}
	//...
	//忘记释放了
}
int main()
{
	test();
	return 0;
}

这种错误很危险，会将内存泄露
解决方法：

#include
#include
void test()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return 1;
	}
	free(p);
	p = NULL;
}
int main()
{
	test();
	return 0;
}

#include
#include
//改函数中进行了malloc操作，返回了malloc开辟空间的起始地址
//记得释放空间
int* test()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return 1;
	}
	return p;
}
int main()
{
	int* ptr=test();
	//记得释放空间
	free(ptr);
	ptr = NULL;
	return 0;
}

4.几个经典的面试题

#include
#include
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.存在内存泄漏，你申请了空间，调用完函数p会销毁，没人知道这个空间在哪，就会造成泄露
2.传值调用：对形参的改变不影响实参，str拷贝形成了非法访问

#include
#include
//该函数进行了malloc操作
//记得free
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;
}
int main()
{
	Test();
	return 0;
}

输出结果：
hello world

2.栈区地址的返回问题

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

这个代码是有问题的，运行结果并不是hello world。
首先，调用Test函数，再调用GetMemory函数，str接收了这个数组的首元素地址，但是GetMemory会被销毁，str接收的地址就无明确指向关系，所以是打印出的东西是乱的，下面的一段代码同理。

#include
int* test()
{
	int a = 10;
	return &a;
}
int main()
{
	int*p=test();
	printf("hehe\n");
	printf("%d\n", *p);
	return 0;
}

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

这个代码的问题就是堆区开辟的内存没有释放。
4.

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

这个代码的问题就是非法访问

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

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

5.柔性数组

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

struct stu
{
	char c;
	int i;
	int arr[];//1.结构体中的最后一个元素是数组
	//2.数组元素个数是未知的
	//int arr[0];这种写法也是对的
};

5.1柔性数组的特点

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

#include
#include
struct stu
{
	char c;
	int i;
	int arr[];

};
int main()
{
	//柔性数组是不参与结构体计算的
	printf("%d\n", sizeof(struct stu));
	//柔性数组的开辟是用动态内存开辟的
	struct stu* pc = (struct stu*)malloc(sizeof(struct stu) + 10 * sizeof(int));
	if (pc == NULL)
	{
		return;
	}
	pc->i = 10;
	//对数组进行初始化
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(pc->arr+i) = i + 1;
	}
	//打印
	for (i = 0; i < 10; i++)
	{
		printf("%d ", pc->arr[i]);
	}
		//增容
	struct stu* ptr = (struct stu*)realloc(pc, sizeof(struct stu) + 20 * sizeof(int));
	if (ptr != NULL)
	{
		pc = ptr;
	}
	else
	{
		perror("realloc");
		return;
	}
	//即使增容了，柔性数组也是不参与结构体大小计算的
	printf("%d\n", sizeof(struct stu));
	free(pc);
	pc = NULL;
	return 0;
}

#include
#include
struct s
{
	int i;
	int* p;
};
int main()
{
	struct s* pc = (struct s*)malloc(sizeof(struct s));
	if (pc == NULL)
	{
		perror("malloc->pc");
		return 0;
	}
	pc->i = 0;
	pc->p = (int*)malloc(10 * sizeof(int));
	if (pc->p == NULL)
	{
		return;
	}
	//释放
	free(pc->p);
	pc->p = NULL;
	free(pc);
	pc = NULL;
	return 0;
}

上述 代码1 和 代码2 可以完成同样的功能，但是 方法1 的实现有两个好处

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

总结：

以上就是本篇的所有内容了，如果喜欢本篇，不妨点个赞，如果想要持续了解更多，欢迎关注我，谢谢大家的观看，下期间！