面试题手册

注意力机制让模型在处理每个词时，能动态决定该"看"输入序列的哪些其他词。它是 Transformer 的核心，也是 BERT、GPT 等现代 NLP 模型的基础。没有注意力机制，就没有今天的大语言模型。直觉：注意力在做什么想象你在读"银行"这个词，想理解它的意思。如果上下文是"他去银行存钱"，"银行"和"存钱"的关系最密切——你的注意力会聚焦在"存钱"上。如果上下文是"他坐在河的银行边"，注意力会转向"河"。注意力机制做的就是这个：对序列中的每个位置，计算它和其他所有位置的相关程度，然后按相关程度加权聚合信息。相关程度高的权重大，低的权重小。核心计算：Query、Key、Value注意力机制借用了数据库检索的概念：Query（Q）：当前词想知道"我应该关注谁"Key（K）：每个词提供的"我是谁、我有什么信息"Value（V）：每个词实际传递的信息内容计算过程：Q 和每个 K 做点积，得到相关性分数 → 除以 √d_k（缩放，防止点积太大导致 softmax 梯度消失）→ softmax 归一化成权重 → 用权重对 V 加权求和，得到输出。公式：Attention(Q, K, V) = softmax(QK^T / √d_k) V为什么 Q·K^T 能代表相关性？因为它们是学出来的向量——训练过程中，相关的 Q 和 K 会被调整到点积更大的方向，不相关的被调到点积更小的方向。点积只是度量相似性的工具，真正的知识在 Q 和 K 的参数里。自注意力 vs 交叉注意力自注意力：Q、K、V 都来自同一个序列。模型在处理一个句子时，让每个词和句子中所有其他词交互。这是 Transformer 编码器的核心——BERT 全靠自注意力理解上下文。交叉注意力：Q 来自一个序列，K 和 V 来自另一个序列。典型场景是机器翻译：Q 来自目标语言（正在生成的词），K 和 V 来自源语言（待翻译的句子）。交叉注意力让模型在生成每个目标词时，"回头看"源句子的哪个部分最相关。多头注意力：为什么不只用一个注意力一个注意力头只能学一种关联模式。但语言中有多层关系：语法关系（主语-谓语）、语义关系（同义词）、位置关系（相邻词）。多头注意力让模型同时学多种模式——每个头独立计算 Q/K/V，最后拼接起来。Transformer 原论文用了 8 个头，GPT-3 用了 96 个头。头数不是越多越好，太小不够表达，太大参数浪费，通常和模型维度一起调。注意力为什么替代了 RNNRNN 的致命问题是顺序依赖：处理第 t 个词必须先处理完前 t-1 个词，无法并行。序列长了梯度消失/爆炸，LSTM 的门机制缓解但没根治。注意力一步到位：每个位置直接和所有位置交互，不需要逐步递归，训练时完全并行。GPU 最擅长的就是并行矩阵运算——注意力的 QK^T 计算就是大矩阵乘法，GPU 跑起来飞快。代价是 O(n²) 的计算和内存复杂度——序列长度翻倍，计算量翻四倍。这就是为什么早期 BERT 只支持 512 token，直到 FlashAttention 等优化技术出现才突破了长序列的瓶颈。实际影响注意力机制不只是 Transformer 的一个组件，它改变了整个 NLP 的范式。RNN 时代，模型架构是瓶颈；注意力时代，瓶颈变成了数据和算力。从 BERT 到 GPT-4，底层都是注意力机制，差别只在规模和训练策略。

构建 NLP 系统不只是训模型——从数据收集到线上服务，中间有大量工程决策要做。模型只是系统的一部分，很多时候瓶颈不在模型效果，而在数据处理、服务稳定性和迭代速度上。明确任务和指标先想清楚三件事：系统要解决什么问题？怎么衡量效果？兜底策略是什么？比如做一个客服意图分类系统：目标是自动识别用户咨询的类别（退款、物流、产品问题等），指标是 F1 值和人工介入率，兜底是置信度低于阈值就转人工。不要上来就想用最先进的模型，先把任务定义清楚。数据工程数据是 NLP 系统的地基，也是最容易出问题的地方。数据收集：业务日志、用户生成内容、公开数据集。优先用业务数据——它最贴近真实场景。公开数据集可以做冷启动，但分布往往和线上不一致，上线后效果会打折。数据标注：标注质量直接决定模型上限。找领域专家标注，别找众包工人——一个律师标的法律文本和一个大学生标的，质量天差地别。标注指南要写清楚边界案例（"苹果"在什么语境下是公司，什么语境下是水果），标注一致性（多人标同一批数据的重合度）至少要 85% 以上。数据版本管理：每次训练用的数据集要能追溯。DVC 或简单的 git + 文件哈希都行。线上出了问题，你得知道当时模型是用哪批数据训的。模型开发选模型：2025 年的默认选择是 BERT 系列做理解任务，GPT 系列做生成任务。小数据量（<1万条）用预训练模型微调，极少数据（<100条）考虑 few-shot prompt 或 LLM API。别从零训模型——预训练成本百万美元起步，除非你是大厂。训练技巧：学习率用 2e-5 起，batch size 小就梯度累积。早停比固定 epoch 好。保存最优 checkpoint 而不是最后一个。混合精度训练（FP16）省一半显存，几乎不损失效果。评估：离线指标（F1、BLEU、ROUGE）只是参考，必须做线上 A/B 测试。离线 F1 从 85 提到 87，线上可能完全没差别——因为测试集和真实分布不一样。服务化部署API 封装：FastAPI 是最简单的选择，异步、自动生成文档、类型检查。模型推理用 ONNX Runtime 或 TensorRT 加速，比原生 PyTorch 快 3-10 倍。批处理 vs 实时：搜索引擎这种场景可以批处理（离线算好存索引），客服对话必须实时推理（用户等不了）。实时推理要控制延迟——P99 低于 200ms 是基本要求。模型版本管理：线上同时跑多个版本，灰度切流量。出了问题秒级回滚。用 A/B 测试比较新旧版本的业务指标，别靠感觉。监控和迭代上线才是开始。监控三件事：输入分布变化（用户开始说之前没见过的话术）、模型置信度下降（突然大面积低置信度说明有新问题）、业务指标波动。建立数据飞轮：线上低置信度的样本 → 人工标注 → 补充训练集 → 重新训练。好的 NLP 系统不是一次训好的，是持续迭代出来的。每个版本的数据、模型、效果都要能追溯，这样出了问题才能定位原因。

