[C++知识库] 【动态内存管理】动态内存分配、常见错误、经典笔试题、柔性数组

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> C++知识库 -> 【动态内存管理】动态内存分配、常见错误、经典笔试题、柔性数组 -> 正文阅读

[C++知识库]【动态内存管理】动态内存分配、常见错误、经典笔试题、柔性数组

一、动态内存分配

1、为什么存在动态内存分配

空间开辟大小是固定的
数组在声明的时候，必须指定数组的长度，它所需要的内存在编译时分配

堆区
malloc calloc realloc free

二、malloc

在堆区上申请size_t大小的空间返回这块空间的起始位置

void* malloc(size_t t);

1、malloc、free

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

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

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

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

#include <stdio.h>
#include <stdlib.h>

int main()
{
	// 1. 开辟空间
	int* p = (int*)malloc(40); // 申请40大小空间 把起始地址强转为int* 赋给p

	if (p == NULL)
	{
		return -1;
	}
	// 开辟成功了 可以使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}

	// 2. 释放空间
	free(p);
	p = NULL; // 

	return 0;
}

2、calloc

void* calloc (size_t num, size_t size);

2.1、与malloc 的区别

malloc函数只负责在堆区申请空间，并且返回起始地址，不初始化空间
calloc函数在堆区上申请空间，并且在返回起始地址之前把申请的每个字节初始化为0

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return -1;
	}
	// 申请成功
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}

	// 释放空间
	free(p);
	p = NULL;

	return 0;
}

3、realloc

让动态内存管理更加灵活

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

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

两种情况：

后面空间大小够用，直接在后面开辟
空间不够，在堆空间上另找一个合适大小的连续空间来使用，这样函数返回的是一个新的内存地址

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return -1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}

	// 空间不够大，增加空间至20int
	int* ptr = (int*)realloc(p, 20 * sizeof(int));
	if (ptr != NULL)
	{
		p = ptr;
	}
	else
	{
		return -1;
	}
	// 增加成功，使用
	for (i = 10; i < 20; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 20; i++)
	{
		printf("%d ", *(p + i));
	}

	free(p);
	p = NULL;

	return 0;
}

4、常见错误

4.1、对malloc返回值判断

int* p = (int*)malloc(20);
*p = 0; // 有风险

#include <stdio.h>
#include <stdlib.h>

int main()
{
	int* p = (int*)malloc(20);

	if (p == NULL)
	{
		return -1;
	}
	*p = 0;

	return 0;
}

4.2、对动态内存空间的越界访问

#include <stdio.h>
#include <stdlib.h>

int main()
{
	int* p = (int*)malloc(200);

	if (p == NULL)
	{
		return -1;
	}

	int i = 0;
	for (i = 0; i < 80; i++)
	{
		*(p + i) = 1;
	}
	
	for (i = 0; i < 80; i++)
	{
		printf("%d ", *(p + i));
	}

	free(p);
	p = NULL;

	return 0;
}

4.3、释放非动态内存空间

int main()
{
	int a = 10;
	int* p = &a;

	free(p); // err
	p = NULL;

	return 0;
}

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

改变了p 不再指向起始位置此时释放的不在起始位置

#include <stdio.h>
#include <stdlib.h>

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

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

	free(p);
	p = NULL;

	return 0;
}

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

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return -1;
	}

	free(p);
	free(p); // err
}

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return -1;
	}

	free(p);
	p = NULL;

	free(p); // ok
}

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

在堆区上申请空间，有2种回收方式，

free
程序退出时，申请的空间回收

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return -1;
	}
	// 没有释放

	return 0;
}

三、经典笔试题

题目一：

#include <stdio.h>
#include <string.h>

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

在这里插入图片描述

程序会崩溃

str传给p的时候，是值传递，p是str的临时拷贝，所以当malloc开辟的空间起始地址放在p中时，不会影响str，str仍是NULL
当str是NULL，strcpy想把hello world拷贝到str指向的空间时，程序就会崩溃，因为NULL指针指向的空间时不能直接访问的
存在内存泄漏，出函数销毁，无法回收空间

修改：
版本1：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void GetMemory(char** p)
{
	*p = (char*)malloc(100);
}
 
