C语言学习之路

第一章 初识C语言
第二章 变量
第三章 常量
第四章 字符串与转义字符
第五章 数组
第六章 操作符
第七章 指针
第八章 结构体
第九章 控制语句之条件语句
第十章 控制语句之循环语句
第十一章 控制语句之转向语句
第十二章 函数基础
第十三章 函数进阶（一）（嵌套使用与链式访问）
第十四章 函数进阶（二）（函数递归）
第十五章 数组进阶
第十六章 操作符（详解及注意事项）
第十七章 指针进阶（1）
第十八章 指针进阶（2）
第十九章 指针进阶（3）
第二十章 指针进阶（4）
第二十一章 数据的存储（秒懂原、反、补码）
第二十二章 指针和数组笔试题详解（1）
第二十三章 指针和数组笔试题详解（2）
第二十四章 字符串函数（1）
第二十五章 字符串函数（2）
第二十六章 内存函数
第二十七章 自定义数据类型之结构体进阶（1）
第二十八章 自定义数据类型之结构体进阶（2）
第二十九章 动态内存管理（1）
第三十章 动态内存管理（2）

---

---

前言

前面一章中，我们主要讲解了动态内存管理相关的四个函数：malloc、realloc、calloc、free。本章节中，将针对前面的函数做一些笔试题，同时了解一下柔性数组的概念。

---

一、笔试题（一）

题目描述

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

上述test函数的运行结果是什么？

题目解答

上述代码在运行时，出现了一个访问权限的错误。接下来我们仔细分析一下上面的代码。
在test函数中，我们采用值传递的方式调用了getmemory函数，所以我们并不是将str这个指针传入，而是将str的数据，即NULL进行了传入，即此时形参变量p接收了NULL。（这里不懂的话，请看：第十二章 函数基础），当我们明白了这个代码采用的是值传递的时候，这道题就迎刃而解了。因为str本身依旧是空指针，并没有发生改变，我们对空指针进行了解引用操作，必然会发生错误。

代码调整

那么我们如何将代码写对呢？

方法1：二级指针（地址传递）

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

方法2：修改返回值

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

二、笔试题（二）

题目描述

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

题目解答

我们发现，上面的代码虽然解决了题目一中的值传递问题，但是最终的打印结果依然是错误的。这是为什么呢？
在解决这个问题之前，我们首先要回忆一下堆区和栈区的知识。栈区中主要存储的是局部变量。而局部变量的生命周期比较短，当生命周期截至，即代码运行完整个大括号后，会对局部变量进行释放。这里也是同理，我们发现，getmemory函数中是在栈区开辟的内存，所以当这个函数执行结束的时候，这个函数中的局部变量就会被释放。所以存储的字符串也会被释放掉。当这段空间被释放掉后，这段空间依然存在，其地址也不会发生改变，也就是说，我们依旧可以通过一个相同的地址找到这块空间，但是这段空间中存储的内容将是一堆乱码。
因此，当我们将这段空间的地址返回时，我们利用str指针接收，此时打印出来的就是这段空间被释放后所放置的乱码。

