动态内存管理

[1. 为什么存在动态内存管理](#1. 为什么存在动态内存管理)
[2. 动态内存函数的介绍](#2. 动态内存函数的介绍)
- [2.1 malloc函数和free函数](#2.1 malloc函数和free函数)
- [2.2 calloc函数](#2.2 calloc函数)
- [2.3 realloc函数](#2.3 realloc函数)
[3. 常见的动态内存错误](#3. 常见的动态内存错误)
- [3.1 对NULL指针的解引用操作](#3.1 对NULL指针的解引用操作)
- [3.2 对动态开辟空间的越界访问](#3.2 对动态开辟空间的越界访问)
- [3.3 对非动态开辟内存使用free函数](#3.3 对非动态开辟内存使用free函数)
- [3.4 使用free释放动态开辟内存的一部分](#3.4 使用free释放动态开辟内存的一部分)
- [3.5 对同一块动态内存多次释放](#3.5 对同一块动态内存多次释放)
- [3.6 动态开辟内存忘记释放(内存泄漏)](#3.6 动态开辟内存忘记释放(内存泄漏))
[4. 几道经典的笔试题](#4. 几道经典的笔试题)
- [4.1 题目一](#4.1 题目一)
- [4.2 题目二](#4.2 题目二)
- [4.3 题目三](#4.3 题目三)
- [4.4 题目四](#4.4 题目四)
[5. C/C++程序的内存开辟](#5. C/C++程序的内存开辟)
[6. 柔性数组](#6. 柔性数组)
- [6.1 为什么需要柔性数组](#6.1 为什么需要柔性数组)
- [6.2 柔性数组的定义](#6.2 柔性数组的定义)
- [6.3 柔性数组的使用](#6.3 柔性数组的使用)
- [6.4 柔性数组的特点](#6.4 柔性数组的特点)
- [6.5 柔性数组的优势](#6.5 柔性数组的优势)

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

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

int val = 20;//在栈空间上开辟四个字节

char arr[10] = {0};//在栈空间上开辟10个字节的连续空间

但上述开辟内存的方式有两个特点

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

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。这时候就只能试试动态存开辟了。

2. 动态内存函数的介绍

2.1 malloc函数和free函数

C语言提供了一个动态内存开辟的函数

void* malloc (size_t size)

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

如果开辟成功，则返回一个指向开辟好空间的指针
如果开辟失败，则会返回NULL(空指针)，因此malloc函数的返回值一定要做检查
返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用时使用者自己决定
如果size等于0，这种行为C标准没有定义，具体取决于编译器

C语言还提供了另一个函数free，专门是用来做动态内存的释放和回收的

void free (void* ptr)

如果ptr指向的空间不是动态开辟的，那么free的行为C语言并没有定义，而是取决于编译器
如果参数ptr是空指针(NULL)，则该函数什么都不做

头文件: stdlib.h

c 复制代码

#include <stdio.h>

int main()
{
 //代码1
 int num = 0;
 scanf("%d", &num);
 int arr[num] = {0};
 
 //代码2
 int* ptr = NULL;
 ptr = (int*)malloc(num*sizeof(int));
 if(NULL != ptr)//判断ptr指针是否为空
 {
 int i = 0;
 for(i=0; i<num; i++)
 {
 *(ptr+i) = 0；
 }
 }
 free(ptr);//释放ptr所指向的动态内存
 ptr = NULL;//是否有必要？
 return 0;
}

注意:

malloc一定要和free搭配使用，用完切记要释放内存
ptr=NULL是十分有必要的，避免ptr成为野指针
malloc函数只负责分配内存，并不会将内存中的值初始化为0，里面是一些随机值

2.2 calloc函数

C语言还提供了一个函数叫 calloc， calloc 函数也用来动态内存分配。原型如下：

void* calloc (size_t num, size_t size)

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

c 复制代码

#include <stdio.h>
#include <stdlib.h>
int main()
{
 int *p = (int*)calloc(10, sizeof(int));
 if(NULL != p)
 {
 //使用空间
  }
 free(p);
 p = NULL;
 return 0;
}

2.3 realloc函数

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

函数原型如下:

void* realloc (void* ptr, size_t size)

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

1.原来空间后面有足够大的空间

当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化
2.原来的空间后面没有足够大的空间

当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。

由于上述两种情况,在使用realloc函数时就要注意

c 复制代码

#include <stdio.h>
int main()
{
 int *ptr = (int*)malloc(100);
 if(ptr != NULL)
 {
     //业务处理
 }
 else
 {
     exit(EXIT_FAILURE);    
 }
 
 //扩展容量
 //代码1
 ptr = (int*)realloc(ptr, 1000);//这样可以吗？(如果申请失败会如何？)
 
 //代码2
 int*p = NULL;
 p = realloc(ptr, 1000);
 if(p != NULL)
 {
 ptr = p;
 }
 //业务处理
 free(ptr);
 return 0;
 }

注意: 不能用之前的指针直接指向realloc函数扩展的新空间，因为如果扩展失败，返回空指针，那么意味着之前的空间找不到了，就导致内存泄漏，正确的做法是新创建一个指针去接收，如果该指针不为空，再将地址赋给原来的指针

3. 常见的动态内存错误

3.1 对NULL指针的解引用操作

c 复制代码

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

解决这个问题的方法是，申请完的空间，在使用前一定要判断不为空，在使用

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

c 复制代码

void test()
{
 int i = 0;
 int *p = (int *)malloc(10*sizeof(int));
 if(NULL == p)
 {
 exit(EXIT_FAILURE);
 }
 for(i=0; i<=10; i++)
 {
 *(p+i) = i;//当i是10的时候越界访问
 }
 free(p);
}

解决这个问题的方法是，在访问时自己心里看清楚有没有越界，在执行程序

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

c 复制代码

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

这种做法也是错误的，free只能释放动态开辟的内存，解决方法是释放的时候看清楚

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

c 复制代码

void test()
{
 int *p = (int *)malloc(100);
 p++;
 free(p);//p不再指向动态内存的起始位置
}

free函数只能释放一整个动态开辟的内存，不能从中间某个位置开始释放

使用时要注意

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

c 复制代码

void test()
{
 int *p = (int *)malloc(100);
 free(p);
 free(p);//重复释放
}

free只能释放一次动态开辟的内存，不能多次释放，使用时要注意哦

3.6 动态开辟内存忘记释放(内存泄漏)

c 复制代码

void test()
{
 int *p = (int *)malloc(100);
 if(NULL != p)
 {
 *p = 20;
 }
}
int main()
{
 test();
 while(1);
 }

p指针是局部变量，当调用完test函数时，指针被销毁，但申请的空间还在，但没有之前的指针也就无法在访问这块地址，这就导致内存一直被占用，其他程序也无法使用，这就是内存泄漏问题

切记: 申请的空间在使用完毕后一定要正确的释放

4. 几道经典的笔试题

4.1 题目一

c 复制代码

void GetMemory(char *p)
{
 p = (char *)malloc(100);
}

void Test(void)
{
 char *str = NULL;
 GetMemory(str);
 strcpy(str, "hello world");
 printf(str);
}

上面的程序test()函数执行会发生什么情况

GetMemory(str);将str的值传递给char*类型的指针p，由于传的不是地址，所以指针p和指针str指向的是不同的地址，对于str来说地址里的值仍然是NULL，对一个NULL去复制，程序就会崩溃

4.2 题目二

c 复制代码

char *GetMemory(void)
{
 char p[] = "hello world";
 return p;
}

void Test(void)
{
 char *str = NULL;
 str = GetMemory();
 printf(str);
}

请问执行Test()函数会发生什么

str = GetMemory();这句话调用了GetMemory()函数，并用char*指针接收该函数的返回值，但char p[]数组是在该函数内部创建的，虽然可以将数组p的地址返回给str，但当str拿对应的地址去访问p之前的空间时，这片空间已经被操作系统回收了，所以就属于非法访问了，打印出来是一些乱码

4.3 题目三

c 复制代码

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()，导致内存泄漏

4.4 题目四

c 复制代码

void Test(void)
{
 char *str = (char *) malloc(100);
 strcpy(str, "hello");
 free(str);
 if(str != NULL)
 {
 strcpy(str, "world");
 printf(str);
 }
}

这道题问题在于，在free完之后没有及时将指针str即使置NULL，所以导致下面的if语句被执行，但str开辟的空间已经被释放掉，所以也属于非法访问了，但是由于我们进行的是字符串的拷贝,所以world还是会被拷贝到当前地址，并成功输出，但我们要知道这实际上是错误的

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

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

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

6. 柔性数组

6.1 为什么需要柔性数组

我们平时在VS上只能指定长度固定的数组，而不能灵活去改变数组的长度，而且在定义一个数组时，[ ]括号中必须是常量，那么我们如果事先不知道要创建大小为多少的数组时应该怎么办?此时就需要C语言提供的另一种方式，即柔性数组

6.2 柔性数组的定义

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

c 复制代码

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

//有些编译器不支持上述写法，可以按照下面来定义

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

6.3 柔性数组的使用

c 复制代码

#include <stdlib.h>
struct Stu {
	int num;
	int grade[];
};
int main()
{
	struct Stu* p = (struct Stu*)malloc(sizeof(struct Stu) + 20);
	if (p != NULL)
	{
		p->num = 100;
		for (int i = 0;i < 5;i++)
		{
			p->grade[i] = i+1;
			printf("%d\n", p->grade[i]);
		}
	}
	free(p);
	p = NULL;
}

在内存中num和grade在一个开辟的动态内存中

6.4 柔性数组的特点

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

6.5 柔性数组的优势

上述代码还可以设计为

c 复制代码

#include <stdlib.h>
struct Stu {
	int num;
	int* ptr;
};

int main()
{
	struct Stu* p = (struct Stu*)malloc(sizeof(struct Stu));
	if (p != NULL)
	{
		p->ptr = (int*)malloc(sizeof(int)*5);
		if (p->ptr != NULL)
		{
			for (int i = 0;i < 5;i++)
			{
				p->ptr[i] = i + 1;
				printf("%d\n", p->ptr[i]);
			}
		}
	}
	free(p->ptr);
	p->ptr = NULL;
	free(p);
	p = NULL;
}

两者的区别在于在内存中的分布不同

情况一:

这种情况结构体变量是在栈中创建的，柔性数组是在堆中创建的

情况二:

这种情况结构体和动态开辟的数组都是在堆上存储

第一种是通过柔性数组来实现，第二种是通过普通的指针来实现，我们来看看柔性数组的优势

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

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

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

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

动态内存管理(C语言)

动态内存管理

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

2. 动态内存函数的介绍

2.1 malloc函数和free函数

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 题目一

4.2 题目二

4.3 题目三

4.4 题目四

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

6. 柔性数组

6.1 为什么需要柔性数组

6.2 柔性数组的定义

6.3 柔性数组的使用

6.4 柔性数组的特点

6.5 柔性数组的优势