命名实体识别（Named Entity Recognition，NER）是从文本中抽取出特定类型的实体——人名、地名、机构名、日期等。它是信息抽取的基础：搜索引擎要理解"苹果"是公司还是水果，问答系统要找到答案里的人名和地点，都靠 NER。NER 怎么定义"实体"最常用的标注体系是 BIO：B-X 表示实体 X 的开头，I-X 表示实体 X 的内部，O 表示非实体。比如"北京大学位于海淀区"标注为"B-ORG I-ORG I-ORG I-ORG O B-LOC I-LOC I-LOC"。还有 BIOES 体系多了 E（结束）和 S（单字实体），理论上更精确但实际差距不大。常见实体类型：PER（人名）、LOC（地名）、ORG（机构）、DATE（日期）、MISC（其他）。具体定义取决于业务场景——医疗 NER 需要识别疾病名和药品名，金融 NER 需要识别公司名和指标。NER 方法演进规则和词典：正则匹配+实体词典，准确率极高但覆盖率低。电话号码、邮箱这类格式固定的实体用正则就行。但新实体（新人名、新公司名）永远识别不了——这就是规则方法的根本缺陷。CRF（条件随机场）：传统方法的巅峰。它考虑整个序列的标签联合概率，避免"I-ORG"跟在"O"后面这种非法序列。CRF 的关键是特征工程——词性、前后缀、词典匹配、上下文窗口，特征设计得好效果就好。缺点是太依赖人工设计特征。BiLSTM-CRF：深度学习 NER 的经典架构。BiLSTM 自动学特征（不需要手工设计），CRF 层保证标签合法性。为什么需要 CRF？因为纯 BiLSTM 每个位置独立预测，可能出现"B-PER"后面跟"I-LOC"这种非法序列，CRF 通过学习转移矩阵约束标签之间的关系。BERT-CRF：用预训练的 BERT 替换 BiLSTM 作为编码器。BERT 自带丰富的语言知识，少量标注数据就能微调出好效果。在 CoNLL-2003 英文 NER 数据集上，BERT-CRF 的 F1 超过 92%，比 BiLSTM-CRF 高 3-5 个点。代价是推理速度慢、显存需求大。LLM 做 NER：GPT-4、Claude 可以通过 prompt 做 zero-shot NER，不需要训练数据。在通用实体上效果不错，但在专业领域（医疗、法律）和细粒度实体类型上还是微调模型更可靠。实际项目中，LLM 做 NER 的成本也比小模型高 10-100 倍。NER 的核心评估指标用精确率（Precision）、召回率（Recall）和 F1 值评估。NER 的"匹配"要求边界和类型都正确——"北京大学"标成 ORG 算对，标成 LOC 算错，只识别出"北京"也算错（边界不对）。实际项目中，精确率和召回率的取舍取决于业务：搜索引擎更重召回（别漏），法律合规更重精确（别标错）。中文 NER 的特殊挑战中文没有天然分词边界，"北京大学"可以是三个字也可以是一个实体。字级别的 NER（一个字一个字标注）比词级别更常见，因为避免了分词错误传播的问题——分词错了，NER 肯定跟着错。Lattice LSTM 就是专门解决这个问题的，它把分词信息作为额外路径融入字级别模型。

文本预处理是把原始文本变成模型能消化的输入的过程。传统 NLP 流程里这一步极其重要——垃圾进垃圾出，预处理做不好，模型再强也没用。但 LLM 时代有些变化，后面会说。预处理的核心步骤按顺序走：1. 清洗噪声：去掉 HTML 标签、URL、特殊符号、多余空格。爬虫抓的文本必做这步。用 BeautifulSoup 去 HTML 标签，正则去 URL（re.sub(r"http\S+", "", text)），没什么技术含量但很重要。2. 文本标准化：统一大小写（英文）、统一编码（UTF-8）、繁简转换（中文）。注意英文小写化会丢失一些信息——"US" 变成 "us" 就不是国家了。如果做 NER，这一步要慎重。3. 分词：把句子切成词或子词。英文按空格切就行（粗略说），中文必须用分词工具（jieba、pkuseg）。但更现代的做法是用子词分词（BPE、WordPiece），BERT 和 GPT 都用这种方式——它解决了 OOV（词表外词）问题，"unhappiness" 会被拆成 "un" + "happi" + "ness"。4. 去停用词：移除"的""了""is""the"这些高频但无实际含义的词。在搜索和分类任务中有用，但在情感分析中要小心——"not" 可能被去掉，语义就反了。LLM 时代这步基本不需要了，大模型自己能判断哪些词重要。5. 词形还原/词干提取：running → run，better → good。英文常用，中文不需要。NLTK 的 WordNetLemmatizer 做词形还原，PorterStemmer 做词干提取。词形还原更准确但更慢，词干提取更快但可能产出非词（如 "university" → "univers"）。6. 序列填充/截断：神经网络需要固定长度的输入，长的截断，短的补 padding。BERT 最大 512 token，GPT-4 可以到 128K，但填充和截断的思路一样。LLM 时代，哪些预处理还需要？分词（tokenizer）仍然需要，但已经是模型自带的了——你不需要自己 jieba 分词再喂给 BERT，直接用模型的 tokenizer 就行。清洗噪声仍然需要——LLM 也不是什么垃圾都能消化，HTML 标签和乱码照样影响效果。去停用词、词形还原、词干提取基本不需要了。LLM 的上下文理解能力足以处理这些变化，手动去掉反而丢失信息。中文预处理的特殊问题中文没有天然的分隔符，分词质量直接影响下游任务。jieba 是最常用的工具，但准确率只有 90% 左右，专业领域（医学、法律）需要自定义词典。另一个常见问题是编码——GBK 和 UTF-8 混用的数据，Python 里先统一 encode("utf-8").decode("utf-8") 处理不了就加 errors 参数忽略。实操建议别一上来就全做。先看任务——情感分析去停用词要小心，文本生成不需要去，搜索需要去。先做最小预处理（清洗+分词），跑个 baseline，看效果再加步骤。预处理步骤越多，pipeline 越复杂，出错的地方也越多。

