最最详细解读动态内存分配函数malloc，free，calloc，realloc，还有《柔性数组》

为什么存在动态内存分配

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

int main()
{
	int a = 10;
	int arr[10] = { 0 };
	return 0;
}

但是上述的开辟空间的方式有两个特点
1.空间开辟大小时固定的
2.数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配

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

所以这时候就只能试试动态内存开辟了

动态内存函数

malloc

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

1.如果开辟成功，则返回指向这块内存的指针
2.如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查
3.返回值的类型时void*，因为malloc函数并不知道要开辟空间的类型，由使用者自己来决定
4.参数size是要开辟多少字节的空间，如过size为0，malloc函数行为标准是未定义的，取决于编译器。

free

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

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

记住动态开辟内存一定要释放，不然会造成内存泄漏

typedef struct Stu
{
	char name[10];
	int i;
}Peo;

int main()
{
	Peo* ps=(Peo*)malloc(sizeof(Peo) * 10);
	if (ps == NULL)
	{
		printf("%s", strerror(errno));
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(ps->name + i) = 'a';
	}
	ps->i = 10;

	free(ps);//释放ps所指向的空间
	ps = NULL;//防止ps变成野指针
	
	return 0;
}

这里问题结合下面这张图更容易理解

calloc

calloc也是c语言提供给我们的动态内存分配函数

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

realloc

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

有时候我们发现过去申请空间大了，或者小了，为了合理使用内存空间，我们就会对存储的大小做灵活的调整，那么realloc函数就可以做到对内存空间大小的调整

1.ptr是要调整的内存空间
2.size是调整之后的新大小（之前申请内存空间大小+在要申请内存空间的大小）
3.返回值为调整之后的内存起始地址
4.这个函数调整原内存空间大小的基础上，还会讲原来内存中的数据移动到新的空间

realloc在调整内存空间存在两种情况
情况1 ：原来空间之后又足够大的空间，直接在原有空间后面追加空间，原来空间的数据不发生变化

情况2 ：原有空间之后没有足够大的空间，在堆空间另找一块合适大小的连续空间，把原有空间数据拷贝过来。

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		printf("申请失败\n");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	int* pt = (int*)realloc(p, 80);
	if (pt == NULL)
	{
		printf("扩容失败\n");
		return 1;
	}
	p = pt;
	for (; i < 20; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 20; i++)
	{
		printf("%d ", *(p + i));
	}
	free(p);
	p = NULL;
	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);
}
int main()
{
	Test();
	return 0;
}

请问运行Test函数会有什么样的结果？

题目2

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

请问运行Test函数会有什么样的结果？

题目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);
}
int main()
{
	Test();
	return 0;
}

请问运行Test函数会有什么样的结果？

题目4

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

请问运行Test函数会有什么样的结果？

题目1答案

首先内存泄漏，其次对空指针解引用程序会奔溃。

题目2答案

不一定会打印hello world，因为GteMemory函数栈帧结束之后，这块内存空间就还给操作系统了。这块空间可能被覆盖。或者保留原来值。

题目3答案

打印hello，但是没有free造出了内存泄漏

题目4答案

free之后str所指向的空间就释放掉了，而str就变成了野指针，对野指针进行解引用会有问题。有关strcpy看这里。

柔性数组

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

struct s
{
	int i;
	int arr[];
};

柔性数组的特点

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

struct s
{
	int i;
	int arr[];
};
int main()
{
	//printf("%d ", sizeof(struct s));
	//这样柔性数组成员arr，相当于获得了100个整型大小的空间
	struct s* ps = (struct s*)malloc(sizeof(struct s) + 100*sizeof(int));
	free(ps);
	ps=NULL;

	return 0;
}

柔性数组的优势

struct s
{
	int i;
	int* a;
};
int main()
{
	struct s* ps = (struct s*)malloc(sizeof(struct s));

	ps->a = (int*)malloc(100 * sizeof(int));

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

	return 0;
}

上述两段代码都完成了同样的功能，但是第一段代码的实现有两个好处
第一个好处：方便内存释放
第二个好处：有利于访问速度（连续的malloc申请内存空间会造成内存碎片）