dynamic_memory_allocation(动态内存分配)

Posted 2021-09-26 DarkAndGrey

Dynamic Memory Allocation（动态内存分配）

 

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

2.动态内存函数的介绍

malloc

free

calloc

realloc

 

3.常见的动态内存错误

4.几个经典的笔试题

5.柔型数组

 
 
 

在开始之前，我们需要回顾一下 我们当前所掌握的 内存使用方法

当前我们知道的内存使用方法

1. 创建一个 变量

int a =10;// （假设）局部变量 - 栈区

int g_a =10; // （假设）全局变量 - 静态区

 
 

2. 创建 一个数组

局部变量 - 栈区

全局变量 - 静态区

 
程序一：

#include<stdio.h>

struct s // 班级成员信息
{
	char name[20];
	int age;
};

int main()
{
	struct s arr[50];// 50 个 struct s 类型的数据
	// 但是如果班级没50人，那么就意味着要浪费空间
	// 反之班级人数超过50个，空间就不够用

	// 如果 在前面加上 int n =0; scanf("%d",&n); n 取代 50 的位数行不行呢？
	// 答案不行 因为 n 是一个变量， 而数组的元素个数应该给一个常量


	return 0;
}

特点：

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

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

 

C语言是可以创建变长数组 - c99 中增加了（vs不支持，gcc支持 c99标准 -> gcc test.c - std = c99）

 
 

下面正式进入正文:

为什么存在动态内存分配？

对于空间的需求，不仅仅是上述的情况，有时候我们需要的空间大小在程序运行的时候才知道

那数组的编译时开辟空间的方式就不能满足了，这时候就只能试试动态开辟了（在堆上申请空间）

 
 
 
 

动态内存函数的介绍

malloc 和 free

malloc ：void* malloc(size_t size); // size 开辟的空间大小，单位字节； void* 是一个指针， 指向的是开辟的空间的起始地址

free：void free(void* memblock); // memblock - 内存块

 
程序二：

#include<stdio.h>
#include<stdlib.h>// malloc 所在头文件
#include<errno.h>// errno，h 错误码库
int main()       // 与 函数 strerror（错误信息报告）  搭配使用,将错误码转化为错误信息，并返回它的地址
{
	// 我想向内存申请 10个 整形的 空间
	int* p = (int*)malloc(/*INT_MAX*/10 * (sizeof(int)));// 因为  malloc 函数 返回的是 万能*（无类型）指针，所以需要转化类型
	// malloc 函数 也有 开辟空间失败的时候，
	// 比如 内存 只有 4 个 g ，我要开辟 8 g 空间，这肯定是会失败的，返回 空指针 NULL
	
	if (p == NULL)
	{
		// 找出打印错误原因的方式
		printf("%s\\n", strerror(errno));// malloc(INT_MAX)
		                //输出 Not enough space
	}
	else
	{
		// 正常使用 空间
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p + i) = i;// 赋值 0 1 2 3 4 5 6 7 8 9
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));// 输出 0 1 2 3 4 5 6 7 8 9
		}
		printf("\\n");
	}
	// 当动态申请的空间 不再使用的时候
	// 就会把空间 还给 操作系统
	// 这时候 就会用到 free 函数
	return 0;
}

 
 

说到 free 函数， free 函数 是专门用来做 动态内存 的 释放 和 回收 的

 
程序三:

