动态内存函数

---

前言

我们之前掌握了两种内存开辟方式

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

这样开辟的空间有两个特点：
1.开辟的空间大小是固定的。
2.数组在申明的时候，必须指定数组长度，它所需要的内存在编译时分配。(有些编译器支持C99的变长数组，但在很多主流的大型编译器上是不支持变长数组的)。
但我们在实际应用中总是不能明确知道到底需要多大的空间，所以有了动态开辟内存。

---

一、动态内存函数

malloc()函数

void* malloc (size_t size);

这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
·如果开辟空间成功，则返回指向这块空间的指针。
·如果开辟空间失败，则返回NULL。所以我们在运用malloc()函数的使用，要用if语句判断，不然编译器会爆出警告或者出错。
·返回值的类型是void*，也就是malloc并不知道开辟空间的类型，具体在使用的时候由使用者来决定。
C语言提供了一个free()函数专门用来回收和释放动态开辟的内存。

void free (void* ptr);

·如果参数ptr指向的空间不是由动态开辟的，那么free函数的行为未知
·如果ptr是NULL，则函数什么都不做。
与动态开辟内存有关的函数都声明在<stdlib.h>头文件里。

//malloc函数的使用
#include<stdio.h>
#include<stdlib.h>

int main()
{
	//开辟一个空间存储10个整形元素
	int* p = (int*)malloc(sizeof(int) * 10);//因为malloc返回void*，强转成int*,操作的是字节数，而非元素个数
	if (p == NULL)
		return 1;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 10; i++)
		printf("%d ", *(p + i));

	free(p);//动态内存开辟的空间使用完一定要释放，避免内存泄漏
	p = NULL;//防止被释放的空间有一次使用。

	return 0;
}

calloc()函数

void* calloc (size_t num, size_t size);

calloc函数和malloc函数相似，也是用来动态内存开辟。
calloc第一个参数是开辟的元素的个数，第二个参数是元素的大小(字节数)。
但是calloc函数在动态开辟的时候，会把开辟的空间的字节全部初始化为0。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	//calloc函数的使用
	//也开辟一个存储10个整形的空间
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
		return 1;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	free(p);
	p = NULL;
	return 0;
}

realloc()函数

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

·realloc()函数的出现可以让动态内存函数变得更加灵活，如果没有realloc()函数，那么由malloc()和calloc()函数开辟的空间大小也就是固定的，这就不符合动态了。
·参数ptr是要调整的内存地址。
·参数size是调整之后的新大小。
·返回值为调整之后的内存起始位置。
·这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
realloc()函数开辟的内存有两种情况。
1.在原来开辟的空间后有足够的空间，要扩展空间就直接在原来开辟的空间后直接追加空间。
2.在原来开辟的空间后没有足够的空间，那就需要在内存中重新找一个新的空间，返回一个新的内存地址。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	//realloc()函数的使用
	//先用malloc()函数开辟一块空间存储5个整型
	int* ptr = (int*)malloc(sizeof(int) * 5);
	if (ptr == NULL)
		return 1;
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(ptr + i) = i;
	}

	//我们用realloc函数扩展空间，使其能够存储10个整型
	int* ptr2 = (int*)realloc(ptr, sizeof(int) * 10);
	if (ptr2 != NULL)
	{
		ptr = ptr2;
		ptr2 = NULL;
	}
	
	for (i = 0; i < 5; i++)
		printf("%d ", *(ptr + i));
	
	printf("\n");
	
	for (i = 5; i < 10; i++)
		*(ptr + i) = i;

	for(i = 0; i < 10; i++)
		printf("%d ", *(ptr + i));

	free(ptr);
	ptr = NULL;

	return 0;
}

要注意如果realloc()函数开辟不成功，会返回NULL指针，并保存原来开辟的空间，所以我们在使用realloc()函数的使用，尽量用一个新的指针来接受，防止出来找不到原来空间的情况，造成内存泄漏。

---

二、常见的动态内存错误

1.对NULL指针的解引用操作

int main()
{
	int* p = NULL;
	*p;
	return 0;
}

编译器在编译的时候就会爆出警告。

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

int main()
{
	//开辟一个空间存储10个整形元素
	int* p = (int*)malloc(sizeof(int) * 10);//因为malloc返回void*，强转成int*,操作的是字节数，而非元素个数
	if (p == NULL)
		return 1;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 12; i++)
		printf("%d ", *(p + i));

	free(p);//动态内存开辟的空间使用完一定要释放，避免内存泄漏
	p = NULL;//防止被释放的空间有一次使用。

	return 0;
}

这里我只用malloc开辟了10个整型空间，却访问了12个，这里编译器虽然没报错，程序也有运行结果，但在使用的使用还是尽量避免这一类的错误。

3.对非动态内存开辟空间运用free()函数

int main()
{
	int a = 10;
	int* p = &a;
	free(p);
	return 0;
}

这里程序会直接挂断，并爆出错误信息

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

int main()
{
	//开辟一个空间存储10个整形元素
	int* p = (int*)malloc(sizeof(int) * 10);//因为malloc返回void*，强转成int*,操作的是字节数，而非元素个数
	if (p == NULL)
		return 1;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 10; i++)
		printf("%d ", *(p + i));

	free(p);//动态内存开辟的空间使用完一定要释放，避免内存泄漏
	p = NULL;//防止被释放的空间有一次使用。
	free(p);
	return 0;
}

这里没有什么问题，是因为我在第一次free()后，把p置为空指针，因为free()函数传入参数是空指针则什么都不做。但如果，没有置空，继续free()则会报错。

5.动态内存开辟后忘释放

我们经常在用完动态内存开辟后的空间后就忘记释放了，虽然我们的程序在运行结束后系统会自动回收，但如果不回收呢，那块空间就会一直存在，如果多次运行同一段程序，内存泄漏的会越来越多，直到将内存撑爆。

6.free()释放动态内存开辟的一部分

int main()
{
	int* p = malloc(100);
	p++;
	free(p);
	return 0;
}

这样也是不可以的，程序在运行时会直接报错。

---

总结

动态开辟内存在数据结构的使用中很是频繁，我们要牢牢抓住这一点，才能在学数据结构时看到动态内存函数才不会感到陌生。我们在使用的时候也要注意动态开辟函数开辟的是字节数，不是元素个数，在使用完之后，要记得free()掉。