大语言模型（Large Language Model，LLM）是用海量文本训练的超大规模神经网络。它不是被编程去"做"某件事，而是通过预测下一个 token 学会了语言的规律——结果出乎意料地，这种能力泛化到了推理、翻译、写代码、做总结等各种任务上。LLM 和传统 NLP 模型有什么本质区别传统 NLP 是"一个模型做一件事"——分类模型做分类，NER 模型做实体识别，翻译模型做翻译。LLM 打破了这个限制：同一个模型，通过不同的提示词（prompt），就能完成几十种任务。这种能力叫涌现能力——模型小的时候没有，参数过了某个阈值突然就出现了。关键在于规模效应。GPT-3 有 1750 亿参数，训练数据覆盖了互联网上几乎所有的公开文本。当你给它一个 prompt，它不是在"查表"找答案，而是在学到的语言分布上做推理。这么说不太精确，但你可以理解为：它把训练数据里的模式压缩成了参数，然后根据 prompt 激活相关的模式来生成回答。核心技术：从 Transformer 到 RLHFLLM 的底层架构是 Transformer，2017 年 Google 在《Attention is All You Need》里提出。Transformer 的自注意力机制让模型能同时看到输入序列的所有位置，不需要像 RNN 那样逐步递归，训练时可以完全并行。但光有 Transformer 不够。从原始模型到好用的 ChatGPT，中间经历了三个关键步骤：预训练：在海量文本上做 next-token prediction，学会语言的基本规律。这步烧钱最多，GPT-4 的训练成本估计超过 1 亿美元。指令微调（SFT）：用人工编写的指令-回答对微调，教模型"用户问问题你要这样答"。原始预训练模型只会续写，不会对话——SFT 让它变成了助手。RLHF：用人类偏好数据训练一个奖励模型，再用 PPO 算法优化语言模型。这一步让模型的回答更符合人类期望——更安全、更礼貌、更拒绝有害请求。LLM 能做什么理解和分析文本：读论文写摘要、从合同中提取关键条款、判断用户评论的情感倾向。这类任务 LLM 已经接近人类水平。生成内容：写邮件、写文案、写代码。代码生成是 LLM 落地最成功的场景之一——GitHub Copilot 用了 GPT 的代码能力，让开发者的编码效率提升了 30-50%。推理：链式思考（Chain-of-Thought）让 LLM 能做数学题、逻辑推理。2024 年 OpenAI 的 o1/o3 模型专门强化了推理能力，在数学和编程竞赛上接近人类顶尖水平。多模态：GPT-4V、Claude、Gemini 已经能看图、看视频、听语音。这不是简单的"图文拼接"，而是模型真正理解了视觉内容和文字内容之间的语义关系。Agent：LLM 不只是回答问题，还能调用工具、执行任务、规划步骤。这是 2024-2025 最热的方向——让 LLM 成为能自主行动的智能体，而不是被动的问答机器。LLM 的局限幻觉（hallucination）是最头疼的问题——模型会自信地编造不存在的事实。上下文窗口有限（虽然已经从 4K 扩展到了 128K 甚至 1M），长文档处理仍有挑战。推理成本高，每次 API 调用都在烧钱。对小公司来说，部署自己的 LLM 仍然不现实——7B 模型需要至少 16GB 显存，70B 需要 4 张 A100。开源和闭源的格局闭源阵营：GPT-4o、Claude、Gemini 代表了最强性能。开源阵营：LLaMA（Meta）、Mistral、Qwen（阿里）、DeepSeek 追赶速度惊人。2025 年，开源 7B 模型的能力已经接近 GPT-3.5 水平，70B 模型在某些任务上和 GPT-4 打平。对开发者来说，开源模型意味着你可以私有化部署、定制微调、不用担心数据泄露。

C 预处理器在编译前处理源代码，处理 #include、#define、#ifdef 等指令。它做的是文本替换，不是代码编译——这意味着宏没有类型检查、没有作用域，出错了很难调试。追问#define 宏有什么坑？经典陷阱：#define SQUARE(x) x * x，调用 SQUARE(1+2) 展开成 1+2 * 1+2，结果是 5 不是 9。正确写法要给参数和整体都加括号：#define SQUARE(x) ((x) * (x))。但即使这样，SQUARE(i++) 还是会让 i 自增两次——宏是文本替换，不是函数调用。能用 inline 函数就别用宏。#include 尖括号和双引号有什么区别？<header.h> 在系统目录和编译器指定路径中搜索，"header.h" 先在当前文件所在目录搜索，找不到再到系统目录。所以系统头文件用 <>，自己的头文件用 ""。这只是搜索顺序的区别，不是语法限制——用 #include <myheader.h> 也行，只是可能找不到。条件编译有哪些常见用法？三种最常用的模式：1) 跨平台适配（#ifdef _WIN32 ... #else ... #endif）；2) 调试开关（#ifdef DEBUG ... #endif，release 编译时整块代码不进去）；3) 头文件防重复包含（#ifndef MYHEADER_H ... #define MYHEADER_H ... #endif，或者 #pragma once）。条件编译的好处是编译器直接跳过不需要的代码，零运行时开销。#pragma once 和 include guard 有什么区别？#ifndef MYHEADER_H / #define MYHEADER_H / #endif 是标准 C 写法，所有编译器都支持，但要自己起宏名，可能撞名。#pragma once 更简洁，编译器用文件路径去重，不用起宏名。但 #pragma once 不是标准，理论上编译器可以不支持——实际上所有主流编译器都支持。项目里选一种统一用就行，别混着来。宏的 # 和 ## 是干什么用的？# 把宏参数转成字符串（字符串化），## 把两个 token 拼接成一个（token 粘合）：#define STR(x) #x // STR(hello) → "hello"#define CONCAT(a, b) a##b // CONCAT(var, 1) → var1在生成枚举名称、注册函数表这些元编程场景中偶尔用到，日常代码很少用。面试知道就行，别主动写这种代码。预处理和编译是什么关系？编译分四个阶段：预处理 → 编译 → 汇编 → 链接。预处理阶段只做文本操作（替换宏、插入头文件、删除条件编译排除的代码），不检查语法。所以宏写错了，报错信息可能非常难懂——因为编译器看到的是展开后的代码，不是你写的源码。gcc -E file.c 可以查看预处理后的结果，调试宏时很有用。

