动态内存管理

为什么需要动态内存分配

**1.**动态内存分配允许程序在运行时根据需要请求内存。这意味着程序可以适应不同大小的数据集，而不需要在编译时知道确切的内存需求。

**2.**动态内存分配对于实现动态数据结构（至关重要。这些数据结构的尺寸在运行时可能会变化，动态内存分配可以有效地管理这些变化。

**3.**动态内存分配可以帮助程序更有效地管理内存资源。程序可以在不再需要时释放内存，从而避免内存浪费。

**4.**在某些情况下，动态内存分配可以提供更好的性能。例如，如果一个数据结构只需要在程序的一部分中使用，那么在需要时动态分配和释放内存可能比在程序的全局范围内保留固定大小的内存更有效率。

**5.**静态分配的内存受到系统栈大小的限制。对于大型数据结构或大量数据，可能会超出这些限制。动态分配的内存来自堆（heap），通常比栈大得多，因此可以容纳更大的数据结构。

**6.**动态分配的内存可以用来在函数之间传递大型数据结构，而不需要复制整个结构，这可以提高效率和减少内存使用。

**7.**当程序需要处理的数据量在编译时未知时，动态内存分配是必要的。例如，从用户输入读取数据或从文件加载数据时，程序可能需要在运行时分配足够的内存来存储这些数据。

malloc和free

malloc

函数定义

涉及到动态内存分配，在数据结构学习中就会看见malloc这个函数，在cpluspplus网站中：

这个函数向内存中申请一块连续可用的地址，并返回指向这片空间的指针
如果开辟成功，则返回一个指向这块空间的指针
如果开辟失败，则返回一个NULL指针
返回值是void*(只知道申请多大的空间，不知道存放什么类型的数据)
如果参数size为0，malloc的行为标准是未定义的，取决于编译器。

假如malloc为int类型开辟空间：

//int arr[10];//
int* p = (int*)malloc(40);
if (p == NULL)
{
	perror("malloc");//检查，并返回错误信息
	return 1;
}
//访问开辟的40个字节
int i = 0;
for (i = 0; i < 10; i++)
{
	*(p + i) = i;
}
//打印
for (i = 0; i < 10; i++)
{
	printf("%d", *(p + i));
}

函数详解

malloc申请的空间是在内存的堆区

free

函数介绍

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

void free (void* ptr);

free是用来动态内存释放的
如果参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的。
如果参数ptr是NULL指针，那么便什么事情都不做。
我们尝试有用free函数释放上述例子的内存：

虽然对于整个动态内存使用与结束的流程已经结束，但是我们可以发现，free函数无法p所存放地址的内存，
所以为了避免使p成为野指针，我们那还需要把指针p初始化

p=NULL;

calloc与realloc

calloc

calloc也是用来动态内存分配的：

void*calloc(size_tnum,size_t size);

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

我们同样用malloc的例子来举例：

int* p = (int*)calloc(100, sizeof(int));
if (p == NULL)
{
	perror("malloc");//检查，并返回错误信息
	return 1;
}

realloc

realloc函数让动态内存管理更加灵活。
realloc函数可以做到对动态开辟内存大小的调整。

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

ptr是要调整的内存地址
size是调整之后的新大小
返回值为调整之后党的内存起始位置

函数扩容情况

realloc的特殊扩容操作遍会出现特殊的情况：

1. 当扩容失败，函数返回NULL
2. 当扩容成功后，同样存在情况：

若后续空间足够进行扩容，那么就在原有内存后面直接追加空间

若原有空间之后没有足够多的空间，那么会在堆空间上另外找一个适合大小的连续空间，使用将旧地址的值传入到新地址空间中，并返回新的地址，旧的存放空间将会被释放掉。

当然，realloc也可以实现malloc函数的作用：

int* p=(int*)realloc(NULL,40);//等价于malloc

常见内存管理错误

对NULL指针的解引用操作

malloc等函数是有可能会返回空指针的

这里被VS标注，表示是有风险的，可能是空指针，正确的写法应该是：

int main()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		//报错信息
		perror("malloc");
		return 1;
	}
	*p = 20;
}

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

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i;//当循环到第11次时就越界访问了
	}
	//
	free(p);
	p = NULL;

	return 0;
}

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

int main()
{
	int a = 10;
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 1;
	}
	
	p = &a;//p指向的空间就不再是堆区上的空间
	free(p);
	p = NULL;
	return 0;
}

若空间不使用无法释放，且程序持续运行，就可能会导致内存泄露

