C语言------动态内存管理

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

已掌握的内存开辟空间：
int val=20；//在栈空间开辟4个字节
char arr[10]={10};//在栈空间上开辟10个字节的连续空间
但是上述开辟空间的方式有两个特点：
1.空间开辟大小是固定的；
2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。
但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。这时候就只能试试动态存开辟了。

2.动态内存函数介绍

2.1mallc和free

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

void*malloc(size_t size)
#void*函数返回值，申请成功返回指向开辟的空间的指针，申请失败则返回NULL;
#size_t size参数是定开辟多少个字节的空间

函数向内存申请一块连续可用的空间，并返回指向这块空间内存
1.如果开辟成功，则返回一个指向开辟好空间的指针
2.如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查
3.返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定；
4.如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器；
C语言提供了另一个函数free，专门是用来做动态内存的释放和回收的，函数原型如下：

void free(void*ptr);
free函数用来释放动态开辟内存的
void free (void* ptr);
# void* ptr 你要释放的空间的起始地址;

函数使用
在上面 malloc 函数的使用中我们已经演示了，将 p 的地址传递给 free 函数即可。
注意事项

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

1.如果参数ptr指向的空间不是动态开辟的，那free函数是未定义的。
2.如果参数ptr是NULL指针，则函数什么事都不做
malloc和free都声明在stdlib.h头文件中
#include<stdlib.h>
#include <stdio.h>
#include <stdlib.h> //动态内存管理对应头文件
#include <string.h> //strerror对应头文件
#include <errno.h> //errno对应头文件

int main()
{
	//申请40个字节的空间，交由指针变量p来管理
	int* p = (int*)malloc(10 * sizeof(int));
	//malloc申请空间可能会失败，所以要进行判断
	//申请失败：打印错误信息并退出
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//申请成功：使用
	for (int i = 0; i < 10; i++)
	{
		p[i] = i;
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);
	}
	//使用完：释放
	free(p);   //释放动态内存开辟的空间
	p = NULL;  //将p置空，防止野指针
}

2.2calloc

c语言还提供了一个函数叫calloc,calloc函数也用来动态内存分配。

void* calloc(size_t num,size_size);

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

void* calloc (size_t num, size_t size);
# void* 函数返回值，申请成功返回动态开辟的空间的起始地址，申请失败则返回NULL;
# size_t num 函数参数，用于指定要申请的元素个数：
# size_t size 函数参数，用于指定每一个元素的大小(字节为单位);
原文链接：https://blog.csdn.net/m0_62391199/article/details/125840627
#include <stdio.h>
#include <stdlib.h>

int main()
{
 int *p = (int*)calloc(10, sizeof(int));
 if(NULL != p)
 {
 //使用空间
}
 free(p);
 p = NULL;
 return 0;
}

所以如何我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloc函数来完成任务。

2.3realloc

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

void* realloc (void* ptr, size_t size);
#void*函数返回值，开辟成功返回动态开辟的空间的额起始地址，开辟失败则返回NULL；
#void*ptr 函数参数吗，表示要调整的空间起始地址
#size_t size函数参数，新的空间大小

3.ptr 是要调整的内存地址
4.size 调整之后新大小
5.返回值为调整之后的内存起始位置。
6.这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。
realloc在调整内存空间的是存在两种情况：
情况1：原有空间之后有足够大的空间
要扩展内存就直接原有内存之后追加空间，原来空间的数据不发生变换
情况2：原有空间之后没有足够大的空间
原有空间之后没有足够多的空间，扩展的方法是，在堆空间上另找一个合适大小的连续空间来使用，这样函数返回的是一个新的内存地址
由于上述的两种情况，realloc函数的使用就要注意一些。

#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;
}

3.常见的动态内存错误

3.1对NULL指针的解引用操作

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

 free(p);
}

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

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释放

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

}

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

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

}

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

void test()
{
 int *p = (int *)malloc(100);

 free(p);
 free(p);//重复释放
}

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

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

忘记释放不再使用的动态开辟空间会造成内存泄露
所以动态开辟的空间一定要释放，并且正确释放

4.经典笔试题

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

void Test(void)
{
	char* str = NULL;
	GetMemory(str);  
	strcpy(str, "hello world");
	printf(str);  //将str的首地址传给printf函数，可行
}

上面这段程序有三个问题：

第一：在Test函数中调用GetMemory函数时，传递的是str的值，所以GetMemory函数的参数p只是str的一份临时拷贝，与str没有任何关系，将动态开辟的100个字节交由指针p管理并不会对str产生任何影响；而且就算传递的是str的地址，malloc函数申请空间也有可能失败；