C 语言有 6 个位运算符：&（与）、|（或）、^（异或）、~（取反）、<<（左移）、>>（右移）。位运算直接操作二进制位，在标志位管理、数据压缩、硬件寄存器操作中不可替代。追问位运算怎么设置、清除、翻转、检查某个位？这是位运算面试的必考题，记住四个套路：#define BIT(n) (1 << n)flags |= BIT(3); // 设置第 3 位flags &= ~BIT(3); // 清除第 3 位flags ^= BIT(3); // 翻转第 3 位if (flags & BIT(3)) {} // 检查第 3 位是否为 1原理：| 遇 1 则 1（设置），& ~ 把目标位变 0 其余不变（清除），^ 遇 1 翻转遇 0 不变（翻转），& 提取目标位（检查）。异或有什么特殊性质？三个重要性质：1) 任何数异或自己为 0（a ^ a == 0）；2) 任何数异或 0 不变（a ^ 0 == a）；3) 交换律和结合律。实际应用：不用临时变量交换两个数（a ^= b; b ^= a; a ^= b;）、找数组中只出现一次的数字（其他都出现两次时，全部异或一遍结果就是那个单独的数）、简单加密。左移和右移有什么坑？左移 << 低位补 0，相当于乘以 2 的幂，没歧义。右移 >> 对无符号数高位补 0（逻辑移位），对有符号数高位补什么取决于编译器——可能补符号位（算术移位），也可能补 0。所以对有符号数做右移是未定义行为（实现定义），面试时说清楚这个区别。另外移位量不能超过类型的位宽，int x; x << 32 在 32 位 int 上是未定义行为。位运算和乘除法哪个快？现代编译器会自动把乘除 2 的幂优化成移位，手写 x >> 2 和 x / 4 生成的汇编基本一样。所以别为了"性能"写移位代替除法——可读性更值钱。唯一需要手写位运算的场景是硬件寄存器操作、协议字段编解码，这时候用位运算是表达意图，不是优化性能。位运算优先级有什么坑？位运算优先级低于比较运算符。if (flags & 0x01 != 0) 实际解析为 if (flags & (0x01 != 0))，先算不等式再位与，结果完全不对。正确写法要加括号：if ((flags & 0x01) != 0)。这也是 C 语言最常见的一类 bug。写段代码// 打包两个 8 位值到 16 位uint16_t pack(uint8_t hi, uint8_t lo) { return ((uint16_t)hi << 8) | lo;}// 解包uint8_t hi = pack(0xCD, 0xAB) >> 8; // 0xCDuint8_t lo = pack(0xCD, 0xAB) & 0xFF; // 0xAB

C 语言字符串就是以 \0 结尾的字符数组，标准库 <string.h> 提供了一组操作函数。面试重点不在背函数签名，而在理解哪些函数安全、哪些有坑、为什么有坑。追问strcpy 和 strncpy 有什么区别？哪个更安全？strcpy 无条件拷贝直到遇到 \0，目标缓冲区不够大就溢出——这是 C 语言最经典的安全漏洞来源。strncpy 限定了最大拷贝长度，但有个坑：如果源字符串比指定长度长，拷贝后不会自动补 \0，目标字符串可能不是合法的 C 字符串。正确用法：strncpy(dest, src, sizeof(dest) - 1);dest[sizeof(dest) - 1] = "\0"; // 手动保底所以 strncpy 不是"更安全的 strcpy"，而是"需要你手动补 \0 的 strcpy"。真正安全的选择是 snprintf：snprintf(dest, sizeof(dest), "%s", src); 自动截断并补 \0。strlen 和 sizeof 有什么区别？strlen 是运行时函数，从指针位置开始数到 \0 为止，返回字符串的实际长度（不含 \0）。sizeof 是编译期运算符，返回变量或类型占用的字节大小。对数组 char s[] = "hello" 来说，sizeof(s) 是 6（含 \0），strlen(s) 是 5。对指针 char *p = "hello" 来说，sizeof(p) 是 4 或 8（指针本身大小），不是字符串长度。这是面试超高频题。strtok 为什么不是线程安全的？strtok 内部用一个静态指针记住上次分割的位置，下次调用传 NULL 就从这里继续。两个线程同时用 strtok，静态指针被互相覆盖，结果就乱了。strtok_r 是可重入版本，由调用者自己维护状态指针：char *saveptr;char *token = strtok_r(str, ",", &saveptr);while (token) { // 处理 token token = strtok_r(NULL, ",", &saveptr);}strcat 有什么问题？怎么安全拼接字符串？strcat 从目标字符串末尾开始追加，不检查目标缓冲区剩余空间，溢出风险和 strcpy 一样。安全做法用 snprintf：char buf[128];snprintf(buf, sizeof(buf), "%s%s", prefix, suffix);或者用 strncat，但要自己算剩余空间：strncat(dest, src, sizeof(dest) - strlen(dest) - 1);C11 的 strcpy_s 值得用吗？理论上 strcpy_s 会检查目标缓冲区大小，溢出时返回错误而不是崩溃。但它是 C11 可选附件（Annex K），MSVC 支持但 glibc 不支持，跨平台代码用不了。实际项目中更普遍的做法是用 snprintf 或自己封装安全拷贝函数。

