数据结构基础】

前言

动态内存管理是今后学习数据结构的基础，它弥补了之前学习一般数组的缺点，即不能按需使用内存：数组在初始化时的大小就已经被确定了。这种规定虽然提高了安全性，但对合理高效地使用内存不利，这篇文章将详细讲解几种动态内存管理函数、讲解经典笔试题以加深理解、介绍C/C++内存开辟的特点以及柔性数组的使用

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

我们已经掌握的内存开辟方式有：

//1. 创建一个变量
int a = 20;//在栈空间上开辟四个字节
//2. 创建一个数组
char arr[10] = { 0 };//在栈空间上开辟10个字节的连续空间

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

空间开辟大小是固定的。
数组在初始化时，必须指定数组的长度，它所需要的内存在编译时分配。但事实上，实际应用场景中程序需要的内存空间往往是变化的，若因为上述条件的约束，而在数组初始化时将长度设定很长，这样就浪费了很多空间。所以动态内存分配出现了。例如

 
    int num = 0;
    scanf("%d", &num);
    //这种写法是不被允许的

注意：

动态内存分配是在堆区上处理的

在这里插入图片描述

栈区：不需要我们维护，一个变量只要进入它的作用域，栈区会自动为它开辟空间，当变量超出了它的作用域后，栈区也会自动回收该空间

堆区：需要我们人为地开辟空间，也一定要人为地归还空间

2. 动态内存函数

2.1 malloc和free

malloc要和free配对使用

malloc和free都声明在stdlib.h 头文件中。

2.1.1 malloc

void* malloc (size_t size);//字节

在这里插入图片描述

要点

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

2.1.2 free

void free (void* ptr);

在这里插入图片描述

要点

free函数用来释放动态开辟的内存。
如果参数ptr 指向的空间不是动态开辟的，那free的行为是未知的。也就是说，先用malloc开辟内存才能用free释放。（但如果free的是空指针，即使没有先malloc也是符合语法的，因为不会发生任何事，就好像对0加减乘除一样）
如果参数ptr 是NULL指针，则函数什么事都不做。

2.1.3 用例

#include <stdio.h>
int main()
{
	
	
	int* ptr = NULL;//初始化指针
	ptr = (int*)malloc(1000);

	if (NULL != ptr)//判断ptr指针是否为空
	{
		int i = 0;
		for (i = 0; i < num; i++)
		{
			*(ptr + i) = 0;
		}
	}

	free(ptr);//释放ptr所指向的动态内存
	ptr = NULL;//free掉以后一定要将指针置空

	return 0;
}

要点

内存泄漏：在程序结束前，如果只向内存申请在堆区开辟空间，使用完毕后却不free，没有将内存空间还给堆区，操作系统会认为用户还在使用，这块内存就相当于浪费了，造成内存泄漏。

为什么是程序结束前？因为程序结束后会自动将内存还给操作系统。

开辟内存的不同写法

ptr = (int*)malloc(1000);
ptr = (int*)malloc(100 * sizeof(int));

非法访问内存：仅仅将内存free还不够，因为内存中的内容（如果其他程序没有使用的话），指针存放的地址都没有被改变，free掉使用过的内存仅是向系统传达一个“申请的内存空间已经使用完毕”这个信息。如果后续再使用这个指针p，那么它还是指向那块内存空间的，但这个内存空间已经还给操作系统了，若再访问，则造成非法访问内存。

在这里插入图片描述

要完全切断ptr和free之前的内存空间的联系，就要将ptr置为空指针。所以这两句是一定要在一起。

	free(ptr);//释放ptr所指向的动态内存
	ptr = NULL;//free掉以后一定要将指针置空

2.2 calloc

void* calloc (size_t num, size_t size);

在这里插入图片描述

要点

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

举个例子：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (NULL != p)
	{
		for (int i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));//打印
		}
	}
	free(p);
	p = NULL;
	return 0;
}

在这里插入图片描述

2.3 realloc

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

在这里插入图片描述

要点

ptr 是要调整的内存地址
size 调整之后新大小
返回值为调整之后的内存起始位置。如果失败，返回空指针。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
realloc在调整内存空间的方式有两种：

情况1：原有空间之后有足够大的空间

当空间足够大，直接再原有内存之后追加空间，直至达到size大小，原来空间的数据不发生变化。返回原有内存的地址

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

