动态内存管理

╰+哭是因爲堅強的太久メ 2023-10-09 16:34 16阅读 0赞

**目录**

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

二 动态内存函数的介绍

2.1 malloc和free

2.2 calloc

2.3 realloc

三 常见的动态内存错误

3.1 对NULL指针的解引用

3.2 对动态开辟空间的越界访问

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

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

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

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

四 经典题目

五 C/C++程序的内存开辟

六 柔性数组

6.1 柔性数组的特点

6.2 柔性数组的优势

--------------------

励志环节

不要躺平去发光

--------------------

重点

（1）为什么存在动态内存分配 （2）动态内存函数的介绍 molloc free calloc realloc （3）常见的动态内存错误（4）题目（5）柔型数组

--------------------

## 一 为什么存在动态内存分配 ##

int a = 4; int arr\[40\] = \{ 0 \};

> 上面的内存开辟（1）空间开辟大小是固定的（2）数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

但是，对空间的需求，不仅仅是上述的情况，需要的空间大小在运行的时候才能知道，可能有的空间比较多，有的需要的空间不足，这个时候就需要动态内存分配了。

> 动态内存分配在堆区

## 二 动态内存函数的介绍 ##

在malloc、calloc、realloc创建的空间需要释放

### 2.1 malloc和free ###

这两个函数的头文件是<stdlib.h>

malloc

这是一个动态内存开辟的函数

> void\*  malloc  ( size\_t  size );

size\_t size 单位是字节，因为不知道开辟的空间是什么类型的，所以直接用字节数来表示

这个函数向内存申请一块 **连续可用** 的空间，并返回指向这块空间的指针。

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

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

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

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

free

这是一个动态内存的开辟和回收的函数

> void  free  ( void\*  ptr );

free 函数用来释放动态开辟的内存。

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

（2）如果参数  ptr  是 NULL 指针，则函数什么事都不做。

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h> //strerror函数头文件
    #include <errno.h>  //errno这个变量头文件
    
    int main()
    {
    	//开辟10个整形的空间int arr[10];
    	int* p = (int*)malloc(40);//malloc返回的是void*
    	//如果开辟失败，返回的是一个空指针，所以要先检查，后使用
    	if (p == NULL)
    	{
    		printf("%s\n", strerror(errno));//字符串
    		return 0;
    	}
    
    	//使用
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
    		*(p + 1) = i;
    		printf("%d ", *(p + 1));
    	}
    
    	//释放这份空间,还给操作系统
    	free(p);
    	//但是p还是保存的这个地址，就变成了野指针，
    	p = NULL;//就可以防止野指针这种操作
    	return 0;
    }

**提示：**野指针成因之一：指针指向的空间释放（在C语言初阶专栏的初阶指针知识点的文章中有详细写到野指针成因）[http://t.csdn.cn/nr6EZ][http_t.csdn.cn_nr6EZ]（文章链接）

### 2.2 calloc ###

头文件是<stdlib.h>

calloc  函数也用来动态内存分配

> void\*  calloc  ( size\_t  num ,  size\_t  size );

num元素个数 size每个元素的大小 例如： calloc（10，sizeof（int））

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

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

增容失败，返回空指针。

### 2.3 realloc ###

头文件是<stdlib.h>

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

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

> void\*  realloc  ( void\*  ptr ,  size\_t  size );

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

> （1）原有的空间后面的空间足够，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。
> 
> （2）原有的空间后面的空间不够，当是情况 2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。

#include <stdlib.h>
    #include <stdio.h>
    #include <string.h> //strerror函数头文件
    #include <errno.h>  //errno这个变量头文件
    
    int main()
    {
    	//开辟10个整形的空间int arr[10];
    	int* p = (int*)malloc(40);//malloc返回的是void*
    	//如果开辟失败，返回的是一个空指针，所以要先检查，后使用
    	if (p == NULL)
    	{
    		printf("%s\n", strerror(errno));//字符串
    		return 0;
    	}
    	//使用
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
    		*(p + 1) = i;
    		printf("%d ", *(p + 1));
    	}
    	//增容
    	int* ptr = (int*)realloc(p, 80);
    	if (ptr != NULL)
    	{
    		p = ptr;
    		ptr = NULL;//因为这个地址，后面会被释放
    	}
    
    
    	//释放这份空间,还给操作系统
    	free(p);
    	//但是p还是保存的这个地址，就变成了野指针，
    	//野指针成因之一：指针指向的空间释放（在C语言初阶专栏的初阶指针知识点的文章中有详细写到野指针成因）
    	p = NULL;
    	return 0;
    }

这个函数也会出现增容失败的时候。（返回空指针，意思空间被释放，会导致原来的空间也被释放）（所以不能把返回的指针直接放在原来的指针变量里，应该再定义一个指针变量存放返回地址，先判断是否是空指针（增容失败），不是空指针，再赋值给p）

> realloc（NULL，40），就和malloc一样了

## 三 常见的动态内存错误 ##

### 3.1 对NULL指针的解引用 ###