C 语言文件操作就四步：fopen 打开 → fread/fwrite（或 fgets/fprintf）读写 → fseek/ftell 定位 → fclose 关闭。核心原则是：打开必检查返回值，关闭前确保所有操作完成，错误用 ferror/feof 判断。追问文本模式和二进制模式有什么区别？文本模式（"r"/"w"）在 Windows 上会自动做换行转换——读时把 \r\n 变成 \n，写时把 \n 变成 \r\n。二进制模式（"rb"/"wb"）原样读写，不做任何转换。Linux/macOS 上没区别，因为换行符本身就是 \n。跨平台代码处理二进制数据（图片、结构体）时一定要用二进制模式，否则数据会被悄悄改掉。fread 和 fgets 怎么选？fgets 按行读取文本，遇到 \n 或 EOF 停止，适合逐行处理配置文件、日志。fread 按字节块读取，一次读指定大小的块，适合二进制数据（结构体、数组）或大文件批量读取。性能上 fread 更快，因为它跳过了行尾检测和字符串格式化。怎么获取文件大小？最常见的方法：跳到末尾看位置，再跳回来：fseek(fp, 0, SEEK_END);long size = ftell(fp);rewind(fp);注意这是对常规文件的做法，对管道、设备文件、标准输入不适用（fseek 可能失败）。更稳妥的方式是用 fstat（POSIX）。文件操作怎么处理错误？三个工具：ferror(fp) 检测读写错误，feof(fp) 检测是否到文件尾，perror() 把 errno 翻译成人话打印出来。常见模式：if (fread(buf, 1, size, fp) < size) { if (ferror(fp)) perror("Read error"); else if (feof(fp)) { /* 正常结束 */ }}文件指针忘记关闭会怎样？fclose 刷出缓冲区里还没写入磁盘的数据，然后释放 FILE 结构体。忘了关闭，最后一批数据可能丢失，文件描述符泄漏——进程打开文件数有上限（通常 1024），多了就 fopen 失败。长期运行的程序（服务器）里这个问题尤其严重。写段代码FILE *fp = fopen("data.bin", "rb");if (!fp) { perror("fopen"); return -1; }fseek(fp, 0, SEEK_END);long size = ftell(fp);rewind(fp);char *buf = malloc(size);fread(buf, 1, size, fp);fclose(fp);

C 语言用 malloc/calloc/realloc 在堆上分配内存，用 free 释放。和栈上变量不同，堆内存的生命周期由程序员手动控制——分配了不释放就是内存泄漏，释放了再访问就是悬空指针。追问malloc、calloc、realloc 有什么区别？malloc(size) 分配 size 字节，内容不确定（可能是垃圾值）。calloc(n, size) 分配 n×size 字节并全部清零。realloc(ptr, new_size) 在已分配内存基础上调整大小——如果新空间够大就在原地扩展，不够就另找一块新地方拷贝过去。realloc 返回新地址，旧指针可能失效，所以务必用返回值更新指针。int *arr = malloc(5 * sizeof(int)); // 5 个未初始化的 intint *arr2 = calloc(5, sizeof(int)); // 5 个全零 intint *arr3 = realloc(arr, 10 * sizeof(int)); // 扩到 10 个内存泄漏怎么排查？最直接的办法：每个 malloc 配一个 free，在代码审查时逐对核对。工具方面，Linux 下用 Valgrind（valgrind --leak-check=full ./a.out）能自动检测泄漏位置；macOS 用 Instruments 的 Leaks 模板。常见泄漏场景：函数提前 return 忘了 free、循环里分配但只保存了最后一个指针、结构体成员分配了但释放结构体时忘了先释放成员。悬空指针和野指针有什么区别？野指针是未初始化的指针，指向随机地址——声明后没赋值就用了。悬空指针是释放后没置 NULL 的指针，指向已回收的内存——free(p) 后 *p 就是悬空访问。两者都是未定义行为，但悬空指针更危险，因为那段内存可能已被重新分配，改写它会导致别的数据被无声破坏。free(p); p = NULL; 是最简单的防护。realloc 失败了怎么办？realloc 失败返回 NULL，但原来的内存块仍然有效。常见错误写法：p = realloc(p, new_size); 如果失败，p 被置 NULL，原来的内存块丢失了——既无法访问也无法释放，内存泄漏。正确做法是先用临时指针接返回值，成功再更新：int *tmp = realloc(p, new_size);if (!tmp) { free(p); return NULL; } // 失败也要善后p = tmp;实际项目里怎么管理内存？小项目靠纪律：谁分配谁释放，函数文档写清楚返回的指针要不要调用者 free。大项目用内存池——预先分配一大块，自定义分配器从中切分，统一释放时一次 free 整个池。另外 C11 引入了 _Atomic 和 aligned_alloc，但核心思路没变：malloc/free 配对，free 后置 NULL，每个分配都有明确的释放点。

