动态内存管理篇

为什么要动态内存分配？

之前，我们向内存申请空间，有两种方式，一种是定义变量，一种是建立数组；但是，这两种方式都有缺陷，创建的空间大小是固定的，在程序的运行过程中，不能随着我们的需要改变而改变，这就需要我们申请动态内存了

1. 动态内存函数

---

1.1 malloc和free

void* malloc (size_t size);

函数功能：

• 开辟一块size字节大小的空间
• 如果开辟成功，返回开辟空间首地址
• 如果开辟失败，返回NULL
• 如果size是0，标准未定义，取决于编译器
• 由于返回值是void*类型，因此返回的地址需要我们另做处理

void free (void* ptr);

函数功能：

• 释放ptr指向的空间，前提是ptr指向的空间是动态开辟的；如果ptr指向的空间不是动态开辟的，编译器会报错
• 如果ptr为NULL，则什么都不做
• 另外，释放完空间，ptr此时是一个野指针，需要置空

动态内存函数要和free一同使用，动态开辟的空间有两种方式释放：

1. free主动释放
2. 程序结束，操作系统会帮我们回收

虽然程序结束，申请的动态空间也会被回收，但如果程序在退出之前，开辟了多处动态内存而没有释放，又去开辟动态内存，很可能会导致内存泄漏，因此，每次申请的动态内存都要记得free释放

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

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

	for (int i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);
	}

	free(p);
	p = NULL;

	return 0;
}
//输出：0 1 2 3 4 5 6 7 8 9

内存非为三大部分，动态内存函数申请的空间是在堆上开辟的

1.2 calloc函数

void* calloc (size_t num, size_t size);

函数功能：

• num是开辟元素的个数，size是每个元素的大小，开辟num*size字节的空间
• calloc开辟空间后，会将空间自动初始化为0

1.3 realloc函数

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

动态开辟的内存用完了，想进行增容，这时就可以考虑使用realloc

函数功能：

• ptr是要进行扩容的地址，size为新的空间大小
• 返回新空间的地址
• 如果ptr为空，此时就相当于malloc函数

开辟空间有两种情况：

1. ptr后面的空间够存放新空间的大小：此时直接在ptr后面的空间扩容
2. ptr后面的空间不够存放新空间的大小：此时会另开辟一块size大小的空间，并把原数据拷贝到新空间，释放掉旧空间，返回新空间的地址

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

	//...

	//想扩容到100个int的大小
	//写法1
	p = realloc(p, 100 * sizeof(int));

	//写法2
	int* ptr = (int*)realloc(p, 100 * sizeof(int));
	if (ptr == NULL)
	{
		perror("realloc");
		return 1;
	}
	p = ptr;
	//...

	free(p);
	p = NULL;

	return 0;
}

用realloc开辟完空间，更推荐使用写法2，因为realloc开辟空间可能会失败，此时返回NULL，不仅没有扩容成功，还把原来的空间给弄没了

2.动态内存常见的错误

---

2.1对空指针进行解引用

这种情况通常是因为使用完动态内存函数没有对返回值进行检查

2.2对动态内存的越界访问

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

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

	return 0;
}

i=10的内存已经不属于我们的了；这种情况编译器是不会报错的，需要我们自己擦亮眼睛

2.3对非动态内存使用free

int main()
{
	int p[10] = { 0 };
	for (int i = 0; i < 10; i++)
	{
		p[i] = i;
	}

	free(p);

	return 0;
}

p指向的空间不是动态开辟的，不能进行free释放

2.4使用free释放一部分动态内存

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

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

	free(p);
	p = NULL;

	return 0;
}

p最终指向动态内存的一部分，free§只释放了一部分，最终仍有可能造成内存泄漏

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

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

	//...

	free(p);

	//...

	free(p);
	p = NULL;

	return 0;
}

前面说过，free指向的空间必须是动态内存，第二次free时，p指向的空间已经不是动态的了

2.6忘记释放动态内存

void Print(int n)
{
	int* p = (int*)malloc(n * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return;
	}

	if (n == 3)
		return;

	free(p);
	p = NULL;
}

int main()
{
	Print(3);

	return 0;
}

上面的代码写了free且置空，看似没有问题，但在执行free之前，函数已经返回，不会执行free，因此没有释放成功

