【C进阶】动态内存管理

楔子

我们在内存中开辟空间通常都是在栈上开辟，比如int a = 10;在栈上开辟4个字节的空间，再者int a[100] ={0}在栈上开辟100个大小位4字节的连续空间。但栈上开辟的空间是有限的，比如我们开辟一个int a[10000000] = {0}这么大的数组，这时候编译器会报错，即Stack overflow栈溢出，那么我们想要这么大的空间应该怎么办呢？这时候就需要我们在堆上开辟空间，需要我们学习动态内存开辟。

动态内存函数

这些函数有malloc，realloc，calloc，free，包含在stdlib.h

malloc

void* malloc (size_t size);

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

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

另外，C语言还提供另一个函数free，该函数时专门用来回收和释放

void free (void* ptr);

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

#include<stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
int main ()
{
	int* p = (int*)malloc(sizeof(int) * 4);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 0;
	}
	for(int i=0; i<10; i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
	return 0;
}

注：

1. 我们开辟16个字节的空间，由于malloc是void*，所以我们要强制类型转化为int*，然后把这个空间的起始地址赋值给p变量。
2. 这里我们需要对指针的有效性进行判断，内部的strerror,errno,在这篇文章中说明链接
3. 将p中数据初始化0~9，使用完毕后我们free§,并且把p置为NULL

free的本质是什么在这篇文章中有所解答

calloc

void* calloc (size_t num, size_t size);

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

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

通过查看内存可以看到其全部被初始化为0

realloc

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

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

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

情况1：原有空间之后有足够大的空间
情况2：原有空间之后没有足够大的空间

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

int main()
{
	int* ptr = (int*)calloc(10, sizeof(int));
	if (NULL != ptr)
	{

	}
	int* p = NULL;
	p = realloc(ptr, 1000);//我们不能用原来的ptr来接受realloc函数返回值，因为我们不知道它是情况1，还是情况2
	if (p != NULL)
	{
		ptr = p;
	}
	free(ptr);
	ptr = NULL;
	return 0;
}

常见的动态内存错误

对NULL指针的解引用操作

#include <limits.h>
int main()
{
	int* p = (int*)malloc(INT_MAX);
	if (p == NULL)
		return 0;//没有这个语句，程序直接崩溃

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}

	return 0;
}

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

int main()
{
	char* p = (char*)malloc(10 * sizeof(char));
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 0;
	}
	//使用
	int i = 0;
	//for (i = 0; i <= 10; i++)//越界
	for(i=0; i<10; i++)
	{
		*(p + i) = 'a'+i;
	}
	//释放
	free(p);
	p = NULL;
	return 0;
}

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

int main()
{
	int a = 10;
	int*p = &a;
	free(p);//err
	p = NULL;

	return 0;
}

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

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 0;
	}
	//使用内存
	int i = 0;
	//1~5
	for (i = 0; i < 5; i++)
	{
		*p = i+1;
		p++;
	}
	//释放
	free(p);
	p = NULL;
	return 0;
}

我们释放时应该给free传入的是申请时的起始地址

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

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 0;
	}
	//使用内存
	int i = 0;
	//1~5
	for (i = 0; i < 5; i++)
	{
		*(p+i) = i + 1;
	}
	//释放
	free(p);
	p = NULL;

	free(p);//err

	return 0;
}

多次free，导致错误

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

int main ()
{
	while(1){
		int *p = malloc(1024):
	}
	return 0;
}

这里有详细介绍链接

经典的笔试题

题1

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

p时ptr的形式参数，并且这里时值传递，不会对str有影响，所以程序会崩溃，如果把str改为&str程序就会正常运行

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

int main()
{
	Test();
	return 0;
}

题2

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

字符数组是在栈上开辟的，当函数结束调用时这个空间被销毁了，所以我们打印出来的一串乱码

题3

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

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

提前free，导致无法使用

柔性数组

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

特点

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

使用

//code1
struct S1
{
	int n;
	int arr[0];//大小是未指定
};

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

int main()
{
	printf("%d\n", sizeof(struct S1));//4
	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;
}

优势

//code2
struct S
{
	int n;
	int* arr;
};

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	ps->n = 100;
	ps->arr = (int*)malloc(40);
	//使用
	//增容

	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;

	return 0;
}

code1比code2更好，原因有2点：

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

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

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

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