位域（bit-field）让你在结构体里按位定义成员，指定每个成员占几个二进制位。主要用途是压缩存储——当多个标志位只需要 0/1 时，用位域把多个 bool 塞进一个 int 里，省内存。在网络协议解析和硬件寄存器映射中非常常见。追问位域怎么定义？占多少内存？struct Flags { unsigned int read : 1; // 1 bit unsigned int write : 1; // 1 bit unsigned int execute : 1; // 1 bit unsigned int reserved: 29; // 填满 32 bit};// sizeof(struct Flags) = 4 字节冒号后面的数字是位宽。所有位域成员加起来不能超过底层类型的总位数（unsigned int 是 32 位）。如果超过，编译器会分配下一个存储单元。位域有什么限制？三个硬限制：1) 不能取地址——&flags.read 编译报错，因为位域没有独立的字节地址；2) 不能用指针指向位域成员；3) 赋值超出范围会截断——3 位位域最大值是 7，赋值 10 实际存的是 2（10 % 8）。位域跨平台有什么坑？大端序和小端序机器上，位域的排列方向可能相反——同样是 a:4, b:4，x86 上 a 在低 4 位，PowerPC 上 a 可能在高 4 位。另外不同编译器对位域的对齐和填充规则不同。所以位域不适合做跨平台的数据传输格式，只适合同一平台内部使用。网络协议解析用位域的话，要做字节序转换。无名位域是干什么用的？两个用途：unsigned :0 强制下一个位域从新的存储单元开始（对齐）；unsigned :N（N>0）跳过 N 位不用（保留位）。协议头里经常用无名位域来对齐字段位置。struct IPHeader { unsigned int version : 4; unsigned int ihl : 4; unsigned int tos : 8; unsigned int tot_len : 16;};位域和位运算比哪个好？位运算（flags |= 1 << 3）完全可控、跨平台、可移植，但可读性差。位域可读性好（flags.read = 1），但牺牲了可控性和可移植性。在嵌入式开发中，寄存器映射用位域更直观；跨平台代码用位运算更安全。实际项目里两种都有人用，看对可移植性的要求。

可变参数函数就是参数个数不固定的函数，最典型的例子是 printf。C 语言通过 <stdarg.h> 里的四个宏来操作可变参数：va_list 声明参数指针，va_start 定位到第一个可变参数，va_arg 逐个取出参数，va_end 收尾清理。追问va_list 的底层原理是什么？函数参数从右往左压栈，所以最后一个固定参数的地址紧挨着第一个可变参数。va_list 本质上是 char* 指针，va_start 根据最后一个固定参数的地址加上它的偏移量，算出第一个可变参数的位置。va_arg 取出当前参数后，指针按类型大小前进到下一个。这就是为什么 va_start 需要传最后一个固定参数——它得知道从哪里开始找可变参数。为什么可变参数没有类型安全？C 语言的调用约定只负责把参数压栈，不传递类型信息。va_arg(args, type) 里的 type 完全由调用者自己指定——你写 va_arg(args, int) 就按 int 读，写 va_arg(args, double) 就按 double 读，编译器不做任何检查。printf 的 %d、%f 就是靠格式字符串来"约定"参数类型，格式串写错就会读到垃圾值。可变参数怎么知道自己有几个参数？没办法自动知道，必须靠约定。常见做法有三种：1) 像 printf 用格式字符串描述参数个数和类型；2) 第一个参数传数量，如 sum(3, 10, 20, 30)；3) 用哨兵值结尾，如 concat("a", "b", NULL)。va_copy 是干什么用的？复制一个 va_list 的当前状态。场景是你需要遍历两遍可变参数——第一遍计算长度，第二遍真正处理。遍历一遍后 va_list 已经指到末尾了，用 va_copy 在遍历前备份一份就能重来。va_list args, args_copy;va_start(args, fmt);va_copy(args_copy, args); // 备份// 第一遍：计算长度vsnprintf(NULL, 0, fmt, args);// 第二遍：实际格式化vsnprintf(buf, size, fmt, args_copy);va_end(args);va_end(args_copy);可变参数有什么坑？最大的是类型提升：char 和 short 会自动提升为 int，float 提升为 double。所以 va_arg(args, char) 是错的，必须写 va_arg(args, int)。另外，可变参数不能是结构体或联合体，只能传基本类型和指针。写段代码int sum(int count, ...) { va_list args; va_start(args, count); int total = 0; for (int i = 0; i < count; i++) total += va_arg(args, int); va_end(args); return total;}// sum(3, 10, 20, 30) → 60