void test()
    {
     int *p = (int *)malloc(INT_MAX/4);
     *p = 20;//如果p的值是NULL，就会有问题
     free(p);
    }

应该先判断是否为空指针

### 3.2 对动态开辟空间的越界访问 ###

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <errno.h>
    
    
    int main()
    {
    	int i = 0;
    	int* p = (int*)malloc(10 * sizeof(int));
    	if (NULL == p)
    	{
    		printf("%s\n", strerror(errno));
    	}
    	for (i = 0; i <= 10; i++)
    	{
    		*(p + i) = i;//当i是10的时候越界访问
    	}
    	free(p);
    	p = NULL;
    	return 0;
    }

不可以越界访问

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

#include <stdio.h>
    #include <string.h>
    
    int main()
    {
    	int a = 10;
    	int* p = &a;
    	free(p);//非动态开辟，不可以释放
    	return 0;
    }

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

#include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <errno.h>
    
    int main()
    {
    	int* p = (int*)malloc(100);
    	if (p == NULL)
    	{
    		printf("%s\n", strerror(errno));
    		return 0;
    	}
     
    	p++;
    	free(p);//p不再指向动态内存的起始位置,不能释放
    	return 0;
    }

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

#include <stdio.h>
    #include <string.h>
    int main()
    {
    	int* p = (int*)malloc(100);
    	free(p);
    	free(p);//重复释放
    	return 0;
    }

不可以重复释放（当把p赋值为空指针后再释放是可以的）

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

#include <stdio.h>
    #include <stdlib.h>
    
    
    void test()
    {
    	int* p = (int*)malloc(100);
    	if (NULL != p)
    	{
    		*p = 20;
    	}
    	//记得要释放
    }
    int main()
    {
    	test();
    	//在这里释放不可以
    	return 0;
    }
    
    //或者把函数返回值改为int*,在主函数接收一下，这样就可以在主函数释放
    //总而言之,要释放，这块内存要释放

> **忘记释放不再使用的动态开辟的空间会造成内存泄漏。**
> 
> 记得释放，也要正确释放。

## 四 经典题目 ##

（1）

#include <stdio.h>
    #include <stdlib.h>
    
    void GetMemory(char* p)
    {
    	p = (char*)malloc(100);
    	//没有释放
    	//并没有返回任何值，也没有改变str的值
    
    }
    
    void Test(void)
    {
    	char* str = NULL;
    	GetMemory(str);
    	strcpy(str, "hello world");
    	//常量字符串传递的是h的地址，所以是正确的
    	//str是空指针，在这里非法访问，程序会崩溃
    	printf(str);//这个写法是可以的，但是程序崩溃无法运行到这里
    }
    
    int main()
    
    {
    	Test();
    	return 0;
    }

运行结果：程序崩溃

（2）

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

（3）

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

（4）

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

## 五 C/C++程序的内存开辟 ##

![8f971d86dde649fc9fc13b900336d684.png][]

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

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

## 六 柔性数组 ##

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

写法一：

struct S1
    {
    	int n;
    	int arr[0];//大小是未指定的，并不是0
    };

写法二

struct S2
    {
    	int n;
    	int arr[];
    };

### 6.1 柔性数组的特点 ###

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

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

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

代码一：

#include <stdio.h>
    #include <stdlib.h>
    
    struct S2
    {
    	int n;
    	int arr[];
    };
    
    int main()
    {
    	struct S2* ps = (struct S2*)malloc(sizeof(struct S2) + 40);
    	ps->n = 100;
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
    		ps->arr[i] = i;
    	}
    	//增容
    	struct S2* ptr = (struct S2*)realloc(ps, sizeof(struct S2) + 80);
    	if (ptr == NULL)
    	{
    		return 0;
    	}
    	else
    	{
    		ps = ptr;
    	}
    
    	free(ps);
    	ps = NULL;
    
    	return 0;
    }

### 6.2 柔性数组的优势 ###

代码二：

#include <stdio.h>
    #include <stdlib.h>
    
    struct S2
    {
    	int n;
    	int* arr;
    };
    
    int main()
    {
    	struct S2* ps = (struct S2*)malloc(sizeof(struct S2));
    	ps->n = 100;
    	ps->arr = (int*)molloc(40);
    	//增容
    	free(ps->arr);
    	ps->arr = NULL;
    	free(ps);
    	ps = NULL;
    
    	free(ps);
    	ps = NULL;
    
    	return 0;
    }

代码一相对于来说比较好：（1）方便内存释放 如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给 用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你 不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好 了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。 （2）这样有利于访问速度. 连续的内存有益于提高访问速度，也有益于减少内存碎片。

（代码二：开辟和释放的次数多，容易出错；容易形成内存碎片）

[http_t.csdn.cn_nr6EZ]: http://t.csdn.cn/nr6EZ
[8f971d86dde649fc9fc13b900336d684.png]: https://img-blog.csdnimg.cn/8f971d86dde649fc9fc13b900336d684.png