void Test(void)
{
	char* str = NULL;
	GetMemory(&str); // char**
 
	strcpy(str, "hello world");
	printf(str);
	// 释放
	free(str);
	str = NULL;
}
 
int main()
{
	Test();
	return 0;
}

版本2：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char* GetMemory(char* p)
{
	p = (char*)malloc(100);
 
	return p;
}
 
void Test(void)
{
	char* str = NULL;
 
	str = GetMemory(str);

	strcpy(str, "hello world");
 
	printf(str);
	
	free(str);
	str = NULL;
}
 
int main()
{
	Test();
	return 0;
}

题目二：

#include <stdio.h>

char* GetMemory(void)
{
	char p[] = "hello world";

	return p;
}
 
void Test(void)
{
	char* str = NULL;

	str = GetMemory();

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

【返回栈空间地址问题】

在这里插入图片描述

#include <stdio.h>

int* test()
{
	int n = 10;

	return &n;
}
 
int main()
{
	int* p = test();

	printf("%d\n", *p);
	// 如果没有被覆盖,有可能输出10
	
	return 0;
}

题目三：

#include <stdio.h>

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

通过*p 用malloc给str在堆上开辟空间，
问题：

内存泄漏，没有free
free(str);
str = NULL;

改正：

#include <stdio.h>
#include <stdlib.h>

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(str);
	str = NULL;
}

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

题目四：

#include <stdio.h>
#include <stdlib.h>

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

在这里插入图片描述

改正：

#include <stdio.h>
#include <stdlib.h>

void Test(void)
{
	char* str = (char*)malloc(100);

	strcpy(str, "hello");
	free(str);
	str = NULL;

	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}

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

四、C/C++程序的内存开辟

在这里插入图片描述

五、柔性数组

1、柔性数组成员

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

// 数组大小不确定，可大可小
typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;
// 编译器报错无法编译可改成：
typedef struct st_type
{
	int i;
	int a[];//柔性数组成员
}type_a;

2、柔性数组的特点：

1. 结构中的柔性数组成员前面必须至少一个其他成员
	如 int a[] 前有 int i
2. sizeof 返回的这种结构大小不包括柔性数组的内存

#include <stdio.h>

typedef struct st_type
{
	int i;
	int a[];//柔性数组成员
}type_a;

int main()
{
	printf("%d\n", sizeof(struct st_type)); // 4
	return 0;
}

3. 包含柔性数组成员的结构体的使用，要配合malloc()这类动态内存分配函数使用

在这里插入图片描述

3、使用

实现之一：

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

struct st_type
{
	int i;
	int a[];
};

int main()
{
	struct st_type* ps = (struct st_type*)malloc(sizeof(struct st_type) + 10 * sizeof(int));
	// 4byte - i
	// 40byte - a

	if (ps == NULL)
	{
		printf("%s\n", strerror(errno));
		return -1;
	}
	// 开辟成功                                         
	ps->i = 100;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->a[i] = i;
	}

	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->a[i]);
	}

	// a数组的空间不够了，调为20个整型数据
	struct st_type* ptr = (struct st_type*)realloc(ps, sizeof(struct st_type) + 20 * sizeof(int));
	if (ptr == NULL)
	{
		printf("扩容空间失败");
		return -1;
	}
	else
	{
		ps = ptr;
	}

	// 使用...

	// 释放
	free(ps);
	ps = NULL;

	return 0;
}

实现之二：

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

struct st_type
{
	int i; // 4
	int* a; // 4
};

int main()
{
	struct st_type* ps = (struct st_type*)malloc(sizeof(struct st_type)); // 开辟8字节空间
	ps->i = 100;
	ps->a = (int*)malloc(10 * sizeof(int));

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

	{
		printf("%d ", ps->a[i]);
	}

	// 调整ps->a 空间
	int* ptr = (int*)realloc(ps->a, 20 * sizeof(int));
	if (ptr == NULL)
	{
		printf("扩容失败\n");
		return -1;
	}
	else
	{
		ps->a = ptr;
	}

	// 使用...

	// 释放
	free(ps->a);
	ps->a = NULL;
	free(ps);
	ps = NULL;

	return 0;
}