动态内存管理

目录

1.为什么存在动态内存管理

2.动态内存管理函数

2.1 malloc和free

2.2 calloc

2.3 realloc 

3.常见的动态内存错误

3.1 对NULL指针的解引用操作

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

3.3 对非动态开辟内存使用free释放

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

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

3.6 动态开辟内存忘记释放

4.动态内存管理的经典笔试题

4.1 题目1：

4.2 题目2：

4.3 题目3：

4.4 题目4：

5.C/C++程序的内存开辟

6.柔性数组

6.1 什么是柔性数组

6.2 柔性数组的特点

6.3 柔性数组的使用

6.4 柔性数组的优点 

---

1.为什么存在动态内存管理

我们已知内存开辟方式有：

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

但是这种开辟空间的方式有两个特点：

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

但是有时候我们需要的空间大小在程序运行的时候在能知道，那么数组开辟空间的方式就不能满足了，这时候我们就需要动态内存开辟了。

2.动态内存管理函数

---

重点补充：

前面所说的变量val和数组arr都是在栈空间上开辟的内存空间，下面所介绍的内存函数都是在堆空间上开辟内存空间，关于堆栈空间以及内存分区，我们来重点回顾一下：

---

2.1 malloc和free

​void* malloc (size_t size);​

• 这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
• 返回类型是void*，所以malloc函数开辟出来的空间类型可以是任意类型，具体在使用的时候有我们自己来决定。（使用（类型）来进行强转）。
• size表示开辟空间的大小（单位字节），如果size为0，malloc函数的行为是标准未定义的，取决于编译器。
• 如果空间开辟成功，则malloc函数返回开辟空间的起始地址。
• 如果空间开辟失败，则返回NULL指针，因此malloc函数的返回值一定要做检查。
• malloc函数不会初始化开辟空间的内容。

​void free (void* ptr);​

• free函数用来释放动态开辟的内存。
• 如果参数ptr指向的空间不是动态开辟的，那么free函数的行为是未定义的。
• 如果参数ptr是NULL指针，则函数会忽略该调用，并不会导致错误和未定义行为。

malloc和free函数都声明在stdlib.h头文件中

两个函数的使用：

int main()
{
	int num = 0;
	scanf("%d", &num);
	int* ptr = (int*)malloc(num * sizeof(int));
	if (ptr == NULL)
	{
		perror("malloc");
	}
	else
	{
		int i = 0;
		for (i = 0; i < num; i++)
		{
			*(ptr + i) = 0;
			//ptr[i] = 0;
		}
	}
	free(ptr);
	ptr = NULL;

	return 0;
}

代码细节：

• malloc函数的返回值要做检查，不能为NULL。（可用perror检查）。
• 自己malloc出来的空间要自己free（释放）掉，并且置空NULL。
• *（ptr+i）可以直接写成ptr[i]，以数组的形式访问。

具体原因在后面解释。

2.2 calloc

​void* calloc (size_t num, size_t size);​​

C语言还提供了calloc函数，这个函数和malloc函数很像，但区别如下：

• 函数的功能是为num个大小为size字节的元素开辟一块空间，并且把空间的每个字节初始化为0。
• 与函数ma1loc的区别只在于calloc会在返回地址之前把申请的空间的每个字节初始化为全0。

函数使用：

calloc函数相比malloc函数，多了一个初始化功能。

2.3 realloc 

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

realloc函数是这四个内存函数的核心，它的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那realloc函数就可以做到对动态开辟内存大小的调整。

• ptr是要调整的内存地址。
• size调整之后新大小。
• 返回值为调整之后的内存起始位置，如果调整失败，返回NULL。所以realloc函数的返回值也要做检查。
• 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
• 如果ptr==NULL时，realloc函数的功能和malloc函数一样。

realloc在调整内存空间的是存在两种情况:

• 情况1：原有空间之后有足够大的空间。
  当是情况1的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。
• 情况2：原有空间之后没有足够大的空间。

情况二做以下四件事情：

• 1.开辟新的空间
• 2.将旧空间的数据拷贝到新空间
• 3.释放旧空间
• 4.返回新空间的起始地址

函数使用：

代码一：

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

	//初始化为1~10
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		p[i] = i + 1;
	}

	//增加一些空间
	int* ptr = (int*)realloc(p, 20 * sizeof(int));
	if (ptr == NULL)
	{
		perror("realloc");
		return 1;
	}
	p = ptr;
	ptr = NULL;

	//打印数据
	for (i = 0; i < 20; i++)
	{
		printf("%d\n", p[i]);
	}

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

	return 0;
}

会显然发现我们调整了空间大小，并且后面十个数据我们没有初始化。

---

注意：研究下面代码可能出现的问题

代码二：

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

	//增加一些空间（扩展容量）
	int* p = (int*)realloc(p, 20 * sizeof(int));

我们直接用变量p来接收realloc函数的返回值，如果realloc扩容失败返回NULL，会导致p 置成NULL，p原来指向的空间也会丢失。所以我们一般会使用代码一的写法，用一个临时指针变量tmp来接收realloc函数的返回值，并且判断NULL，然后没有问题后再赋给我们要调整的指针变量p。

3.常见的动态内存错误

以下介绍的是动态内存开辟中常见的错误。

3.1 对NULL指针的解引用操作

void test()
{
	int *p = (int *)malloc(INT_MAX/4);
	*p = 20;//如果p的值是NULL，就会有问题
	free(p);
}

