动态内存管理

实践中发现具体的问题

为什么存在动态内存

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

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

这是在栈区上开辟空间，编译器在我们使用完后会自动释放。

但是上述的开辟空间的方式有两个特点：

1. 空间开辟大小是固定的。
   例：
   int就是开辟4个字节的空间，
   char[10]就是十个字节的空间
2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。
   但是对于空间的需求，不仅仅是上述的情况，有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。
   这时候就可以使用动态内存开辟了。
   内存空间上专门有一片区域让我们进行动态内存开辟，就是堆区。我们可以自行在上面开辟，但使用后要自己释放掉。

动态内存函数的介绍

下面几个函数都是<stdlib.h>头文件下的函数

1.malloc

void* malloc (size_t size);
//(size_t)无符号整型，(size)需要开辟的空间大小，字节数.返回值是void*类型的指针。

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

函数的使用：

int main()
{
    //malloc成功后会返回一个指向开辟空间的void*的指针，
    //我们设置一个指针变量来接收它,记得要类型转换。
	int* p =(int*) malloc(sizeof(int) * 3);
	if (p ！= NULL)//判断开辟是否成功
	{
		;//使用空间。
	}
	free(p);
	p=NULL;
	return 0;
}

2.calloc

void* calloc (size_t num, size_t size);

函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0 ( 两者的使用方式注意事项是完全相同的).
函数的使用：

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

3.free

通过对malloc和calloc的使用，我们大概猜到这个函数的作用了。它负责释放掉我们开辟的空间。

void free (void* ptr);

1.如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
例：

int main()
{
	int m = 2;
	int* p = &m;
	free(p);
	return 0;
	//这样子写编译器会报错，不能用free来释放非动态内存开辟的空间
}

2.如果参数 ptr 是NULL指针，则函数什么事都不做。
3.malloc，calloc这些函数与它必须同时出现。
4.free括号里的需要是指向动态内存的起始地址。
例：

void test()
{
int *p = (int *)malloc(100);
p++;
free(p);//p不再指向动态内存的起始位置，这样会导致空间释放不全。
}

5.free之后的指针会变成野指针，它虽然还指向原来的堆地址，但是内容可能已经不是你的内容了，具有不确定性。所以在使用free后都要free=NULL变成空指针。

4.realloc

malloc和calloc之后，我们可能还是会发现分配的空间不够用或者多了，因此就有了这个函数用于调整开辟的空间大小。

void* realloc (void* ptr, size_t size);
//ptr 是要调整的内存地址
//size 调整之后新大小

1.返回值为调整之后的内存起始位置。
2.这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。
realloc在调整空间大小时有两种情况：
情况1：原有空间后有足够的空间。
情况2：原有空间后没有足够的空间

int main()
{
	int* ptr = (int*)malloc(sizeof(int) * 100);
	int i = 0;
	if (ptr != NULL)
	{
		for (i = 0;i < 100 ; i++)
		{
			*(ptr + i) = i;
		}
	}
	else
	{
		perror("malloc");
	}
	ptr = realloc(ptr, sizeof(int) * 1000);
	//这样写觉得合理吗

	return 0;
}

在realloc的位置我们一定是要杜绝这样写的。
因为如果realloc失败ptr就会变为NULL，我们就找不到之前malloc开辟的空间了。
正确的写法

	int* p = realloc(ptr, sizeof(int) * 1000);
	if (p != NULL)
	{
		ptr = p;
	}
	else
	{
		perror("realloc");
	}

动态内存的常见错误

1. 动态开辟内存后忘记释放。没有free。这样会造成内存泄漏，内存会越来越少。
2. 对指向空间起始位置的变量多次free。
3. 对开辟的空间越界访问。

int* ptr = (int*)malloc(sizeof(int) * 100);
	int i = 0;
	if (ptr != NULL)
	{
		for (i = 0;i <= 100 ; i++)//i=100时就产生了越界访问。
		{
			*(ptr + i) = i;
		}
	}

4.对NULL指针进行解引用操作。

几个经典的笔试题

题目1：

请问运行后会有什么后果？

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

strcpy(str, "hello world");
printf(str);

这里我们会对NULL引用，从而报错。这时你可能会想我们不是给他开辟空间了吗， 但实际上我们只是给形参p开辟了，str并没有改变，还是空指针 。而且这个代码中也没有free，但这里主要问题是对NULL的引用，我们要时刻谨记形参和实参的关系。

题目2：

运行下列代码会有什么结果？

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

char p[] = "hello world";

这里我们是在栈区开辟的空间，在函数GetMemory结束后，空间便会返换回栈区。之后p就变成了野指针，我们不能在引用它。

题目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);
	}
}

strcpy(str, "world");

这里进行了free之后又对str引用，free之后指针str会变成野指针，不能再引用了。当然这里在进行malloc之后，也没对str进行判断是否为NULL。
主要问题是对free之后的指针的引用

谢谢大家的阅读