第二：由于GetMemory函数并没有能让str获得空间，所以str仍为NULL，这时调用strcpy函数会导致程序错误；

第三：代码中并没有对动态开辟的100个字节空间进行free，会导致内存泄漏；

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

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

上面的程序有两个问题：

第一：在GetMemory函数中，p是一个数组，是在栈区上开辟空间，而不是在堆区上动态开辟的，所以当GetMemory函数被调用完毕后其函数栈帧会立即销毁，所以GetMemory函数并不能使str指向一块可用内存；

第二：GetMemory返回了p的地址，并将其赋值给了str，由于GetMemory函数调用完毕后其函数栈帧销毁，所以原本属于p的那块空间现在已经不能使用了，而str保存了p那块空间的起始地址并在printf函数中进行了访问，就造成了野指针问题；

void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}

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

上面程序有两个问题：

第一：虽然这里把str的地址传递给了GetMemory函数，让其指向了一块动态开辟的空间，但是这里没有对malloc函数的返回值进行检查，当malloc失败的时候还是会产生空指针问题；

第二：程序中没有对malloc的空间进行free，造成了内存泄漏；

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

第一：没有对malloc的返回值进行空指针检查，使得strcpy函数可能执行失败；

第二：在free掉动态开辟的内存之后没有把相应的指针变量置空，导致if条件成立，造成野指针问题；

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

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

有了这幅图，我们就可以更好的理解在《C语言初识》中讲的static关键字修饰局部变量的例子了。
实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁所以生命周期变长。

6.柔性数组

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。
C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

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

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

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

6.1柔性数组的特点

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

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

6.2柔性数组的使用

//代码1
int i = 0;
type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));
//业务处理
p->i = 100;

for(i=0; i<100; i++)
{
 p->a[i] = i;
}
free(p);

这样柔性数组成员a，相当于获得了100个整型元素的连续空间。

struct S
{
	int n;
	int arr[];//柔性数组成员
};
int main()
{
	//开辟
	//malloc中加括号前面的部分为结构体普通成员，加号后面为柔性数组成员开辟空间
	struct S* s = (struct S*)malloc(sizeof(struct S) + 40);
	if (s == NULL)
	{
		perror("malloc");//perror函数，找到错误信息
		return 1;
	}
	//扩容
	struct S* ptr = (struct S*)realloc(s, sizeof(struct S) + 80);
	if (ptr == NULL)
	{
		perror("malloc");perror函数，找到错误信息
		return 1;
	}
	s = ptr;
	//使用
	s->n  = 0;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		s->arr[i] = i;
		printf("%d", s->arr[i]);
	}
	//销毁
	free(s);
	s = NULL;
	return 0;
}

6.3柔性数组的优势

如果动态内存管理基础学的扎实的同学可能会发现，我们完全可以在结构体中定义一个int*类型的成员变量，然后为此变量开辟一块空间，也可以达到柔性数组的效果，即如下面代码所示：

struct S
{
	int n;
	int* arr;//指针变量
};
int main()
{
	//开辟:由于含柔性数组的结构体的空间完全是在堆区上开辟的，所以为了最大程度上模拟其效果，这里我们也在堆区上开辟空间
		//为结构体开辟空间
	struct S* s = (struct S*)malloc(sizeof(struct S));
	if (s == NULL)
	{
		perror("malloc");//perror函数，找到错误信息
		return 1;
	}
	//让结构体中的int*变量指向另一块开辟空间
	s->arr = (int*)malloc(20);
	if (s->arr == NULL)
	{
		perror("malloc");
		return 1;
	}
	//扩容为int*指向空间
	int* ptr = (int*)realloc(s->arr, 40);
	if (ptr == NULL)
	{
		perror("realloc");
		return 1;
	}
	s->arr = ptr;
	//使用
	s->n = 0;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		s->arr[i] = i;
		printf("%d", s->arr[i]);
	}
	//销毁
	free(s->arr);
	free(s);
	s = NULL;
	return 0;
}

我们可以看到，上面的方法也可以实现柔性数组的效果，那为什么还要存在柔性数组呢？其实是因为柔性数组有着如下优势：

 方便内存释放。对于第二种代码，如果我们的代码是在一个给别人用的函数中，我们在里面做了二次内存分配，并把整个结构体返回给用户；用户调用free 函数可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，我们不能指望用户来发现这个事；所以，如果我们像第一种代码那样，把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次 free 就可以把所有的内存也给释放掉，很大程度上避免了内存泄露。

有利于提高访问速度。第二种方法我们用了两次 malloc 函数，这会一定程度上导致内存碎片；而第一种我们只使用了一次 malloc 函数，提高了内存的连续性；连续的内存有利于提高访问速度。