• malloc函数开辟空间失败时，会返回NULL指针，这里的参数明显很大，函数返回的是NULL，NULL就不能被解引用。
• NULL指针不指向任何有效的空间，不能被使用，也不能被解引用。
• 使用malloc/calloc/realloc函数，必须要对返回值进行检查，还要free掉创建的空间并且置空（NULL）。

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

void test()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));
	if (NULL == p)
	{
		exit(EXIT_FAILURE);
	}
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i;//当i是10的时候越界访问
	}
	free(p);
}

3.3 对非动态开辟内存使用free释放

void test()
{
	int a = 10;
	int* p = &a;
	free(p);
}

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

void test()
{
	int* p = (int*)malloc(100);
	p++;
	free(p);
}

p的起始位置一定不能偏移，否则free会报错。

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

这是涉及以后C++要学习的深浅拷贝问题，重点掌握。

void test()
{
	int* p = (int*)malloc(100);
	free(p);
	free(p);
}

3.6 动态开辟内存忘记释放

动态申请的内存空间，不会因为出了作用域而自动销毁，只有两种方式才能销毁（这里的销毁不是破坏毁坏的意思，是被操作系统回收）：1，程序员自己free掉 2，程序运行结束收回

void test()
{
	int* p = (int*)malloc(100);
	if (NULL != p)
	{
		*p = 20;
	}
}

int main()
{
	test();
	while (1);
}

4.动态内存管理的经典笔试题

4.1 题目1：

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

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

• 形参是实参的一份拷贝，p是str的拷贝，所以p的改变不会引起str的变化，str依然是NULL。
• strcpy函数里面的指针参数不能是NULL，因为函数内部要对指针进行解引用。
• 指针p指向的空间没有被释放，并且函数调用结束后没有机会去释放，造成内存泄漏。

注意：printf函数的使用：

printf("hello world"); 函数参数里面传的其实不是整个字符串，传的其实是指针，也就是首字符h的地址，和字符串函数相同。

等价于：char* p = "hello world"; printf(p);

4.2 题目2：

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

void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}

数组p[ ]是局部变量，分配在内存分区中的栈区，出了作用域，指针p指向的栈区空间被销毁，这样str和p都是野指针。

4.3 题目3：

void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}

void Test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	//“hello”在代码段中的常量区，str指向一块堆区空间，strcpy函数就是把常量区的字符串拷贝到堆区中
	printf(str);
}

内存泄漏，没有释放str。

4.4 题目4：

void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	//str = NULL:
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}

free掉一块空间后要置空NULL；str=NULL；

5.C/C++程序的内存开辟

C/C++程序内存分配的几个区域：

1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区（heap）：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS（操作系统）回收 。分配方式类似于链表。
3. 数据段（静态区）：存放全局变量、静态数据（static修饰的变量）。程序结束后由系统释放。
4. 代码段：存放函数体（C++类的成员函数和全局函数）的二进制代码以及只读常量（比如字符串常量）。

6.柔性数组

6.1 什么是柔性数组

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

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

有些编译器报错可以写成：

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

6.2 柔性数组的特点

• 结构中的柔性数组成员前面必须至少一个其他成员。（如int i）
• sizeof 返回的这种结构大小不包括柔性数组的内存。（不包括a[ ]所占空间大小）
• 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

比如：

6.3 柔性数组的使用

代码一：

struct S
{
	int n;
	int a[0];//柔性数组成员
};

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	if (!ps)
	{
		perror("malloc");
		return 1;
	}

	ps->n = 10;

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

	//增容
	struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 15 * sizeof(int));
	if (!ptr)
	{
		perror("realloc");
		return 1;
	}

	ps = ptr;
	ps->n = 15;

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

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

	return 0;
}

这么开辟柔性数组空间，相当于获得了15个整形元素的连续空间。并且后面增容的五个元素没有初始化。

6.4 柔性数组的优点 

还有一种很重要的结构体设计（在后面学习的数据结构的顺序表中使用）

struct S
{
	int n;
	int* arr;
};

 

 此时我们发现这种结构体设计和前面的柔性数组并不同。

代码二：

struct S
{
	int n;
	int* arr;
};

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (!ps)
	{
		perror("malloc->ps");
		return 1;
	}

	ps->n = 10;
	ps->arr = (int*)malloc(ps->n * sizeof(int));
	if (!ps->arr)
	{
		perror("malloc->arr");
		return 1;
	}

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

	//容量调整
	ps->n = 15;
	int* ptr = (int*)realloc(ps->arr, ps->n * sizeof(int));
	if (!ptr)
	{
		perror("realloc");
		return 1;
	}

	ps->arr = ptr;

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

	//注意释放顺序
	free(ps->arr);
	ps->arr = NULL;

	free(ps);
	ps = NULL;

	return 0;
}

代码一和代码二在堆中的内存分配区别：

代码一：​

 

代码二：

 

上述 代码1 和 代码2 可以完成同样的功能，但是 方法1 的实现有两个好处：

• 第一个好处是：方便内存释放
  如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给
  用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你
  不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好
  了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉
• 第二个好处是：这样有利于访问速度.
  连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正
  你跑不了要用做偏移量的加法来寻址）

注意：柔性数组虽然相比代码二有优点，但是他是C99的语法规定，早期编译器都不支持C99语法，所以代码的通用性不强，一旦项目需要进行代码移植会有很大麻烦，后期我们实现顺序表时还是使用代码二靠谱。