当前位置：首页 > 卖家故事 > C语言---Xiyou_Linux2023纳新题解 -----详细版

C语言---Xiyou_Linux2023纳新题解 -----详细版

时间：2024-04-21 17:05:24 来源：网络cs 作者：欧阳逸栏目：卖家故事阅读：

阅读本书更多章节>>>>

前言

🐼个人简介：一名在校的大一新生。

🎉个人wechat:lufei13308378206。

🚀本文由秋落风声，首发CSDN，此篇参考了本校Linux实验室的同学们的题解，在此表示感谢。

🔥如果有知识性的错误，或者逻辑上不清楚，欢迎加我的WeChat，来共同探讨，也期待您提供的宝贵建议。CSDN后台私信我也可以哦。

——————————————————————————————

今日（24_4_18）找书时偶然翻到这份面试题（还有其它实验室的），我能看懂了（大概）。我认为这值得写一份清晰的题解。以下仅供个人解答

这套题考察了大量C语言基础知识，重点囊括二进制，数组，函数，结构体和指针，只能作为C语言的巩固复习有限参考。比如这里不（很少）涉及文件，预处理，编译链接的有关知识。

适用对象

1. 想扎实巩固C语言的朋友们，这套题可以有效检验你们的学习成果。

2.想面试本校的Linux实验室的新大一同学们，也许你从0开始，不要畏难，也许题解你看得很吃力。我会把每道题考点罗列一遍，请抓紧时间学习。加油吧！

我使用的是windows系统下的vs2022，

可能与Linux系统中的编译器gcc有差别。

🔥
① 本题目只作为西邮 Linux 兴趣小组 2023 纳新面试的有限参考。 ② 为节省版面，本试题的程序源码省去了 #include 指令。 ③ 本试题中的程序源码仅用于考察 C 语言基础，不应当作为 C 语言「代码风格」的范例。 ④ 所有题目编译并运行于 x86_64 GNU/Linux 环境。

0.鼠鼠我啊，要被祸害了

有 1000 瓶水，其中有一瓶有毒，小白鼠只要尝一点带毒的水， 24 小时后就会准时死亡。至少要多少只小白鼠才能在 24 小时内鉴别出哪瓶水有毒？