当没有足够空间，在堆区找到一个足够大的连续空间，将原有的数据copy，然后再在它后面拓展空间。这样函数返回的是一个新的内存地址。

在这里插入图片描述

由于上述的两种情况，realloc函数的使用就要注意一些。

对于以上代码，是两个指针（p和ptr）变量维护一个内存空间，语法上是可以只用一个维护的，但是这样做是很危险的：如果realloc操作失败，返回空指针，这时原本维护内存的指针就变成了空指针，而且没有free，相当于造成了内存泄漏。
所以要用一个指针变量专门维护内存空间，还要用一个指针变量接收realloc的返回值。若非要用一个指针变量维护，则需要判断指针是否否为空。
上面的程序有个问题，你能找出来吗？

3. 常见错误

3.1 对NULL指针解引用

void test()
{
  int num = 0;
	scanf("%d", &n);
	int* p = (int*)malloc(num);
	*p = 20;//如果p的值是NULL，就会有问题
	free(p);
}

如果malloc操作失败返回NULL，p的值就为NULL，后续操作都是无效的。

改进

void test()
{
  int num = 0;
	scanf("%d", &n);
	int* p = (int*)malloc(num);
	if(p != NULL)//判断指针是否为空
	*p = 20;
	free(p);
}

3.2 越界访问动态开辟空间

void test()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));
	//这里只开辟了10个int大小的空间
	if (NULL == p)
	{
		return 0;
	}
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i;//循环11次，当i是10的时候越界访问
	}
	free(p);
}

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

void test()
{
	int a = 10;
	int* p = &a;
	free(p);//ok?
}

free必须在开辟内存之后使用

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

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
		return 0;
	for (int i = 0; i < 10; i++)
	{
		*p = 1;
		p++;//改变了起始地址
	}
	free(p);
	p = NULL;
	return 0;
}

free传入的地址一定要是原来开辟空间的起始地址

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

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
		return 0;
	free(p);//c第一次
	p = NULL;
	//一堆代码...
	free(p);//第二次
	p = NULL;
	return 0;
}

一个函数内不能多次对同一个内存空间free。这里体现指针置空的好处，第一次将它置零，后面就相当于对k进行无效操作。

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

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(100);
	if (NULL != p)
	{
		*p = 20;
	}
	return 0;
}

动态开辟的空间一定要正确地free。

4. 笔试题

4.1 题目1

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

解读

主函数调用Test函数，然后再调用GetMemory函数。

在Test函数中将存放着NULL地实参str传给Getmemory，而形参是实参的一份临时拷贝，所以Getmemory定义的指针变量p指向的是另外的一个存放着NULL的内存，在函数内部对NULL进行内存开辟是无效的。

GetMemory调用完毕，那块内存已经被销毁，而str指向的内存还是之前存放NULL的内存。strcpy想将一个常量字符串放入NULL中，这是无效操作。

所以程序什么都不会发生，编译器会报内存崩溃错误。

其次这个代码本身是有问题的：开辟内存后没有free。

改进

不难知道，这个程序的目的是将ptr指向的空间拓展，然后存放一个常量字符串。而问题出现在函数传参的过程中，函数没有起到修改原内存内容的作用。有两种改进方法

先将一个指针变量的地址传给函数，让它开辟内存空间

在调用GetMemory时，应该传入&str，形参也应该以char**的形式定义，开辟内存维护的指针也应该是*p。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void GetMemory(char** p)
{
	*p = (char*)malloc(100);
}

void Test(void)
{
	char* str = NULL;
	GetMemory(&str);
	strcpy(str, "hello world");
	printf(str);
	free(ptr);//free掉
	ptr = NULL;
}

int main()
{
	Test();
	return 0;
}

GetMemory的作用是用一个指针变量维护开辟的内存空间，然后返回这个指针，赋值给Test中的str

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char* GetMemory(char* p)//改变了返回值类型
{
	p = (char*)malloc(100);
	return p;
}

void Test(void)
{
	char* str = NULL;
	str = GetMemory(str);//将返回值赋值给str
	strcpy(str, "hello world");
	printf(str);
	free(ptr);
	ptr = NULL;
}

int main()
{
	Test();
	return 0;
}

请思考：一般变量在函数调用完毕后会被销毁，那这块开辟的内存空间也会被销毁吗？

4.2 题目2

#include<stdio.h>
#include<stdlib.h>
#include<string.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数组是一个局部数组，GetMemory被调用完毕以后，返回的是一个野指针，打印出来的是随机值