static 在 C 语言里有三个作用：修饰局部变量让它持久化、修饰全局变量限制作用域、修饰函数限制可见性。记住一个规律——static 总是在"收窄"什么：局部变量收窄不了作用域（已经最窄了），就延长生命周期；全局变量和函数收窄可见范围到当前文件。追问static 局部变量和全局变量有什么区别？存储位置一样，都在 .data 或 .bss 段，生命周期都是程序运行全程。区别在作用域：static 局部变量只在函数内可见，全局变量整个文件可见。换句话说，static 局部变量就是"只有这个函数能用的全局变量"。int* get_counter() { static int count = 0; // 只初始化一次，值持久化 return ++count; // 每次调用 +1}static 全局变量和普通全局变量有什么区别？普通全局变量是外部链接，其他文件通过 extern 能访问。static 全局变量是内部链接，只能在定义它的 .c 文件内使用。效果就是命名隔离——多个文件可以有同名的 static 全局变量，互不冲突。static 函数有什么用？和 static 全局变量一个道理：限制到文件内部。好处是：避免和其他文件的同名函数冲突，编译器可以做更激进的内联优化（因为确定不会被外部调用）。在大型项目里，内部辅助函数都应该加 static，这是基本的模块封装手段。static 变量是线程安全的吗？不是。多个线程同时访问同一个 static 局部变量，和访问全局变量一样需要同步。C11 引入了 _Thread_local，可以给每个线程一份独立的 static 变量副本，但这不是 C89/C99 的特性。实际项目中，static 局部变量配合 mutex 是常见的线程安全模式。static 和 const 有什么区别？static 管的是作用域和生命周期（"谁能看到我""活多久"），const 管的是可修改性（"能不能改我"）。两者可以组合：static const int MAX = 100; 表示文件内可见、不可修改的常量，替代 #define 更类型安全。写段代码// counter.c — static 封装示例static int count = 0; // 文件私有，外部不可见int counter_next() { return ++count; }int counter_get() { return count; }void counter_reset() { count = 0; }// 外部只能通过这三个函数操作 count

extern 告诉编译器"这个变量/函数在别的地方定义了，别报错，链接时再找"。核心作用就是跨文件共享变量和函数声明。追问extern 声明和定义有什么区别？定义分配内存，声明只是说"有这个东西"。一个变量在整个程序里只能定义一次，但可以声明多次：extern int count; // 声明：不分配内存，告诉编译器 count 在别处定义int count = 0; // 定义：分配内存常见坑：extern int x = 10; 虽然语法合法，但一旦在头文件里这么写，多个源文件 include 后就会重复定义，链接报错。extern 声明不要带初始化。extern 和 static 为什么不能一起用？矛盾的东西。extern 说"外面能找到我"，static 说"只有我这个文件能用"。编译器不知道该听谁的，所以直接报错。不过 static 全局变量和 extern 声明可以出现在不同文件里——这时候链接器找不到 static 变量，报 undefined reference。extern "C" 是干嘛的？C++ 支持函数重载，编译器会给函数名加后缀（name mangling），比如 void foo(int) 变成 _Z3fooi。C 语言不做这个变换。当 C++ 代码要调用 C 编译的库时，得告诉 C++ 编译器"按 C 的方式链接这个函数名"：#ifdef __cplusplusextern "C" {#endif void c_library_init(); void c_library_cleanup();#ifdef __cplusplus}#endif这个模式在所有 C/C++ 混编项目的头文件里都会出现。头文件里写 extern 有什么讲究？标准做法：头文件里只放 extern 声明，.c 文件里放定义。这样多个源文件 include 同一个头文件时，各自拿到声明，链接时汇指向唯一的定义。如果头文件里直接写定义（不加 extern），多个 .c 文件 include 就会产生重复定义错误。实际项目中 extern 用得多吗？直接用 extern 声明变量的情况越来越少了，现代 C 项目更倾向用"头文件 + 函数接口"来暴露模块功能，而不是暴露全局变量。但 extern "C" 在 C/C++ 混编项目中几乎必用，比如嵌入式开发里 C++ 调 C 驱动库。写段代码// config.h — 只放声明extern int max_connections;extern const char* get_version();// config.c — 放定义int max_connections = 100;const char* get_version() { return "1.0.0"; }

restrict 是 C99 引入的类型限定符，告诉编译器"这个指针是访问该内存区域的唯一途径"，编译器据此可以做更激进的优化。说白了，restrict 就是一份承诺：你向编译器保证通过这个指针访问的内存，不会通过其他指针再访问。编译器信了，就能省掉很多冗余的内存读取。追问restrict 和普通指针有什么区别？普通指针可能有"别名"（aliasing）——多个指针指向同一块内存：void add(int *a, int *b, int *c, int n) { for (int i = 0; i < n; i++) a[i] = b[i] + c[i];}编译器不敢把 b[i] 和 c[i] 的值缓存在寄存器里，因为 a 可能和 b 或 c 指向同一块内存，每次循环都得老老实实从内存重新读取。加上 restrict 后，编译器知道 a、b、c 三者不会重叠，可以把 b[i] 和 c[i] 优化成寄存器访问，甚至做向量化（SIMD）和循环展开。memcpy 和 memmove 的区别就是 restrict 吗？对，这是最经典的例子。memcpy 的参数声明了 restrict，假定源和目标不重叠，所以可以更快地拷贝。memmove 没有 restrict，必须处理重叠的情况，所以更安全但更慢。void *memcpy(void *restrict dest, const void *restrict src, size_t n);void *memmove(void *dest, const void *src, size_t n);违反 restrict 的承诺会怎样？未定义行为。编译器不会在运行时检查，一旦你传了重叠的指针，结果不可预测——可能正常、可能数据错乱、可能优化后逻辑全变了。这是 restrict 最坑的地方：debug 模式下可能没事，release 模式下爆炸。实际项目里 restrict 常见吗？不算常见，主要出现在高性能计算、图像处理、DSP 这类对性能极度敏感的场景。标准库函数（memcpy、strcpy 等）大量使用。普通业务代码很少主动加，因为维护成本高——你要确保整个调用链都不会传入重叠指针，这个保证很难持续。写段代码// 没有 restrict：编译器保守，每次循环都从内存读void add(int *a, int *b, int *c, int n) { for (int i = 0; i < n; i++) a[i] = b[i] + c[i]; // 可能重叠，不敢优化}// 有 restrict：编译器可以 SIMD/循环展开void add_fast(int *restrict a, const int *restrict b, const int *restrict c, int n) { for (int i = 0; i < n; i++) a[i] = b[i] + c[i];}

inline关键字向编译器建议将函数调用处展开为函数体，消除函数调用开销（压栈、跳转、返回），适合短小的频繁调用函数。inline与宏的区别在于：inline函数有类型检查，支持调试（可在调试器中单步进入），不会因括号问题产生意外行为，而宏只是文本替换，没有类型安全。但inline只是建议，编译器有权忽略——递归函数、包含循环或switch的复杂函数、虚函数通常不会被内联。函数体过长时编译器也会拒绝内联，因为代码膨胀反而降低指令缓存命中率。static inline结合了内部链接性和内联建议，适合放在头文件中，每个包含该头文件的翻译单元生成独立副本，不产生链接冲突。头文件中定义inline函数需加static或inline，否则多个翻译单元包含时会产生重复定义错误。C99和C++的inline语义不同：C99中inline函数不提供外部链接定义，需要在一个翻译单元中提供extern声明；C++中inline函数允许在多个翻译单元中定义，只要定义相同即可。追问编译器如何决定是否内联？现代编译器基于启发式算法：函数体小（通常10行以内）、无循环和递归、被频繁调用则倾向内联。编译选项如-O2/-O3会提高内联积极性，attribute((always_inline))可强制内联。inline会导致代码膨胀吗？会。每次内联展开都复制一份函数体到调用点，小函数开销可忽略，大函数内联后二进制体积显著增大，可能导致指令缓存命中率下降，反而降低性能。这是编译器保守内联的主要原因。C++中inline函数和宏定义的取舍？优先inline函数。宏没有作用域、没有类型检查、参数可能被多次求值（如#define SQUARE(x) ((x)*(x))，SQUARE(i++)会i自增两次）。inline函数在所有这些方面都更安全，性能相同。C99和C++的inline链接差异是什么？C++中inline函数可出现在多个翻译单元，链接器合并为一份，不违反ODR。C99中inline函数默认无外部链接，需要某处提供extern inline定义才能被其他翻译单元使用，否则链接时可能找不到符号。

在C语言中，结构体只能定义数据成员，不能包含成员函数，默认所有成员对外可见。C++中struct和class的唯一语法区别是默认访问权限：struct成员默认public，class成员默认private；默认继承权限也同理，struct默认public继承，class默认private继承。除此之外两者功能完全等价——C++的struct同样可以有构造函数、析构函数、虚函数、继承。内存对齐方面，编译器按成员声明顺序和各自对齐要求布局，通常按最大成员对齐，可用#pragma pack或alignas调整。位域允许在结构体中以位为单位指定成员宽度，节省空间但牺牲可移植性。柔性数组是结构体末尾的未指定长度数组，配合malloc动态分配，实现变长结构体。选择原则：纯数据聚合用struct，需要封装和行为的类型用class。追问内存对齐的规则是什么？每个成员的偏移量必须是该成员对齐要求的整数倍，结构体总大小必须是最大对齐要求的整数倍。对齐要求通常等于成员大小（int为4，double为8）。对齐是为了CPU高效访问，未对齐访问在某些架构上会触发异常。柔性数组和指针有什么区别？柔性数组的内存与结构体连续分配，一次malloc搞定；指针需要额外一次分配，且内存不连续。柔性数组少一次内存间接访问，缓存更友好，但不能直接赋值和拷贝结构体。什么时候用前向声明？结构体互相引用或减少头文件依赖时使用前向声明（struct Foo;）。前向声明后只能声明指针或引用，不能访问成员或创建对象，因为编译器不知道大小。C语言中结构体可以比较相等吗？不行。C语言不支持结构体直接用==比较，需要逐成员比较或用memcmp。但memcmp在含有填充字节时可能不可靠，因为填充内容不确定。正确做法是逐字段比较。

C语言标准定义了一组预定义宏，在编译时由预处理器自动展开，主要用于调试和条件编译。常用宏包括：FILE展开为当前源文件名（字符串），LINE展开为当前行号（整数），DATE和TIME分别展开为编译日期和时间，func（C99）展开为当前函数名，STDC在符合标准的编译器下展开为1。条件编译通过#if、#ifdef、#ifndef、#elif、#else、#endif控制代码是否参与编译，核心指令是#ifdef和#ifndef，常用于头文件保护和平台适配。defined运算符可在#if表达式中检测宏是否定义，不关心其值。#pragma once是主流编译器扩展，等价于头文件保护但更简洁。宏的高级操作符中，#将宏参数字符串化，##将两个宏参数粘合为一个标识符。追问FILE展开的是源文件路径还是文件名？取决于编译器实现。GCC通常展开为编译时传入的路径，可能是相对路径也可能是绝对路径。同一份代码不同编译方式下FILE的值可能不同。#pragma once和#ifndef保护哪个更好？pragma once更简洁且不会宏名冲突，但不是C标准，极少数边缘情况（符号链接同一文件）可能误判。#ifndef是标准方案，可靠但冗长。实践中#pragma once已足够，大型项目两者结合使用。defined运算符和#ifdef有什么区别？ifdef MACRO只能检测单个宏，defined可用在#if表达式中组合逻辑判断，如#if defined(A) && !defined(B)，灵活性更高。条件编译能检测C语言版本吗？可以。C99起定义了STDCVERSION宏，值为长整型常量如199901L（C99）、201112L（C11）。通过#if STDCVERSION >= 201112L可按版本选择性编译。

指针是一个变量，存储另一个变量的内存地址，本身占用内存；引用是已存在变量的别名，与被引用对象共享同一内存地址。指针声明后可不初始化，也可以置为nullptr；引用必须在声明时绑定到一个对象，且不存在"空引用"。指针可以重新指向其他对象，引用一旦绑定就无法更改绑定目标——对引用赋值实际是修改所引用对象的值。指针支持算术运算（加减偏移、指针减法算距离），引用不支持任何算术操作。作为函数参数时，指针传递显式取地址，调用处能看出可能修改实参；引用传递语法上像值传递，但实际可修改实参，语义更隐蔽。返回值方面，返回指针要考虑空指针风险，返回引用要保证所引对象生命周期超出函数作用域，返回局部变量的引用是未定义行为。追问引用在底层是怎么实现的？编译器通常用指针实现引用，即引用变量底层也是一个地址。但C++标准不要求这样实现，只要语义正确即可。所以sizeof(引用)等于所引类型的大小，而非指针大小。什么时候用指针，什么时候用引用？函数参数优先用引用——语义更清晰，不存在空值问题。需要"可能不指向任何对象"或"需要重新指向"时用指针。C++惯用法中，函数参数用const引用避免拷贝，返回值用指针表达"可能失败"。const引用绑定到临时对象会发生什么？const引用可绑定到右值，编译器会延长临时对象的生命周期至引用的生命周期结束。这是C++中少有的生命周期延长规则，非常量引用不允许绑定到右值。引用能实现多态吗？可以。基类引用引用派生类对象，通过引用调用虚函数同样走vtable动态绑定，和指针多态行为一致。

C++虚函数通过虚函数表（vtable）和虚指针（vptr）实现运行时多态。每个含有虚函数的类，编译器会为其生成一个vtable——一个静态数组，按声明顺序存放该类所有虚函数的函数指针。每个对象实例在内存布局的起始位置持有一个vptr，指向所属类的vtable。调用虚函数时，程序通过vptr找到vtable，再从表中取出对应槽位的函数指针进行间接调用，这就实现了动态绑定。单继承下对象只有一个vptr，多继承下会有多个vptr，分别指向不同基类的vtable。虚函数调用的开销主要是一次额外的间接寻址，现代CPU分支预测能大部分消除这个代价。纯虚函数在vtable中通常放入一个抛出异常的纯虚调用占位函数，防止误调。析构函数声明为虚函数是必要的——否则通过基类指针delete派生类对象时，只会调用基类析构函数，派生类资源泄漏。追问vtable存放在内存的哪个区域？vtable是编译期生成的只读数据，通常放在.rodata段，同一类的所有对象共享同一个vtable。构造函数可以是虚函数吗？不行。构造时对象类型尚未完整，vptr还未指向最终类的vtable。构造函数执行期间，vptr逐步从基类向派生类更新，此时虚函数机制尚未就绪。虚函数调用和普通函数调用性能差距大吗？单次间接寻址开销约1-2个CPU周期，现代分支预测器命中率极高，实际差距可忽略。真正影响性能的是虚函数阻碍了编译器内联优化。为什么析构函数必须虚函数？通过基类指针delete派生类对象时，若析构非虚，只调用基类析构函数，派生类析构不执行，资源泄漏。这是C++最常见的内存泄漏来源之一。