#include<stdio.h>
#include<stdlib.h>// malloc,free 所在头文件
#include<errno.h>
int main()
{
	// 我想向内存申请 10个 整形的 空间
	int* p = (int*)malloc(10 * (sizeof(int)));
	if (p == NULL)
	{
		// 找出打印错误原因的方式
		printf("%s\\n", strerror(errno));// malloc(INT_MAX)
		                //输出 Not enough space
	}
	else
	{
		// 正常使用 空间
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p + i) = i;// 0 1 2 3 4 5 6 7 8 9
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));// 0 1 2 3 4 5 6 7 8 9
		}
		printf("\\n");
	}
	// 当动态申请的空间 不再使用的时候
	// 就会把空间 还给 操作系统
	// 这时候 就会用到 free 函数
	free(p);// 用完了再释放，也就是说 在打印完之后（调用完之后），再释放（p的值没有改变，还可以通过它找到该空间）
	//  虽然当前空间 不属于当前程序，但是依然 可以通过 p  找到  该空间，很有可能会破坏这个空间
	//  所以先在这个 指针 依然很危险

	p = NULL; // free函数 释放完空间后，不会改 p 的值，所以我们自己主动改
	return 0;
}
// 最后请注意:free 是用来 释放 动态开辟的内存

// free 函数 的 特殊情况：
//1. 如果参数 ptr 指向的空间不是动态开辟的，那 free 函数的行为是未定义的
//2. 如果参数 ptr 是 NULL 指针，则函数 什么 都不做。

为了方便你们进一步了解 free 函数

举个 special 例子：

你呢，跟你 girlfriend 前期 相处非常好，你把女友电话记得牢牢的，有助于交流。

但是，有一天 你女朋友看不上你了，就 free§ [ 跟你分手了 ]

但是你（p）还死皮赖脸的记住你前女友的号码（动态开辟空间的地址），随时可能打电话骚扰她，并且找到她，影响她的生活，说明你很危险（访问该空间内容，并修改，该指针很危险）

这时候，你前女友为了你能断开念想 (其实保护自己 == 维护程序安全)

你前女友 给你当头一棒（爆头），让你失忆了。（p = NULL）

我只能说 杀人诛心！！！(还好我单身，暂时不用担心被爆头的危险。)

 
 
 
 

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

num 元素个数，size每个元素的长度【大小】（字节）

 

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

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

 
程序四：

 用法跟 malloc 函数差不多
#include<stdio.h>
#include<errno.h>
#include<string.h>
int main()
{                     // 开一块空间，空间大小为 10 * int == 40 字节
	int* p = (int*)calloc(10, sizeof(int));// 比 malloc 函数 多一个元素个数 参数
	if (p == NULL)    
	{
		printf("%s\\n", strerror(errno));
	}
	else
	{
		int i = 0;
		for (i = 0; i < 10; i++)// 因为 p 为整形指针变量，指向一个 int 类型 元素，所以有 10个 int 元素
		{
			printf("%d ", *(p + i));// 0 0 0 0 0 0 0 0 0 0
		}  //calloc 在开辟好空间后，会把空间的所有字节内容全部初始化为 零
	}
	free(p);
	p = NULL;// 狗头拿来！！
	return 0;
}

 
 

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

memblock - 内存块 (指针 指向 之前已经开辟了的内存块)

size : 新的大小

 

1. realloc 函数 的 出现 让动态内存管理更加灵活

2. 有时我们会发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了， 为了合理的使用内存，我们一定会对 内存的大小 做灵活的调整， realloc 函数就可以做到 对 动态开辟内存 大小的调整。

3. memblock 是要调整的内存块的地址

4.size 调整之后 新空间的大小

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

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