内存泄漏是非常严重的问题，在日常写代码的过程中，一定要注意，动态开辟的内存要记得释放

3.笔试题讲解

---

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

上述代码的运行结果是什么？

• 由于p是str的一份临时拷贝，出了GetMemory函数就销毁了，malloc开辟出来的空间就找不到了，导致内存泄漏
• 执行完GetMemory函数，str仍然是NULL，在strcpy函数中，会对str解引用，对空指针进行解引用，最终导致程序崩溃

怎么修改上述代码，让它达到我们想要的功能？

char* GetMemory()
{
	char* p = (char*)malloc(100);

	return p;
}

void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	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);
}

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

p是GetMemory函数的局部变量，出了函数就销毁了，此时返回的p被外面的str接受，str就变成了野指针，打印的是一堆乱码，这是一种返回栈空间地址的问题

上面的代码也可以简化为：

int* Test()
{
	int a = 10;
	return &a;
}

int main()
{
	int* p = Test();
	printf("%d\n", *p);//10

	return 0;
}

同样是犯了返回栈空间地址的错误，我们发现该代码输出是正常的，这是为什么？

虽然结果正确，但这并不代表代码没有问题，结果正确的原因是Test函数即使销毁了，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);
}

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

该代码正常打印，唯一的缺点就是少了释放内存，存在内存泄漏的问题

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

str指向的空间释放后，没有置空，str此时是野指针，对野指针进行了访问，非法访问内存空间

题目5：

int* Test()
{
	int* p;
	*p = 10;
	return p;
}

创建p时没有对其初始化，p为随机值，随机指向一块空间，是野指针，对野指针进行了操作

4.C/C++的内存区域

---

• 栈区：执行函数时，函数内的局部变量都是在该区域创建的，当函数结束时，自动销毁创建的区域
• 堆区：动态开辟的空间在该区域创建，通常由程序员自己释放，当程序结束时，也会由操作系统自动回收
• 数据段：存放全局变量，静态数据，程序结束由系统释放
• 代码段：存放函数体的二进制代码

6.柔性数组

定义：在结构体中，最后一名成员是数据，且数组的大小未知，我们把该数组叫做柔性数组

struct S
{
	char c;
	int i;
	int arr[];
};

6.1柔性数组的特点

1. 柔性数组必须在结构体当中
2. 必须是最后一名成员
3. 柔性数组前面至少有一名成员
4. 该结构体的大小不包括数组的大小
5. 必须用动态内存函数对结构体开辟空间，且开辟空间的大小要大于结构体的大小，确保柔性数组有有一定的空间

6.2柔性数组的使用

//代码1
struct S
{
	char c;
	int i;
	int arr[];
};

int main()
{
	struct S* p;
	p = (struct S*)malloc(sizeof(struct S) + 20);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	p->c = 'a';
	p->i = 5;
	for (int i = 0; i < 5; i++)
	{
		p->arr[i] = i;
	}

	//空间不够了，进行增容
	struct S* ptr = (struct S*)realloc(p, sizeof(struct S) + 40);
	if (ptr == NULL)
	{
		perror("realloc");
		return 1;
	}
	p = ptr;
	ptr = NULL;
	for (int i = 0; i < 10; i++)
	{
		p->arr[i] = i;
	}

	free(p);
	p = NULL;

	return 0;
}

实际上，不用柔性数组也能完成上面的操作

//代码2  
struct S  
{
	char c;  
	int i;  
	int* arr;  
};

int main()  
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));


	if (ps == NULL) 
	{
		perror("malloc");
		return 1;
	}

	int* ptr = (int*)malloc(sizeof(int) * 5);
	if(ptr == NULL)
	{
		perror("malloc");
		return 1;
	}
	ps->arr = ptr;
	ptr = NULL;

	for (int i = 0; i < 5; i++)
	{
		ps->arr[i] = i;
	}
	
	//增容
	int* p = (int*)realloc(ps->arr, sizeof(int) * 10);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	ps->arr = p;
	p = NULL;

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

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

那么，使用柔性数组的代码1相较于代码2，有什么优势呢？

1. 方便内存的释放，使用柔性数组只需要释放一次内存空间；而代码2你必须先将结构体成员开辟的空间释放后，才能释放结构体，多释放意味着风险越多

---

动态内存的内容就到这！