[C++知识库]动态内存管理（C语言系列20）

目录

前言：

1.为什么会存在动态内存管理

2.动态内存函数的介绍

2.1malloc函数

2.2free函数

2.3calloc函数

2.4realloc函数

2.4.1为什么会有realloc函数

2.4.2realloc函数的定义

3.常见的动态内存错误

4.c/c++程序内存的开辟

5.柔性数组

5.1柔性数组的定义

5.2柔性数组的特点

5.3柔性数组的使用

5.4柔性数组的优势

结束语：

前言：

这次小编想与大家分享一下关于动态内存管理方面的一些知识，关于为什么会存在动态内存管理，动态内存管理都会有哪些函数，如何开辟空间，如何释放空间以及一些常见的动态内存的错误。

1.为什么会存在动态内存管理

在此之前我们先来回顾一下我们之前是如何开辟一块空间的。

• int a = 10;是在栈空间上开辟了4个字节的空间。
• char arr[20] = {0};是在栈空间上开辟了20个字节的连续空间。

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

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

2.动态内存函数的介绍

2.1malloc函数

定义：是C语言提供的一个动态内存开辟的空间的函数。

头文件：#include<stdlib.h>

格式：void* malloc（size_t?size）。

规则：

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

代码如下所示：

#define _CRT_SECURE_NO_WARNINGS 1
//malloc函数
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	int* ptr = p;
	//判断是否为空指针
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//不是空指针，继续
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*ptr = i;
		ptr++;
	}
	//使用free释放空间
	free(p);
	p = NULL;
	ptr = NULL;
	return 0;
}

2.2free函数

定义：free是用来释放动态开辟的内存的。

头文件：#include<stdlib.h>

规则：

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

注意：malloc和free是成对出现的。

代码如上面malloc函数中的代码所示。

?

2.3calloc函数

格式：void* malloc（size_t num,size_t size）

头文件：#include<stdlib.h>

规则：

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

特点：

• malloc的效率高于calloc，因为malloc不需要初始化0。
• calloc = malloc + memset
• calloc + free成对出现。

代码如下所示：

#define _CRT_SECURE_NO_WARNINGS 1
//calloc函数
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)calloc(10 , sizeof(int));
	//判断是否为空指针
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	//不是空指针再往下走
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	//释放空间
	free(p);
	p = NULL;
	return 0;
}

?

2.4realloc函数

2.4.1为什么会有realloc函数

• realloc函数的出现让动态内存管理更加灵活。
• 有时候我们会发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的内存，我们一定会对你才能的大小进行灵活的调整。

2.4.2realloc函数的定义

格式：void* realloc （void* ptr , size_t size）。

头文件：#include<stdlib.h>

规则：

• ptr是要调整的内存地址。
• size是调整之后的新大小。
• 返回值为调整之后的内存起始位置。
• 这个函数在调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间中。

realloc在调整内存空间的时候存在两种情况：
情况1：原空间值后有足够大的空间。

扩展方法：之间在原内存后面追加空间，原内存的数据不变。

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

扩展方法：在堆上在找一块足够的大的连续空间来使用，然后将原来空间中的数据拷贝一份放到新的空间内。

代码展示：

#define _CRT_SECURE_NO_WARNINGS 1
//realloc函数
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//增加空间
	int* ptr = (int*)realloc(p, 80);
	if (ptr != NULL)
	{
		p = ptr;
		ptr = NULL;
	}
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
	return 0;
}

结果展示：

3.常见的动态内存错误

1.对NULL指针的解引用操作。

代码展示：

#define _CRT_SECURE_NO_WARNINGS 1
//1.对NULL指针的解引用操作。
#include<stdio.h>
#include<stdlib.h>
#include<limits.h>
int main()
{
	int* p = (int*)malloc(INT_MAX);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	else
	{
		*p = 5;
	}
	free(p);
	p = NULL;
	return 0;
}

结果如下所示:

?

2.对内存动态开辟空间的越界访问。

代码展示：

#define _CRT_SECURE_NO_WARNINGS 1
//2.对内存动态开辟空间的越界访问。
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(20);
	if (p == NULL)
	{
		return 1;
	}
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 20; i++)
	{
		printf("%d ", p[i]);//越界访问
	}
	free(p);
	p = NULL;
	return 0;
}

结果展示：

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

代码展示：

#define _CRT_SECURE_NO_WARNINGS 1
//3.对非动态开辟内存使用free释放。
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int num = 10;
	int* p = &num;
	//使用
	//释放
	free(p);//错误
	p = NULL;
	return 0;
}

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

代码展示：

#define _CRT_SECURE_NO_WARNINGS 1
//4.使用free释放一块动态内存开辟内存的一部分。
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p = i;
		p++;
	}
	//未将p指针恢复到初始位置
	free(p);
	p = NULL;
	return 0;
}

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

代码展示：

#define _CRT_SECURE_NO_WARNINGS 1
//5.对同一块动态内存多次释放。
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i;
	}
	//释放
	free(p);
	p = NULL;
	//再次释放
	free(p);
	p = NULL;
	return 0;
}

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

代码展示：

#define _CRT_SECURE_NO_WARNINGS 1
//6.动态开辟内存忘记释放。
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i;
	}
	//忘记释放空间了！！！
	return 0;
}

代码展示：

#define _CRT_SECURE_NO_WARNINGS 1
//6.动态开辟内存忘记释放（内存泄漏）。
#include<stdio.h>
#include<stdlib.h>
int* get_memory()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	return p;
}
int main()
{
	int* p = get_memory();
	//没有释放空间
	return 0;
}

4.c/c++程序内存的开辟

如下图所示：

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

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

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

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

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

5.柔性数组

5.1柔性数组的定义

在c99中，结构体中的最后一个元素允许是未知大小的数组，这就叫做柔性数组成员。

#define _CRT_SECURE_NO_WARNINGS 1
//柔性数组
struct S
{
	int i;
	int arr[];//柔性数组成员
};
//当有的编译器出现报错时可以写成下面的这种
struct S
{
	int i;
	int arr[0];
};

5.2柔性数组的特点

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

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

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

5.3柔性数组的使用

代码如下所示：

#define _CRT_SECURE_NO_WARNINGS 1
//柔性数组的使用
#include<stdio.h>
#include<stdlib.h>
struct S
{
	int n;
	float s;
	int arr[];//柔性数组
};
int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + sizeof(int*) * 4);
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	ps->n = 100;
	ps->s = 5.5f;
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		scanf("%d", &(ps->arr[i]));
	}
	//调整
	struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 10 * sizeof(int));
	if (ptr == NULL)
	{
		perror("realloc");
		return 1;
	}
	else
	{
		ps = ptr;
	}
	free(ps);
	ps = NULL;
	return 0;
}

5.4柔性数组的优势

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

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

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

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

结束语：

这次小编主要与大家分享了如何在C语言中动态开辟内存，其中malloc是不初始化的，calloc在最开始的时候就会初始化为0，而realloc是用来调整内存空间大小的，free是用来释放内存的，这些你都掌握了吗？希望对大家有所帮助，想要学习的同学记得关注小编和小编一起学习吧！如果文章中有任何错误也欢迎各位大佬及时为小编指点迷津（在此小编先谢过各位大佬啦！）?