7.realloc 在 调整内存空间 时，存在两种情况：

 
程序五：

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
int main()
{
	int* p = (int*)malloc(20);// 开辟 20 byte 动态空间
	if (p == NULL) // 防止malloc 开辟动态空间失败
	{
		printf("%s\\n", strerror(errno));// 打印错误信息
	}
	else
	{  // 正常使用空间
		int i = 0;// 20 字节 ==  5* (sizeof(int))
		for (i = 0; i < 5; i++)
		{
			*(p + i) = i;// 此时 就是在使用 malloc 函数开辟的空间（20byte）
		}               
	}
	// 假设 malloc 函数 开辟的 20 byte 的空间，不满足我们的需求（不够）
	// 我们希望能够有 40 个 byte 的空间
	//这里 就可以使用 realloc 函数 来调整动态开辟的内存
	int* p2 = (int*)realloc(p, 40);//  10 * int == 40 byte
	/* p */
    
    //  记住 只要开辟动态空间的时候，最好判断一下，无论是 malloc ，calloc还是realloc 函数 都有可能开辟空间失败
    //  在下面的解决方案中，已得到解决 
    
	// 你会发现 原本 整个空间是 由 p 来维护的
	// 但是 现在你会发现 变成了 p2 来维护 了

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p2/* p */ + i));// 0 1 2 3 4 随机值1 随机值2  随机值3  随机值4  随机值5
	}                                // 随机值 是因为 malloc 不会像 calloc 函数 一样开辟完动态空间之后，初始化为 0
	printf("\\n");
	for (i = 5; i < 10; i++) // 使用 增大后的空间
	{
		*(p2/* p */ + i) = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p2/* p */ + i));// 0 1 2 3 4 5 6 7 8 9
	}                 // 如果保持统一 ，p2 换成 p，会出现问题（p已将找不到了）
	             // 因为 realloc 函数，是重新创建一个（40 byte）空间
	             // 把  p 的内容拷贝下来，把拷贝下来的数据 放进 这新创建的空间里
	             // 然后把 p 释放（p = NULL）
	             // 最后 返回新空间的地址
	             // 输出这个新创建的空间 的结果 让你 感觉 空间确实变大了
	             // 实际上 已经 不是 原先的空间 了
	return 0;
}

 

解决方案：

程序六：

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
int main()
{
	int* p = (int*)malloc(20);
	if (p == NULL)
	{
		printf("%s\\n", strerror(errno));
	}
	else
	{
		int i = 0;// 20 字节 ==  5* (sizeof(int))
		for (i = 0; i < 5; i++)
		{
			*(p + i) = i;// 此时 就是在使用 malloc 函数开辟的空间（20byte）
		}
	}

	int* ptr = (int*)realloc(p, 40);//  拿一个新的指针变量 ptr 先来接收 realloc 的返回地址
	if (ptr != NULL) // 判断 realloc 开辟动态空间是否 成功
	{
		p = ptr;// 防止开辟失败，把 p 改掉了

		int i = 0;
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));// 0 1 2 3 4 随机值1 随机值2  随机值3  随机值4  随机值5
		}
		printf("\\n");
		for (i = 5; i < 10; i++)
		{
			*(p + i) = i;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));// 0 1 2 3 4 5 6 7 8 9
		}
	}
	// 释放内存
	free(p);// 如果 realloc 开辟动态空间失败，返回 NULL，而 free(NULL),free 函数什么都不会做
	p = NULL;
	// 一定 要释放内存，并置为空指针，永绝后患！
	return 0;
}

realloc 如果 p 指向的空间之后 有 足够的内存空间可以追加，则追加上，返回原先的旧地址（p）

如果 p 指向的空间之后 没有 足够的内存空间可以追加，则重新找一个新的内存区域，开辟一块新的空间， 来满足你对空间需求，同时把 原来内存 的 数据 拷贝下来，把拷贝下来的数据放到新空间里，且把原来的空间释放，最后返回新空间的地址

 
 

另外再补充一点

realloc 函数 可以实现与 malloc 函数 一样的功能

程序七：

#include<stdio.h>
int main()
{
	int* p = (int*)realloc(NULL, 40);// 此时它的功能 与 malloc 函数一样
	                     //  == (int*)malloc(40);
}

 
 
 
 

常见的动态内存错误

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

程序八：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	//  万一 malloc 失败，p 被赋值为 NULL
	for (int i = 0; i < 10; i++)
	{
		*(p + i) = i;// 非法地址,对 NULL 指针 进行解引用
	}
	free(p);
	p = NULL;
	return 0;
	//解决方案 ：在使用开辟的动态空间之前，用 assert(p),记得加上头文件 assert.h; 或 加上 if（p != NULL） 判断语句，对 p 进行相关的判断
}

 
 
 

2，对动态开辟的内存 的 越界访问

