简介：《C语言笔试大全》是一份面向准备C语言笔试、校招面试及课程复习读者的知识点整理文档，聚焦基础概念与高频考点的快速梳理。文档围绕static关键字、引用与指针差异、全局变量和局部变量在内存中的存放位置、平衡二叉树定义、堆栈溢出原因、虚函数限制、冒泡排序复杂度、float与零值比较、TCP/IP层次结构、ARP地址转换及IP地址编码等常见问题展开，并收录循环链表取余实现报数输出、switch参数类型、extern引用全局变量、do…while与while…do区别等题目，便于读者按考点查漏补缺并理解答题思路。资源包共1个doc文件，大小约225KB，内容集中、便于检索。目前已有259人学习，适合需要在较短时间内回顾C语言核心知识、熟悉笔试常见问法与易错点的读者使用。
1. 从一道 static 题说起：C 语言笔试到底在考什么
翻 C 语言笔试的真题，常会有一种很别扭的感觉：题目里每一个词你都认识——static、指针、堆栈、sizeof、冒泡排序——可一旦要求「请至少说明两种用途」或者「说说它们的区别」，笔尖就停住了。这就像考驾照时考官突然问「踩离合之前手应该放哪」，你天天开车，却从来没认真想过这件事。
C 语言笔试考的并不是偏题怪题，它考的是这门语言的「骨架常识」：一个变量到底存在内存的哪个角落、一个名字在多大的范围内有效、指针加一的时候加的究竟是几个字节、sizeof 在函数里还认不认得出数组。这些东西没有一条是只在考卷上才成立的，它们全都直接对应你写程序时遇到的各种异常现象。
搞懂它们的价值在于：你从此看报错信息不再只是猜，而是知道它大概卡在编译期还是链接期、崩在栈上还是堆上。这份资料本身是一批真题和参考答案的汇总，它适合用来对照检查自己哪块认知有缺口，但前提是你先建立起那套骨架。
2. static 到底改变了什么：一个关键字背后的三种身份
C 语言笔试里，static 大概是出镜率最高的关键字，而且特别喜欢以「请至少说明两种用途」的形式出现。它让人别扭的地方在于：同样是一个 static，加在局部变量前面、加在全局变量前面、加在函数前面，改掉的东西完全不是一回事。
加在局部变量前，变量从「函数一返回就没了」变成「活得跟程序一样久」；加在全局变量前，它从「整个工程可见」缩成「只有本文件可见」；加在函数前面，效果和加在全局变量前一样，只是管的对象换成了函数。
为什么一个关键字要身兼三职？因为 C 在描述一个名字的时候，本来就把信息拆成了两个独立维度：存在多久（存储期）和在哪儿能被看见（作用域、链接属性）。static 恰好这两个维度都能插手：对局部变量它动的是存储期，对全局变量和函数它动的是链接属性。把这条线索抓住，三种用法就不再是三件需要死记的事。
2.1 static 修饰局部变量：只认一次初值
普通局部变量的寿命很短。函数被调用时，系统在栈上给它腾一块地方；函数一返回，这块地方就作废。下次再调用，又是一份全新的，初值重新给一遍。
static 局部变量换了个住处：从栈搬到静态存储区。搬家带来的直接后果是，它在程序开始运行之前就已经建好，并且只初始化一次；函数返回时它不会消失，下次进来还是上次那个值。
#include <stdio.h> void counter(void) { int normal = 0; /* 每调用一次就重新建一份，初值永远是 0 */ static int persist = 0; /* 只在程序装载时初始化一次，之后一直活着 */ normal++; persist++; printf("normal=%d, persist=%d\n", normal, persist); } int main(void) { counter(); /* normal=1, persist=1 */ counter(); /* normal=1, persist=2 */ counter(); /* normal=1, persist=3 */ return 0; }normal每次进函数都从头来过，所以永远打印 1；persist把上一次的值带到了下一次，所以一路涨到 3。这就是很多笔试答案里说的「static 局部变量只被初始化一次，下一次依据上一次结果值」。
这里有两个容易被扣分的细节。
第一，static 局部变量的初值必须是编译期能算出来的常量表达式。static int n = rand();编译不过，因为它的初始化发生在 main 开始之前，那时候还不存在「运行」这件事，自然没法调用函数。
第二，也是踩坑最多的一条：「只初始化一次」不等于「线程安全」。static 局部变量在所有线程之间共享同一份，多个线程同时进来改它照样会出问题，该加锁还是得加锁。很多人在单线程的回调函数里用得很顺，一上多线程就出现异常，回头查半天才发现问题在这一行。
2.2 static 修饰全局变量与函数：把名字锁在本文件里
这一条是很多人记反的地方，也是最值得掰开讲清楚的地方。
一个普通的全局变量天生带着「外部链接」：别的 .c 文件只要写一句 extern 声明，就能用到它。加了 static，它变成「内部链接」——这个名字被关在当前这个源文件里面，别的文件写 extern 也找不到，链接器会当它不存在。
存储方式没变。不管是不是 static，全局变量都在静态存储区，都活到程序结束。变的是谁能够看见它。所以「static 全局变量和普通全局变量有什么区别」这道题，标准答案永远落在作用域上，而不是存储上。
/* file_a.c */ int g_count = 0; /* 外部链接：其他文件 extern 一下就能用 */ /* file_b.c */ static int g_count = 0; /* 内部链接：只在本文件可见，和 file_a 里那个毫无关系 */这段代码里有两个叫g_count的变量，它们互不干扰，也不会产生链接冲突，因为它们本来就是两个文件里两个独立的名字。这正是 static 全局变量最有用的地方：避免同名撞车。一个工程里好几个模块各自维护一个「计数器」「缓冲区」，用 static 一关，谁也碍不着谁。
资料里还给了个很实用的对照：引用一个已经定义过的全局变量，可以走「包含头文件」的路子，也可以走「写 extern 声明」的路子，而这两条路的报错时机不一样。
- 走头文件，变量名写错了，编译期就报错。编译器顺着 include 找过去，找不到这个名字，当场翻脸。
- 走 extern，名字写错了，编译期不报错。extern 本身就是一句「我保证别处有这么个东西」，编译器选择相信你。要等到链接期，链接器把所有目标文件拼起来对账，发现账上根本没这个符号，才报错。
这两种错误的差别，只有真正链接失败过一次的人才有体感：编译错误通常清清楚楚指着某一行，链接错误的提示往往是一大段符号名和未解析引用，看着就像天书。血泪经验是，遇到 extern 相关的报错，先怀疑名字拼写，再怀疑有没有把定义所在的源文件加进构建列表。
static 函数同理。在函数声明前加 static，这个函数就只在本文件内可用，别的文件调不到。好处是名字可以起得随意，不用操心冲突；代价是没法被外部单独测试，也没法被别的模块复用。所以一个函数到底要不要加 static，取决于你打不打算把它当成模块对外的接口——不打算，就加上。
2.3 全局、局部、动态申请：三个不同的住处
C 语言笔试里几乎必考一道「变量存在哪」的题，答案很干脆：
| 变量种类 | 存放位置 | 生命周期 | 谁负责释放 |
|---|---|---|---|
| 局部变量（非 static） | 栈 | 函数调用期间 | 系统自动 |
| static 局部变量、全局变量、字符串常量 | 静态存储区 | 整个程序运行期 | 系统自动 |
| malloc / calloc 申请的内存 | 堆 | 从申请到 free | 程序员手动 |
这张表值得记牢，因为它同时解释了好几个看似不相关的问题：为什么递归太深会崩（栈空间有限，一般也就几 MB）、为什么忘记 free 会漏（堆上那块没人替你管）、为什么 static 局部变量下次进来还有值（它压根不在栈上）。
注意：堆和栈这两个词经常被并排提起，但它们的运作方向正好相反。栈是系统按函数调用一层层压上去、再弹回来的；堆是一大片自由存储区，你去要一块，用完还回去。中文里都带个「堆」字（其实栈该叫「栈」，堆该叫「堆」），看混的人不在少数。
理解了这三块地盘的划分，后面关于「内存泄漏」「栈溢出」「动态数组越界」的题就有统一的解释框架了：先问这块内存在哪，再问谁该负责收尾，答案基本就出来了。
3. 指针与数组、const 与引用：那些长得几乎一样的写法
指针是 C 语言笔试的分水岭。前面那些关键字题，背一背还能应付；到了指针，题目开始要求你真的在脑子里画出内存布局。而指针难，往往不是难在「指针是什么」，而是难在一堆长得几乎一样的写法，差一个符号含义就全变了。
3.1 引用与指针：三条必须分清的硬区别
先讲一个很多人不知道的事实：引用其实是 C++ 的东西，标准 C 里根本没有。资料里会收进这道题，是因为市面上大量「C/C++ 笔试」是混着考的。意识到这一点很关键——不然被问「C 语言里怎么声明一个引用」的时候就很难答了。
抛开语言归属不谈，引用和指针的三条区别确实值得记住：
- 引用必须被初始化，指针可以不初始化。引用一旦声明就得绑定到某个对象上，没有「空引用」这回事；指针可以声明完先空着，也就有了后面那些野指针、空指针的麻烦。
- 引用初始化后不能改绑，指针可以改指向。引用是那个对象的「别名」，从此就只代表它；指针是一个装着地址的变量，你可以让它指向别处。
- 不存在指向空值的引用，但存在指向空值的指针。这也是为什么函数用引用传参时不用判空，用指针传参时几乎必须判空。
通俗地说，引用像是给变量起了个外号，指针像是记下了变量的门牌号。外号不会指错人，门牌号可能写错、可能过期、可能压根没写。
3.2 数组名不是指针：&a + 1为什么一下跳过整个数组
这是指针题里最经典的一道，几乎每份资料都有：
#include <stdio.h> int main(void) { int a[5] = {1, 2, 3, 4, 5}; int *ptr = (int *)(&a + 1); /* 加的是整个数组的长度，不是 4 个字节 */ printf("%d,%d\n", *(a + 1), *(ptr - 1)); /* 输出 2,5 */ return 0; }*(a + 1)很好理解：a 是数组首元素地址，加一跳到第二个元素，取出来是 2。
难的是&a + 1。a 和&a的数值一样，都是这个数组的起始地址，但它们的类型不一样：
a在表达式里会退化成int *，指向第一个元素，a + 1就是往前进一个int。&a的类型是int (*)[5]，也就是「指向一个含 5 个 int 的数组的指针」，&a + 1是往前进一整个数组，也就是 5 个 int。
所以ptr实际指向的是a[5]这个越界位置，ptr - 1退回一个 int，正好落在a[4]上，输出 5。参数上要记住的就是：指针加一加多少，取决于指针的类型，不取决于数值。
同样的道理能解释另一个高频错题：
void upper(char str[]) { /* 形参里的 [] 会被悄悄改写成指针 */ printf("%zu\n", sizeof(str)); /* 32 位下通常是 4，不是数组的真实长度 */ } int main(void) { char s[] = "aBcDe"; printf("%zu\n", sizeof(s) / sizeof(s[0])); /* 这里是 6，含结尾的 '\0' */ upper(s); return 0; }在函数外面，s是货真价实的数组，sizeof 能算出 6 个字节；进到函数里面，str已经退化成char *，sizeof 量到的是一个指针的大小。这个差异坑过太多人，尤其是写字符串处理函数的时候，习惯性地在函数里用sizeof(str)/sizeof(str[0])算长度，结果循环条件从一开始就是错的。
3.3 const 贴在指针的哪一边，决定了谁不能改
三行代码：
char * const p; /* 常量指针：p 的值不能改，p 指向的内容可以改 */ char const * p; /* 指向常量的指针：p 可以改指向，p 指向的内容不能改 */ const char * p; /* 和上一行完全等价，const 和 char 换个位置而已 */记忆方法是「从变量名开始往左读」：const char *p读作「p 是一个指针，指向 const char」，所以不能改的是被指向的字符；char * const p读作「p 是一个 const 指针，指向 char」，所以不能改的是 p 自己。
再配上一段经典代码，效果更明显：
#include <stdio.h> int main(void) { char str1[] = "abc"; char str2[] = "abc"; const char *str5 = "abc"; const char *str6 = "abc"; printf("%d %d\n", str1 == str2, str5 == str6); /* 输出 0 1 */ return 0; }str1和str2是两个独立的数组，各自分配了内存，地址当然不同；str5和str6是两个指针，指向同一块只读的字符串常量区，编译器没必要存两份一样的字面量，所以地址相同。这个例子同时说明了数组名和指针的区别，以及「字符串常量不可修改」的由来——你对着str5[0]赋值，改的是一块只读区域，程序会直接崩掉。
4. 五个最容易记反的结论：C 语言笔试里的常见误区
刷题刷到一定量会发现，错的题往往不是不会，而是「记成了另一个说法」。这类错误最麻烦，因为你明明有印象，答得还挺自信。下面五条是出现频率最高的混淆点。
4.1 误区一：堆栈溢出就是「垃圾没回收」
- 易混点：栈溢出、堆溢出、内存泄漏，三个词经常被当成一件事。
- 为什么混：它们都归在「内存问题」这个大类下，表现又都是程序崩掉或者行为异常，中文表述还都带个「溢」或「漏」字。
- 怎么区分：看崩在哪儿、什么时候崩。栈溢出是递归太深或者局部数组开得太大，栈空间被压爆，通常一运行就崩，崩得很干脆；堆溢出是 malloc 拿到一块内存之后越界写，可能当场崩，也可能悄悄改坏相邻数据，过很久才出问题；内存泄漏是该 free 没 free，程序越跑越胖，短时间不崩，跑上几个小时才被系统干掉。判断顺序建议是：先看崩的位置在不在递归里（栈），再看有没有越界写（堆），最后看内存占用曲线是不是只涨不跌（泄漏）。
4.2 误区二：switch 只能接 int
- 易混点：把「switch 的参数不能是实型」记成了「只能是 int」。
- 为什么混：教材上举的例子几乎全是 int，久而久之就以为别的都不行。
- 怎么区分：C 标准要求 switch 的表达式是整型，char、short、枚举都算整型，都会先做整型提升再参与匹配，所以完全合法；float、double 不行，原因不在于语法限制，而在于浮点数相等比较本身就不可靠，而且 case 标签必须是整型常量表达式。另外顺带记一句：那种
if (x > 0.000001 && x < -0.000001)的写法是明显笔误，正确的浮点判零应该是if (x > -1e-6 && x < 1e-6)，两个边界方向要一致。
4.3 误区三：函数里的 sizeof 还能测出数组大小
- 易混点：以为
sizeof(arr)/sizeof(arr[0])在哪儿都管用。 - 为什么混：在定义数组的那个函数里它确实好用，很多人就把它当成了通用写法复制到别处。
- 怎么区分：看 arr 是不是形参。数组作为函数参数时会退化成指针，sizeof 量到的是指针大小，不是数组长度。解决办法有两个：要么在调用方算好长度再传进来，要么约定一个结束标记（比如字符串的
'\0'），要么用结构体把数组包起来传。
4.4 误区四：宏SQUARE(a)遇上a++只加一次
- 易混点：把宏当成函数，以为参数只求值一次。
- 为什么混：调用写法一模一样，看起来就像个函数。
- 怎么区分：宏是预处理阶段的文本替换。
#define SQUARE(a) ((a)*(a))遇到SQUARE(a++)会展开成((a++)*(a++))，a 被加了两次，而且两次自增之间没有序列点，属于未定义行为，不同编译器的结果可能不一样。宏的参数要么保证没有副作用，要么改用 inline 函数——C 里用static inline，C++ 里用inline，这正是资料里「频繁使用的短小函数在 C 和 C++ 中分别怎么实现」那道题的答案。
4.5 误区五：全局变量和局部变量重名时，用::拿全局的
- 易混点：把 C++ 的作用域解析运算符当成了 C 的语法。
- 为什么混：C 和 C++ 的题混在一起考，而
::在 C++ 里确实能干这件事。 - 怎么区分：C 语言里没有
::。局部变量会屏蔽同名的全局变量，在函数内直接写名字拿到的永远是局部那个。想用全局的，要么给全局变量换个名字，要么在函数开头先把全局值取出来存到一个别名变量里，要么通过一个专门的访问函数去取。这条同样是资料混编带来的坑，看到涉及::的题目，先确认它问的是 C 还是 C++。
5. 从冒泡到平衡树：笔试里的数据结构为什么总爱考这几个
C 语言笔试往后半段走，就会从语法转向数据结构。奇怪的是，考来考去就那么几个：冒泡排序、平衡二叉树、栈与队列、链表找环。这不是出题人偷懒，而是这几个点各自代表一类思维方式，用最小的篇幅就能测出你有没有真正理解，而不只是记住了。
5.1 冒泡排序的 O(n²) 是怎么数出来的
冒泡排序的思路很朴素：从头到尾扫一遍，相邻两个元素比大小，大的往后挪，扫完一轮最大的就沉到了末尾；然后对前面剩下的部分重复这个过程。
复杂度是数比较次数数出来的。第一轮比较 n-1 次，第二轮 n-2 次，一直到 1 次，加起来是(n-1) + (n-2) + ... + 1 = n(n-1)/2，去掉常数和低阶项就是 O(n²)。交换次数在最坏情况下也是这个量级。
很多人只记得结论「冒泡是 O(n²)」，但笔试真正想确认的是你能不能自己推出来。因为一旦会推，你就能解释为什么快速排序平均是 O(n log n)——它每一轮把问题分成两半，递归深度是 log n，每层的工作量是 n。
5.2 平衡二叉树：先看「深度差」，再递归看子树
定义只有两句话：左右子树都是平衡二叉树，且左右子树的深度差的绝对值不大于 1。
这两句话是有顺序的。很多人判断的时候只看根节点左右深度差，差不超过 1 就判平衡，结果栽在子树里——根节点平衡不代表子树也平衡，定义要求每一棵子树都满足。所以正确的判断流程是递归的：对每个节点，先算左右子树高度，差值超过 1 直接判否；没超过，再递归检查左右子树。
举个能帮助记住的例子：一棵树根节点左边挂着一长串、右边挂着一长串，两边总深度可能刚好相等，但左边的内部早就歪得不成样子了。只看根节点会判它平衡，实际不是。
平衡的意义也值得说一句：普通二叉搜索树的查找效率取决于树的形状，运气不好退化成链表就是 O(n)；保持平衡能把高度压在 O(log n)，查找也就稳定在 O(log n)。这是「为什么要有平衡树」的答案，比背定义有用得多。
5.3 两个栈拼一个队列，以及循环链表报数
栈是后进先出，队列是先进先出，方向相反。用两个栈拼出一个队列，是这类题里最漂亮的一个：
/* 思路示意：A 栈负责入队，B 栈负责出队 */ void enqueue(Stack *A, int value) { push(A, value); /* 新元素一律压进 A */ } int dequeue(Stack *A, Stack *B) { if (is_empty(B)) { /* B 空了才从 A 搬 */ while (!is_empty(A)) { push(B, pop(A)); /* 从 A 弹出再压进 B，顺序正好倒过来 */ } } return pop(B); /* 从 B 弹出就是最早进来的那个 */ }关键在于「B 空了才搬」这个条件。每个元素最多被搬一次，所以入队和出队的平摊复杂度都是 O(1)。如果每次出队都搬一遍，复杂度立刻退化成 O(n)，这是这道题最容易翻车的地方。
另一道常见的实战题是循环报数：n 个人围成一圈，从 1 开始数，数到 m 的人出列，然后从下一个人继续数，直到所有人出列。标准解法是用循环链表模拟，每次走 m-1 步然后删掉当前节点。如果不想手写链表，用数组加一个「当前位置」的下标配合取余也能做，pos = (pos + m - 1) % remaining这一行就是整个算法的核心，取余的作用是把走到末尾的下标自动绕回开头。
6. 什么时候该刷这份题库，什么时候该合上它
这份资料的价值很明确：它是一份高密度的考点索引。你拿它对照自己，能很快看出哪些概念是「听过但说不清」的，哪些是「压根没意识到是个考点」的。做题时发现自己卡在 static 的三种用法上，回头去把存储期和链接属性捋一遍，这个来回效率很高。
它不适合的场景同样明确：
| 你的目标 | 这份资料合适吗 | 更适合的做法 |
|---|---|---|
| 面试/笔试前突击，查漏补缺 | 合适 | 按章节过一遍，把答不上来的标出来 |
| 想系统学 C 语言 | 不合适 | 需要成体系的教材和大量动手练习 |
| 想搞懂某个概念为什么这样设计 | 部分合适 | 资料给结论，原理还得自己顺着推 |
| 想提升工程能力、写出能维护的代码 | 不合适 | 去读真实项目的代码，写有测试的程序 |
最需要警惕的一点是：这些答案里混着 C 和 C++ 的内容，还夹着个别笔误。引用、::、虚函数、虚表这些都是 C++ 的东西，被收进「C 语言笔试」的资料里很正常，因为现实中大量岗位的笔试卷子就是混着出的。但你得清楚哪条属于哪边，否则被追问一句「C 里怎么实现引用」就答不上来了。至于笔误，像浮点判零那个不等号方向反了的例子，照抄进答题纸上是会扣分的——看到明显不对劲的结论，宁可自己动手编译跑一遍。
我自己的习惯是，每次拿到这类题库，先不急着背答案，而是挑十道题出来，在编辑器里把代码敲一遍、跑一遍、把结果和答案对一遍。对不上的地方，不是答案错了，就是我某一处理解错了，两种情况都值得记下来。从那以后我每次复习这类资料，都强制走一遍「先跑再背」的流程，因为只有跑过的结论才会在需要的时候自己冒出来。希望帮到你。
本文还有配套的精品资源，点击获取