代码调整

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
char* GetMemory()
{
	char* p = (char*)malloc(40);
	assert(p != NULL);

	return p;
}
void Test()
{
	char* str = NULL;
	str = GetMemory();
	strcpy(str, "hello world.");
	printf(str);
	free(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

三、笔试题（三）

题目描述

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

题目解答

我们发现这段代码运行后，最终都得到了我们想要的结果，但是上面的代码就一定正确码？我们发现在我们修改第一二题目的时候，我们有意地释放了动态开辟的内存，同时将指向被释放的动态开辟内存空间的指针设置为空指针。那么这段代码恰恰就缺少了释放动态开辟空间的步骤。所以造成了内存泄漏问题，很多人会想，这段代码很短，当代码执行结束后，系统同样会释放堆区中未被释放的空间，用不着我们释放。但是，在较大工程中，倘若我们每次开辟都不释放，那么内存泄漏是相当严重的，所以我们每次在堆区开辟内存后，都要及时释放。

代码修改

#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);
	free(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

四、笔试题（四）

题目描述

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

题目解答

我们发现这道题，及时的释放了开辟的空间，但是这道题释放的太过着急，以至于后面依旧通过str指针访问了这段空间。这是一个非常严重和经典的问题，野指针的解引用。
那么这道题，想考察的其实是，当我们将一段空间后释放后，一定要将指向这段空间的指针设置为空指针。
那么问题又来了，虽然出现了野指针解引用的问题，但是编译器依旧编译出了程序结果。但是这不代表这段代码本身没有问题，仅仅是因为编译器没有发现这个错误。

代码修改

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

五、柔性数组

1、什么是柔性数组？

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

2、柔性数组的使用

struct type_a
{
	char a;
	int b;
	int arr[];
};

struct type_b
{
	char a;
	int b;
	int arr[0];
};

上述两种柔性数组的方式都是成立的，只是在某些编译器中只有某个柔性数组的定义版本能够通过编译。
那么我们发现，在结构体中，柔性数组的大小是不确定，那么我们应该如何计算这个结构体的大小呢？

printf("%zu",sizeof(struct type_a));

我们发现，我们打印的结果是8。而利用我们之前学过的内存对齐，简单分析一下，如下图所示：

我们发现，这个数组的内存开辟并没有将柔性数组的内存大小算进结构体的大小。
那么我们该如何使用柔性数组呢？

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

struct type_a
{
	char a;
	int b;
	int arr[];
};

int main()
{
	struct type_a* ptr = (struct type_a*)malloc(sizeof(struct type_a) + (10 * sizeof(int)));
	struct type_a* p = NULL;
	if (ptr == NULL)
	{
		perror("malloc");
		return 1;
	}
	else
	{
		p = ptr;
	}
	p->a = 'a';
	p->b = 18;
	for (int i = 0; i < 10; i++)
	{
		p->arr[i] = i;
	}

	free(p);
	p = NULL;
	ptr = NULL;
	return 0;
}

由于sizeof并不会计算柔性数组的大小，其实根本原因是，这个数组的大小是不确定的，所以没法计算。因此，在我们开辟这个空间的时候，需要在形参列表中主动写上，柔性数组所需的内存空间。

3、柔性数组的等效代码

我们发现，我们完全能够不使用柔性数组，然后达到柔性数组的作用。

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

struct type_a
{
	char a;
	int b;
	int* arr;
};

int main()
{
	struct type_a* ptr = (struct type_a*)malloc(sizeof(struct type_a));
	struct type_a* p = NULL;
	if (ptr == NULL)
	{
		perror("malloc");
		return 1;
	}
	else
	{
		p = ptr;
	}
	int* pp = (int*)malloc(10 * sizeof(int));

	if (pp == NULL)
	{
		perror("malloc");
		return 1;
	}
	else
	{
		p->arr = pp;
	}

	p->a = 'y';
	p->b = 12;
	for (int i = 0; i < 10; i++)
	{
		p->arr[i] = i;
	}

	free(p);
	p = NULL;
	ptr = NULL;
	free(pp);
	pp = NULL;
	p->arr = NULL;

	return 0;
}

我们仔细分析一下上面的代码，我们发现，两者的作用完全等效，那么柔性数组又有什么好处呢？

4、柔性数组的好处

（1）减少内存碎片

我们发现，柔性数组的代码中，结构体和柔性数组所在的空间之间是连续的。但是等效代码中的二者的空间未必是连续的。如下图所示：

而连续存储的好处在于，减少了内存碎片的存在。那么什么叫内存碎片呢？如下图所示：

这些内存碎片是指，两段内存空间之间较小的内存区。这些内存区其实几乎不太可能会用到，因为我们开辟的空间一般较大，这些内存碎片不够存储，只能白白浪费。因此，柔性数组的存在就能够减少内存碎片的存在，从而提高内存的利用效率。

（2）提高访问速度

由于利用柔性数组开辟的空间是连续的，所以当我们遍历完前两个元素后，指针直接向后偏移就能够找到柔性数组。
但是，我们的等效代码开辟的空间中，遍历完前面两个元素后，还要不断地向后寻找数组的存储空间，浪费时间。

（3）方便释放内存空间

如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给
用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你
不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好
了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。