4.3 题目3

#include<stdio.h>
#include<stdlib.>
#include<string.h>
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指向Getmemory开辟的内存空间并放入一个常量字符串，打印成功

错误在于未释放开辟的空间

4.4 题目4

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
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;
}

解读

这是一个十分奇怪的错误：copy完常量字符串到开辟的内存空间以后就free掉了，紧接着又使用这块空间，造成非法访问内存

free的作用仅是向操作系统传达“已经使用完毕”这一信息，其内存空间的内容暂时不会改变（如果其他程序没有用到这块内存的话），紧接着判断指针是否为空，然后world覆盖了hello，打印结果为world

free的同时也要将指针变量置空，因为free没有这个功能

改进

显然，在开辟完空间以后就应该判断str是否为空，而不是在free掉以后再判断。不可直接将free放到程序末尾。本题考点是free的同时将指针变量置空

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
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;
}

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

以一段代码为例

在这里插入图片描述

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

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

以上图理解static修饰局部变量

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

6. 柔性数组

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

例如

typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;

有些编译器会报错无法编译可以改成：

typedef struct st_type
{
int i;
int a[];//柔性数组成员
}type_a;

6.1 柔性数组的特点

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

typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;
int main()
{
	printf("%d\n", sizeof(type_a));//输出的是4
	return 0;
}

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

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

6.2 柔性数组的使用

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct s
{
	int i;
	int a[0];//柔性数组成员
};
int main()
{
	int i = 0;
	struct s* p = (struct s*)malloc(sizeof(struct s) + 100 * sizeof(int));
	//使用指针变量维护和使用malloc开辟内存要强转
	p->i = 100;//修改成员i的值
	for (i = 0; i < 100; i++)
	{
		p->a[i] = i;//修改成员a的值
	}
	free(p);
	p = NULL;
	return 0;
}

6.3 柔性数组的优势

以上代码和下面等价，但有所不同。以下面的代码为例与之作比较。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct st_type
{
	int i;
	int* p_a;//后面把这个指针变量当数组使用
}type_a;
int main()
{
	type_a* p = (type_a*)malloc(sizeof(type_a));
	//为结构体开辟内存
	p->i = 100;//修改成员i
	p->p_a = (int*)malloc(p->i * sizeof(int));
	//为数组成员开辟内存
	for (int i = 0; i < 100; i++)
	{
		p->p_a[i] = i;//修改数组成员
	}
	//释放空间
	free(p->p_a);
	p->p_a = NULL;
	free(p);
	p = NULL;
	return 0;
}

这里将一个数组作为结构成员，并单独为它开辟内存空间，每次通过结构访问成员使用它，这和柔性数组的特性是十分类似的。

不同或者说是前者的优点

方便内存释放

注意这个程序开辟了两次空间，一次为结构体，一次为数组，所以需要free两次。但假设这两次内存的开辟都是在一个函数中，当别人使用这个函数不知道要free两次，只free了一次，这会造成问题。所以前者的写法是符合习惯的。开辟一次内存，free一次。

提高内存访问速度

能提高，但只能提高一点点。访问一块连续的内存，比访问若干分散的内存速度要快。但以当今的性能，这点速度是很难感知的。所以主要的优点是前者。

结语

动态内存管理是数据结构的基础，一个比较长的链表需要不断地开辟和释放内存，但这么做的意义不仅在于更灵活地使用数组，弥补一般数组不能按需增加长度的缺点，更在于这么做能提高内存的使用效率，这是单纯一个数组无法做到的。
欢迎指正！
如果你有收获的话，不妨给作者一个鼓励吧~

posted @ 2022-12-06 22:31 shawyxy 阅读(122) 评论(0) 编辑收藏举报

刷新页面返回顶部

详解动态内存管理【malloc/calloc/realloc/free函数/柔性数组】【C语言/进阶/数据结构基础】

文章目录

前言

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

2. 动态内存函数

2.1 malloc和free

2.1.1 malloc

2.1.2 free

2.1.3 用例

2.2 calloc

2.3 realloc

3. 常见错误

3.1 对NULL指针解引用

3.2 越界访问动态开辟空间

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

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

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

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

4. 笔试题

4.1 题目1

4.2 题目2

4.3 题目3

4.4 题目4

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

6. 柔性数组

6.1 柔性数组的特点

6.2 柔性数组的使用

6.3 柔性数组的优势

结语

公告