程序九：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(20);// 开辟了 5个 int 元素的空间
	if (p == NULL)// 判断 malloc 函数 开辟动态空间 是否成功
	{
		return  0; //  失败
	}
	else//  成功
	{  
		int i = 0;    
		for (i = 0; i < 10; i++) // 我只有 5个 int元素，而现在 要访问 第 6~10 个 int 元素，形成了越界访问,导致程序崩溃
		{                      // 改成 5 就没问题了
			*(p + i) = i;           
		}
	}
	free(p);
	p = NULL;
}

 
 
 

3， 对 非动态 开辟内存使用 free（释放）函数

程序十：

#include<stdio.h>
int main()
{
	int a = 10;// 在 栈上 开辟空间
	int* p = &a;
	*p = 20;


	free(p); // free 对 非动态 开辟内存 使用，会造成程序崩溃
	p = NULL;
	return 0;
}

 
 
 

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

程序十一：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 0;
	}
	else
	{
		int  i = 0;
		for (i = 0; i < 10; i++)
		{
			*p++ = i;// 解决方法  *(p+i)= i; 这样避免了 p 的地址被改变
		}
		// 回收空间
		free(p);// 如果这样直接这样释放空间，会导致程序崩溃
		// 因为 p 已经不再指向该 动态开辟空间 的 起始位置，它释放第 10 个元素之后的空间（释放一部分动态开辟的空间）
		// free 只能释放 动态开辟空间 的起始地址（要释放就全释放）
	}
	p = NULL;
	return 0;
}

 
 
 

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

free 释放 一块动态开辟空间后，那个 空间 的地址并没有改变，此时再 free 就可能出现问题

程序十二：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p = NULL)
	{
		return 0;
	}
    // 使用
	// 释放
	free(p);
	free(p);// free 释放 一块动态开辟空间后，那个 空间 的地址并没有改变，此时再 free 就可能出现问题
	return 0;
}	//  谁申请 谁回收
	//  在 free(); 后面 手动 把 p = NULL; 后面就算再接上一个 free，也不会有问题
	// 因为 根据C语言标准：free(NULL)； free 什么都不做

 
 
 

6. 对动态开辟内存 忘记释放（内存泄露）

这种错误的出现，会导致计算机内存被耗干，导致卡死，毕竟计算机内存有限

程序十三：

#include<stdio.h>
#include<windows.h>
int main()
{
	
	while (1)
	{
		malloc(1);
		// 通过 三点（Ctrl、Alt 点 .）一线(同时按)，选择任务管理器 -》 性能 
	    // 通过观察 内存 占用 显示发现，内存正在被大量消耗，
		// 原因是 程序一直在申请空间，不回收，导致大量内存空间被占用（这些你不用，别人也用不了，因为你没还），这就是 内存泄露
	}

}

 
 
 

接下来我们来看几道面试题，来加深我对 动态内存分配 函数的 理解

 

题目 1

程序十四：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>


void GetMemory(char* p)// p 是 str 的一份临时拷贝，即 p= NULL;
{
	// malloc  在堆上开辟了一块空间，把该动态开辟空间的起始地址赋给 p
	p = (char*)malloc(100);// 此时 p 指向 malloc 开辟的动态空间

	// 动态开辟空间，调用完了，没有释放空间，会造成 内存泄露
    // 而且 这函数调用完后之后，这块函数空间会被回收
	// 到时我们再也找不到 这动态开辟的空间的起始地址
	// 也就是说 出了这个函数  想解决 内存泄露 这个问题，都解决不了（p 是该函数的形参，只在该函数内部有效）

 再举个例子，
  假设有一个卧底（malloc开辟的动态空间），他的信息（空间的地址）在警察系统中都删掉了，只有 p 知道，
 后来，有一天 p 死掉了（出了函数，销毁了 局部变量 p）.他也没有记本本告诉别人（没有返回这块空间的地址），
 那么这个卧底再也证明不了自己的身
以上是关于dynamic_memory_allocation(动态内存分配)的主要内容，如果未能解决你的问题，请参考以下文章