知道二进制吧?二进制由1,0组成。 1表示 turn on(打开) 0表示 turn off(关闭）理解一： 0和1表示两种相反的状态，即这里0可以表示死掉了，1表示活着。

对于一只小白鼠喝完水，它有两种状态即0（死了） 1（活了），那么这种结果就可以说明几瓶水有毒？

2瓶，很好理解是吧，小鼠喝了其中一瓶，根据最后的状态，可以确定两瓶总有一瓶有毒。

现在有两只小白鼠，对应4种结果即00 ，01，10，11。两只都死了（00），两只都活着（11），一死一活（10 01）。可以判断几瓶呢？

4瓶，嗯，还是写一下理解吧。

设四瓶水分别为A ,B ,C, D。小鼠a,b。

a:A,B ;

b:B,C;

D瓶都不喝。

🆗相信你懂了。

三只小鼠可以证明8瓶水有毒。4只小鼠可以证明16……巴拉巴拉。

因此其实这道题就是解方程 2^n=1000;由于2^9=512,所以实际要至少10只小鼠，最多可以检测1024瓶水。

理解二：

看不明白？呃，这样吧。

1000瓶水，二进制中0表示没喝，1表示喝了。要表示1000中结果，最少要10个二进制位。2^10=1024>1000。每小鼠按照二进制编号来喝水，根据最后结果死掉的小鼠都喝的就是有毒的。

可怜的小白鼠。

考察二进制

1.先预测一下~

按照函数要求输入自己的姓名试试~

char* welcome() {// 请你返回自己的姓名}int main(void) {char* a = welcome();printf("Hi, 我相信 %s 可以面试成功!\n", a);return 0;}

都说让你返回姓名了,就返回一个字符串呗。

char* welcome() {return "eren";//后面有解释}int main(void) {char* a = welcome();//创建char* 的指针变量接受返回值printf("Hi, 我相信 %s 可以面试成功!\n", a);//打印字符串。return 0;}

要解释一下吗？

welcome 的返回类型是字符指针（char* ）,意思是要return 地址。

这里return "eren" ,看起来return 的不是字符串吗？

这个其实是常量字符串，常量字符串是字符数组，可以看作首元素的地址。这里return的就是其首元素的地址。

可以这样写吗？

char* welcome() {char* arr = "eren";//创建临时变量存储常量字符串的地址return arr;//返回这个指针。}int main(void) {char* a = welcome();printf("Hi, 我相信 %s 可以面试成功!\n", a);return 0;}

试运行两种代码，看一下结果！

char* welcome() {char arr[] = "eren";//字符数组return arr;//返回数组名，数组名即首元素的地址}int main(void) {char* a = welcome();printf("Hi, 我相信 %s 可以面试成功!\n", a);return 0;}

第一种方法结果是对的，但我不建议。

第二种写法是错的。

我说得简单一点，你认为两个“eren”一样吗？

也许你听过栈，堆，静态区。

无论是char arr[],char* arr都是welcome函数内部创建的，为局部变量，存储在栈区，函数结束就销毁了。

常量字符串存储在静态区，变量常量在程序运行期间会一直存在，不会释放，且变量常量在其中只有一份拷贝，不会出现相同的变量和常量的不同拷贝。

一之所以对，只不过是把常量字符串地址传回去，常量字符串一直都在就能打印。

二不对，字符数组在栈区上，这个“eren"拷贝了一份在数组上。出函数，内存回收，数据就不在了。

不妨自己调试观察一下。

前面变量加static修饰，或者改成全局变量就可以了。

仅展示第二种运行结果。

2.欢迎来到 Linux 兴趣小组

有趣的输出，为什么会这样子呢~

nt main(void) {char* ptr0 = "Welcome to Xiyou Linux!";char ptr1[] = "Welcome to Xiyou Linux!";if (*ptr0 == *ptr1) {printf("%d\n", printf("Hello, Linux Group - 2%d", printf("")));}int diff = ptr0 - ptr1;printf("Pointer Difference: %d\n", diff);}

1.常量字符串和字符数组中字符串在内存中存储。

2.指针解引用

3.函数递归。

4.printf的返回类型

解释一下原因。

自上而下，解读每一行代码

第一个把常量字符串首元素的地址存储在字符指针，存储在静态区。

第二个是字符数组，这里是字符串，存储在栈区。

if语句内指针解引用 *ptr0指向常量字符串的‘w'。*ptr1，（一维）数组数组名即是首元素的地址，*ptr1是字符数组（字符串）的‘w',都是字符’w'，执行if下面的语句。

最外面的printf的第一个参数是格式字符串，里面占位符%d , 换行符\n,第二个参数是另一个printf的语句，这个表达式的返回结果是什么呢？

printf的返回值是打印的字符总数。返回类型是int。

继续看第二个printf("Hello, Linux Group - 2%d", printf("")），格式字符串，和又一个printf。

再看第三个printf,总算简单了。printf("")先打印一下空字符串（打印个寂寞），返回值为0。（printf打印字符串打印\0之前的字符，并返回\0的字符总数）。自己查一下printf。

第二个等价于printf("Hello, Linux Group - 2%d",0），先打印，结果为Hello, Linux Group - 20

并返回打印字符个数23个。

第一个等价于printf（"%d",23）,打印23，返回值被忽略。

按照打印顺序 Hello, Linux Group - 2023 就是打印结果啦。

从递归来看，先递推到终点，再逐步回归。

其实栈的应用，栈的特点：先进后出，后进先出。

最后两个指针（地址）进行减法，不可以这样操作，因为它们不是在同一块空间，内存块都不同，结果为随机值（每次程序运行结果不同）。不是0，不是0，不是0！

🆗

那么今年就是2024了，懂我意思吧，哈哈！

3.一切都翻倍了吗

① 请尝试解释一下程序的输出。 ② 请谈谈对 sizeof () 和 strlen () 的理解吧。 ③ 什么是 sprintf () ，它的参数以及返回值又是什么呢？

int main(void) {char arr[] = { 'L', 'i', 'n', 'u', 'x', '\0', '!' }, str[20];short num = 520;int num2 = 1314;printf("%zu\t%zu\t%zu\n", sizeof(*&arr), sizeof(arr + 0),sizeof(num = num2 + 4));printf("%d\n", sprintf(str, "0x%x", num) == num);printf("%zu\t%zu\n", strlen(&str[0] + 1), strlen(arr + 0));}

解释一下程序输出，那先看看程序输出吧。

1. sizeof()计算数据类型的大小（单位字节），sizeof(int)计算的是int数据类型的大小。

sizeof(变量)本质也是计算变量类型的大小。

sizeof(表达式)，计算表达式结果的类型，表达式不运算。

sizeof(函数调用表达式)，函数都不调用，计算的是函数返回类型的大小。

2.strlen是专门计算字符串的大小，计算的是字符串'\0'前面的字符个数。

它只能计算字符串吗？

字符数组也适用，但用结束标志'\0'。

前面的考点就是这些。

自上而下分析每个printf和它的对应参数。

1.%zu是针对size_t的占位符，这是一种无符号整型，不了解详情自行查资料。

sizeof(*&arr),这里我提供两种理解，其一，* &均为指针运算符，互为可逆运算，即*&抵消了。等价于sizeof（arr）,计算的是整个字符数组的大小，这里是7，（自己数一下）。

其二，先看&arr的类型是什么，是指针数组(char * []),再解引用是字符数组，数组元素是七个，就是（char [7]）这个类型的大小。

sizeof(arr+0),arr+0,这里arr是首元素的地址，arr+0还是首元素的地址，类型是（char*）,大小为4字节。

sizeof(num = num2 + 4)，表达式不进行运算，表达式结果类型是什么？是short类型，注意这里num是short,num2是int。结果为2字节。

2.sprintf函数。

sprintf - C++ Reference (cplusplus.com)，如果看不明白下面的，自己网站找。

printf知道吧。参数分别是格式字符串和待打印项。格式字符串有n个占位符，printf就有n+1个参数。

那么sprintf有什么区别呢？

sprintf第一个参数是char* str，其余参数跟printf一模一样，功能是指定格式化后的字符串，拷贝到str所在的空间。（不打印了）

返回类型是int,返回写入数组的字符总数。

分析此处，先格式化字符串，以%x(16进制)将520转换到字符串，520（10进制）=208（16进制），字符串"0x208"拷贝到str数组上。返回字符串的字符总数（'\0'之前），返回值是5，那个判断真假的式子为假（0）,所以打印结果为0。

3.第三个printf,strlen(&str[0] + 1),从str[1]开始到'\0'之前的字符个数。前面分析了str存了

"0x208",这里就是从'x'开始到'\0'之前的（已标注），这里一共4个，与打印结果相符。

strlen(arr+0),从arr数组首元素开始到'\0'之前的元素。char arr[] = { 'L', 'i', 'n', 'u', 'x', '\0', '!' }；即Linux，结果为5。

考察

1.sizeof运算符的理解；

2.strlen函数的参数，返回类型，功能；

3.sprintf函数参数功能返回类型；

4.进制转换（10进制转二进制转16进制）；

补充：为什么不把sizeof这个运算符设计成函数？

1.从代码上来看更加简洁。

2.sizeof可以作用于类型，比函数灵活。

3.sizeof可以计算复杂类型的大小，比函数灵活。

4.函数调用会在栈上申请空间（函数栈帧），运行时会加大开销。

4.奇怪的输出

程序的输出结果是什么？解释一下为什么出现该结果吧~

int main(void) { char a = 64 & 127; char b = 64 ^ 127; char c = -64 >> 6; char ch = a + b - c; printf("a = %d b = %d c = %d\n", a, b, c); printf("ch = %d\n", ch);}

又要看输出结果分析吗？，先上结果吧。

掌握一下位运算就搞定了，还有进制转换。

64，127在默认为整型(int)，先转二进制补码，正整数二进制原码=反码=补码。

64：00000000 00000000 00000000 01000000

127：00000000 00000000 00000000 01111111

按位与（&）运算，任何位*0为0，乘一就为它本身。

这里相应有0变成0，没0的变成1.

64&127 =64；

按位异或（^）相同为0，相异为一

结果为 00000000 00000000 00000000 00111111（63的二进制）

64^127 =63;

移位操作符（这里☞右移操作符）

c=-64>>6,由于大多编译器采用的是算术右移，-64>>6=-1。

所以前面以%d（10进制有符号整数（signed int））打印的结果就理解了。

因为字符类型本质是整型，如果把右边当成整型即64+63-（-1）；则ch是128整型。

但由于char为有符号的char，取值范围为-128~127，取不到128的整型。见图

127-（-1）后，是-128的整型，这里规定10000000是-128的补码。所以ch的打印结果是-128。

分析完毕。

考察

1.位运算符，（尤其注意移位操作符的算术右移和逻辑右移）；

2.整数在内存中存储：二进制原码反码补码；

3.signed char的数据溢出，数据范围；

4.进制转换（十进制转二进制）；

5.乍一看就不想看的函数

“人们常说互联网凛冬已至，要提高自己的竞争力，可我怎么卷都卷不过别人，只好用一些奇技淫 巧让我的代码变得高深莫测。” 这个 func () 函数的功能是什么？是如何实现的？

int func(int a, int b) { if (!a) return b;//a=0时，递归的终止条件。 return func((a & b) << 1, a ^ b);}int main(void) { int a = 4, b = 9, c = -7; printf("%d\n", func(a, func(b, c)));}

这确实乍一看就不想看，运行结果是6，是a+b+c的结果。

自己先调试一下代码吧。观察一下func函数内部a,b的变化。

func(b,c)结果为2，是b+c的和。

func实现的是加法功能啊，没用+算术运算符，而是位运算和二进制就解决了啊。也对，cpu处理器本来就只能处理二进制的加法。

那具体原理还是简单说明一下吧。

a + b = (a ^ b) + ((a & b) << 1)。这里还是有加号啊？没错，这里用递归使得(a & b) << 1这部分为0了，用递归和位运算实现加法

你可以搜一下为什么位运算能实现加法，我在这里就不细述了。

6.自定义过滤

请实现 filter () 函数：过滤满足条件的数组元素。提示：使用函数指针作为函数参数并且你需要为新数组分配空间。

typedef int (*Predicate)(int);int* filter(int* array, int length, Predicate predicate,int* resultLength); /*补全函数*/int isPositive(int num) { return num > 0; }int main(void) {int array[] = { -3, -2, -1, 0, 1, 2, 3, 4, 5, 6 };int length = sizeof(array) / sizeof(array[0]);int resultLength;int* filteredNumbers = filter(array, length, isPositive,&resultLength);for (int i = 0; i < resultLength; i++) {printf("%d ", filteredNumbers[i]);}printf("\n");free(filteredNumbers);return 0;}

理解的要点：

1.typedef关键字这里Predicate重命名了int (*)(int) ,函数指针类型。

2.int isPositive(int num) { return num > 0; }，传递函数指针来调用函数。

3.int length = sizeof(array) / sizeof(array[0]);计算数组的元素个数。

4.main函数free释放了指针变量filteredNumbers存储地址的内存，说明这空间是动态开辟的，且filter函数要返回开辟空间的起始地址给这个变量。

int* filter(int* array, int length, Predicate predicate,
int* resultLength);

1.第一个参数传递的一维数组（传址调用），第二个参数是数组的长度（遍历原数组），第三个参数是函数指针（回调函数），第四个参数是新分配动态空间的元素个数（传址调用）。

实现filter函数的定义

1.函数指针作为参数。

2.为新数组分配空间。

int* filter(int* array, int length, Predicate predicate,int* resultLength){int* p = (int*)malloc(length*sizeof(int));//动态开辟内存，因为主函数后面用了free释放。assert(p);//断言，动态内存是否开辟失败。记得包含头文件<assert.h>int i = 0;//循环变量int count = 0;//计数变量，记录动态内存中存储的整型个数for (i = 0; i < length; i++){if (isPositive(array[i]))//回调函数{*(p + count) = array[i];//指针解引用，动态内存空间当作数组处理++count;//每存入一个数据就++。}}*resultLength = count;//返回新分配动态数组的元素个数return p;//返回动态空间的起始地址}

跟上下文填空一样。

1.动态内存malloc,calloc,realloc 和free。

2.传址调用。

7.静...态...

① 如何理解关键字 static ？ ② static 与变量结合后有什么作用？ ③ static 与函数结合后有什么作用？ ④ static 与指针结合后有什么作用？ ⑤ static 如何影响内存分配？

static关键字的特点就是静态。

static 修饰局部变量

static修饰局部变量会改变局部变量的生命周期，从存储上，改变了其在内存上的存储位置，由栈到静态存储区。

static 修饰全局变量

全局变量被修饰后改变了链接属性，由外部链接属性改变到内部链接属性，总之就是，这个全局变量只能在本源文件使用了。

static 修饰函数

函数被static修饰也有内部链接属性，这个函数称为静态函数，只能在本源文件使用，跟全局变量很像。

static修饰指针

修改指针变量的生命周期，周期和程序一样，数据可在多个函数中共享。

static 如何影响内存分配？

前面说过了。

考点即标题

8.救命！指针！

数组指针是什么？指针数组是什么？函数指针呢？用自己的话说出来更好哦，下面数据类型的含义都是什么呢？

int(*p)[10];const int* p[10];int (*f1(int))(int*, int);

数组指针即存放数组的指针，int (*p)[10],这里p先和*结合，说明它是指针。这个指针解引用对应的类型呢，即int [10],元素个数10个，元素类型为整型的数组。

指针数组即存放指针的数组，数组里面存放的指针都是同一类型，这里加const修饰表明不能对指针解引用修改对应的值。

int (*f1(int))(int*, int);

f1是变量名，f1后面着的(int)是参数类型，那么剩下int (*) (int*,int)是这个函数的返回类型。

这个函数它的参数是int类型，它的返回类型是int (*)(int* ,int)类型的函数指针。

那么这条语句什么意思，函数返回类型函数名函数参数；哦，是在进行函数声明。

函数指针是存储相应类型的函数的地址，函数名或者&函数名就是函数的地址

。另外，补充一句，知道函数指针，我们就可以通过函数指针来调用函数了。

1.函数指针，数组指针，二级指针，指针数组，函数指针数组。

2.const 关键字，你能分清楚下面的吗？

A.const char *p

B.char const *p

C.char*const p

D.const char *const p

简单记一下，const在*p左边，不能修改*p即指针变量指向的内容，如A,B

const在*p右边呢，不能修改p这个指针变量的值。 C

那两边都有呢，那都不能修改呗。 D

OVER！

9.咋不循环了

程序直接运行，输出的内容是什么意思？

int main(int argc, char* argv[]) {printf("[%d]\n", argc);while (argc) {++argc;}int i = -1, j = argc, k = 1;i++ && j++ || k++;printf("i = %d, j = %d, k = %d\n", i, j, k);return EXIT_SUCCESS;}

int main(int argc,char* argv[])

main函数的参数形式
C语言中，argc是传递给main函数的命令行参数的数量，通常情况至少为1，因为第一个参数是程序的名称。

循环内部对argc进行自增操作++argc，导致argc会增大到最大然后溢出到最小。

即argc从1--->INT_MAX->INT_MIN--->0,结束循环。

i++ && j++ || k++;

这个考察一个逻辑运算符的知识点：
逻辑运算符总是先对左侧的表达式求值，再对右边的表达式求值，这个顺序是保证的。如果左侧符合逻辑运算符的条件，就不执行右边了。就拿这个举例，后置自增运算符，先使用，再++。-1为真，使用完自增到0；执行逻辑与右侧0为假，则整体i++ && j++，结果为假(0),i,j都++了。此时i==0,j==1,由于左侧为假，逻辑或推不出结果，要执行||右侧的表达式，k=1,先使用，右侧为真，再自增，最后k=2。最终三个自增表达式都执行了。所以最终打印结果为 i=0，j=1,k=2;

10.到底是不是 TWO

#define CAL(a) a * a * a#define MAGIC_CAL(a, b) CAL(a) + CAL(b)int main(void) {int nums = 1;if (16 / CAL(2) == 2) {printf("I'm TWO(ﾉ>ω<)ﾉ\n");}else {int nums = MAGIC_CAL(++nums, 2);}printf("%d\n", nums);}

呃，报错了。可能是编译器问题，反正windows下的vs2022跑不了。

这里以下面修改后的代码为例

#define CAL(a) a * a * a#define MAGIC_CAL(a, b) CAL(a) + CAL(b)int main(void) {int nums = 1;if (16 / CAL(2) == 2) {printf("I'm TWO(ﾉ>ω<)ﾉ\n");}else {int nums = 0;//那初始化一下吧nums = MAGIC_CAL(++nums, 2);}printf("%d\n", nums);}

按此代码，总结了以下考点

1.函数宏，#define指令

2.宏替换后带来的未定义行为问题

3.块作用域，和同名变量局部优先原则。

#define 这个预处理指令可以实现定义宏，它可以将参数替换到文本。

第一个if语句中替换后为 16/2*2*2 =32 !=2,表达式为假，执行else后面的语句。

这里不要脑补加括号，也不要先计算结果再替换，因为在编译过程会处理预处理指令（#define），预处理处理所有的#define指令，将文本信息替换。

这里将#define CAL(a) a * a * a 改为 #define CAL(a) （（a） * （a） *（ a）），即使文本替换了，由于加了括号修改了优先级，也是先执行里面的运算。这个时候if语句就为真了。

else后面的 MAGIC_CAL(++nums, 2)--->替换为++nums*++nums*++nums+2*2*2。

你清楚这个表达式怎么计算吗？

如果一个表达式的运算符的优先级和结合性都清楚的话，那么表达式的结果就一定确定吗？

答案肯定不确定，++nums*++nums*++nums+2*2*2。这个你可能知道是未定义行为。

我简单说一下吧，优先级++(自增运算符) > * >+ ,但每个nums带什么值是不确定的。

比如 ++nums*++nums*++nums+2*2*2

nums初始为0，

前置自增+1,代入1;第一个nums为1了，再自增+1，带入第二个nums，第二个num位2；最后自增+1，第三个nums就为3。

则执行一种结果 1*2*3+2*2*2=14

那我也可以这样算

前置自增+1，num都代入0，再前置++两次，0*0*0+2*2*2=8，num最终为3。

虽然优先级和结合性确定了，但什么时候代入什么值，是一起带，还是执行某个运算后在带，C语言并没有规定，结果取决于编译器，所以是未定义行为。

那么最终结果num为什么是一，这里涉及到作用域，main函数内申请第一个nums是1，作用域是main函数内；第二个nums是0，在else语句花括号内，出了就销毁了。这里第一个nums在main函数实际范围大于else的花括号，其实也考察了同名变量局部优先的原则。

这里printf打印的是main函数内，else复合语句外的nums,所以打印结果为1。

11.克隆困境

试着运行一下程序，为什么会出现这样的结果？直接将 s2 赋值给 s1 会出现哪些问题，应该如何解决？请写出相应代码。

struct Student { char *name; int age;};void initializeStudent(struct Student *student, const char *name, int age) { student->name = (char *)malloc(strlen(name) + 1); strcpy(student->name, name); student->age = age;}int main(void) { struct Student s1, s2; initializeStudent(&s1, "Tom", 18); initializeStudent(&s2, "Jerry", 28); s1 = s2; printf("s1 的姓名: %s 年龄: %d\n", s1.name, s1.age); printf("s2 的姓名: %s 年龄: %d\n", s2.name, s2.age); free(s1.name); free(s2.name); return 0;}

//声明结构体struct Student {char* name;int age;};//初始化结构体void initializeStudent(struct Student* student, const char* name,int age) {student->name = (char*)malloc(strlen(name) + 1);//动态开辟内存（堆区上的空间）strcpy(student->name, name);//拷贝字符串student->age = age;//初始结构体成员}int main(void) {struct Student s1, s2;//两个结构体变量initializeStudent(&s1, "Tom", 18);initializeStudent(&s2, "Jerry", 28);//初始化两个变量s1，s2。s1 = s2;//结构体赋值//打印结构体成员printf("s1 的姓名: %s 年龄: %d\n", s1.name, s1.age);printf("s2 的姓名: %s 年龄: %d\n", s2.name, s2.age);//释放动态开辟的内存。free(s1.name);free(s2.name);return 0;}

这个要对结构体赋值有理解。

现在C语言可以进行结构体赋值结构体的操作，当然，前提是同一个结构体类型。

结构体赋值等价于，对应结构体成员的赋值。

这里s1，s2创建后在栈区申请空间，而其成员变量char* 字符指针，指向的是堆区动态开辟的内存。

进行s1=s2的赋值后，s1,s2的char* 指针（name成员）指向了相同的内存地址，即原来的s1.name地址找不着了。s1.name的动态开辟内存没有释放，会造成内存泄漏。

下面的语句都表示释放s2动态开辟空间
free(s1.name);
free(s2.name);

free多次释放同一块动态内存，也出问题了

其三，释放完内存，原有指针（变为野指针）指向空间存储未知，滥用会非法访问，需要置空。

这里出错原因分析完毕了，原因就是没有释放完动态内存，重复释放同一块空间报错了，只需创建一个临时变量存储地址就可以了。

struct Student {char* name;int age;};void initializeStudent(struct Student* student, const char* name,int age) {student->name = (char*)malloc(strlen(name) + 1);strcpy(student->name, name);student->age = age;}int main(void) {struct Student s1, s2;initializeStudent(&s1, "Tom", 18);initializeStudent(&s2, "Jerry", 28);//创建结构体中间变量来交换两个结构体struct Student s3 = s1;s1 = s2;s2 = s3;//如果不想修改s2，则忽略此句，下面改成free(s3. name)printf("s1 的姓名: %s 年龄: %d\n", s1.name, s1.age);printf("s2 的姓名: %s 年龄: %d\n", s2.name, s2.age);//这里不用担心s3.name的动态内存，因为s3.name==s1.name,释放了。free(s1.name);free(s2.name);s1.name = NULL;//释放完内存，置空处理s2.name = NULL;return 0;}

12.你好，我是内存

作为一名合格的 C-Coder，一定对内存很敏感吧~来尝试理解这个程序吧！

struct structure {int foo;union {int integer;char string[11];void* pointer;} node;short bar;long long baz;int array[7];};int main(void) {int arr[] = { 0x590ff23c, 0x2fbc5a4d, 0x636c6557, 0x20656d6f,0x58206f74, 0x20545055, 0x6577202c, 0x6d6f636c,0x6f742065, 0x79695820, 0x4c20756f, 0x78756e69,0x6f724720, 0x5b207075, 0x33323032, 0x7825005d,0x636c6557, 0x64fd6d1d };printf("%s\n", ((struct structure*)arr)->node.string);}

考点

1.结构体的内存对齐

2.联合体在内存中存储

3.大端字节序和小端字节序

x86下运行结果

结构体大小为64字节

x64下结果

结构体大小为72字节

如果你了解结构体的内存对齐和联合体的存储，那么你就往下看详解，否则请自行搜索相关内容学习或者看我写的结构体的博客。

这里是x86下的分析，下面的序号不是偏移量，可以理解为个数

上图什么意思？

struct structure* 这个结构体指针解引用能访问的内存大小，就是这个结构体指针的访问权限。

仔细观察一下main函数的arr数组，它有18个元素。每个元素是以16进制写法的整型（0x整数表示这个整数为16进制）。

这是巧合吗？

这必然是精心设计好的。

((struct structure*)arr)

不同指针的类型决定了解引用访问字节的个数。

arr是数组名，即数组首元素地址，可以认为（int*）,解引用只能访问4个字节，现在强制转化成（struct structure*），解引用由上面可知访问64个字节。

下面要以这种方式访问64节空间的整型数组。

((struct structure*)arr)->node.string)

这里相当于用结构体内存的访问形式访问arr数组。

1字节有8个二进制位，1个16进制位对应4个二进制位，所以1个字节放2个16进制位。

超过⼀个字节的数据在内存中存储的时候，就有存储顺序的问题，这就是所谓的字节序问题。

vs2022采用的小端存储（低位放低地址，高位放高地址），printf%s形式打印字符串的，即将每个字节以字符形式打印直到遇到'\0'（'\0'对应一字节16进制为00），所以打印结果为蓝色标注。

int arr[] = { 0x590ff23c, 0x2fbc5a4d, 0x636c6557, 0x20656d6f,
   0x58206f74, 0x20545055, 0x6577202c, 0x6d6f636c,
   0x6f742065, 0x79695820, 0x4c20756f, 0x78756e69,
   0x6f724720, 0x5b207075, 0x33323032, 0x7825005d,
   0x636c6557, 0x64fd6d1d };

低地址------>高地址

4d 5a |  bc 2f | 57 65 | 6c 63 | 6f 6d | 65 20 | 74 6f |20 58| 55 50| 54 20|

2c 20 | 77 65 | 6c 63 | 6f 6d |65 20 | 74 6f | 20 58|69 79| 6f 75| 20 4c|

69 6e | 75 78| 20 47| 72 6f |75 70 |20 5b | 32 30|32 33|5d 00

掏出ASCII码表16进制对一下就是如下结果：

MZ?/Welcome to XUPT , welcome to Xiyou Linux Group [2023]

13.GNU/Linux (选做)

注：嘿！你或许对 Linux 命令不是很熟悉，甚至你没听说过 Linux。但别担心，这是选做题，了解 Linux 是加分项，但不了解也不扣分哦！ 你知道 cd 命令的用法与 / . ~ 这些符号的含义吗？ 请问你还懂得哪些与 GNU/Linux 相关的知识呢~ 不会，作者还没入门Linux。（暂时没这个打算）请自行了解学习。

后期学习计划

C语言相关博客还没更完，我决定做一个系列栏目，很可惜的是，个人的时间精力有限。

有意做一个0基础入门C语言，总结一下自己入门时踩过的坑，心有余而力不足。总之日后会继续更新C语言系列，数据结构系列，c++系列，和算法系列，可能会随机更新，但最后会整理成合集。