**注意：**malloc/calloc/realloc 申请的空间 如果不主动释放，出了作用域是不会销毁的
若没有free的主动释放，那么只有在程序结束时，由操作系统来回收

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

int main()
{
	int a = 10;
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 1;
	}
	//使用

	//释放
	free(p);
	

	free(p);
	p = NULL;

	return 0;
}

这样对于程序也是会报错的，若将空间释放后，将指针初始化后再次执行是不会报错的。

动态内存忘记释放（内存释放）

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

int main()
{
    
    test();
    while (1);
}

经典笔试题分析

number 1

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

这段代码运行的结果是？
1.在 GetMemory 函数中，参数 p 是一个指针。将一个指针传递给函数时，实际上传递的是指针的副本，而不是指针本身。因此，在 GetMemory 函数内部对 p 所做的任何更改都不会影响原始指针 str
2.有上可知，str为NULL，对于NULL指针进行解引用，会造成程序崩坏
3.因为p的销毁，导致其指向的动态空间无法释放，会导致内存泄露。

代码要成功的话，应该是更改为：

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

number 2

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

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

这段代码有什么问题吗？
（返回栈空间地址问题！）
1.p 是一个局部数组，它在函数的栈帧上分配。当 GetMemory 函数返回时，这个数组就会被销毁，因此返回它的地址是错误的。
2.因为str所指向的空间由函数开辟，当函数结束时，空间释放，str就成为了野指针。

如果想要成功返回，需要让在函数中创建的空间不释放，可以使用static函数来变为静态局部变量。

number 3

void Test(void)
{
    char* str = (char*)malloc(100);
    strcpy(str, "hello");
    free(str);

   
    if (str != NULL)
    {
        strcpy(str, "world");
        printf(str);
    }

这行代码有没有问题呢？
肯定是不行的，在free(str)时，str指向的空间内存就已经释放了，但是str并未初始化，此时候进入if语句时，str就是一个野指针，在使用strcopy函数时，这里就出现了非法访问。

柔性数组

在C99标准中，结构体中的最后一个成员可以是一个柔性数组（允许是未知的大小），也称为伸缩性数组成员。柔性数组是一个数组，其大小在结构体定义时不需要指定，而是在运行时动态指定。这种数组的特点是可以根据需要动态地调整大小，因此它提供了很大的灵活性。
基本形式例如：

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

数组特点

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

方案比较

以下是需要扩容场景的两个操作：
方案一：

int main()
{
	//struct St s = {0};
	//printf("%d\n", sizeof(struct St));
	struct St* ps = (struct St*)malloc(sizeof(struct St));
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	ps->c = 'w';
	ps->n = 100;
	
	ps->arr = (int*)malloc(10*sizeof(int));
	if (ps->arr == NULL)
	{
		perror("malloc-2");
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}

	//数组空间不够
	int* ptr = (int*)realloc(ps->arr, 15*sizeof(int));
	if (ptr == NULL)
	{
		perror("realloc");
		return 1;
	}
	else
	{
		ps->arr = ptr;
	}
	//使用
	for (i = 10; i < 15; i++)
	{
		ps->arr[i] = i;
	}
	for (i = 0; i < 15; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n%d\n", ps->n);
	printf("%c\n", ps->c);

	//释放
	free(ps->arr);
	ps->arr = NULL;

	free(ps);
	ps = NULL;

	return 0;
}

方案二：

    int main()
{
	//struct St s = {0};
	//printf("%d\n", sizeof(struct St));
	struct St* ps = (struct St*)malloc(sizeof(struct St) + 10 * sizeof(int));
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	ps->c = 'w';
	ps->n = 100;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	//数组空间不够
	struct St* ptr = realloc(ps, sizeof(struct St) + 15 * sizeof(int));
	if (ptr != NULL)
	{
		ps = ptr;
	}
	else
	{
		perror("realloc");
		return 1;
	}
	//...继续使用

	for (i = 10; i < 15; i++)
	{
		ps->arr[i] = i;
	}

	for (i = 0; i < 15; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n%d\n", ps->n);
	printf("%c\n", ps->c);



	//释放
	free(ps);
	ps = NULL;

	return 0;
}

柔性数组的使用好处

方便内存释放 若我们的代码给别人的函数中，你在内部做了二次内存分配，并把整个结构体返回给用户，用户调用free可以释放结构体，但是你不能指望用户来发现结构体成员也需要free并释放动态内存，所以可以把结构体内存以及成员一次性分配好，以此只用一次free释放。
有益于访问速度连续的内存有益于提高访问速度，也有益于减少内存碎片。（内存碎片减少，寻址操作减少了）