服务端面试题手册

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++最常见的内存泄漏来源之一。

C++ 提供三种智能指针，均位于 <memory> 头文件。unique_ptr 独占所有权，不可拷贝只能移动，开销接近裸指针，是默认首选。shared_ptr 共享所有权，内部维护引用计数，最后一个持有者销毁时释放资源，拷贝和赋值增加计数。weak_ptr 是 shared_ptr 的观察者，不增加引用计数，通过 lock() 获取临时 shared_ptr 访问对象，用于打破循环引用。make_unique 和 make_shared 在单次分配中同时构造对象和控制块（后者），比单独 new 更高效且异常安全。自定义删除器允许在析构时执行特定操作，如 unique_ptr<FILE, decltype(&fclose)> 或传入 lambda 关闭文件句柄、释放 C 库资源。选择原则：独占用 unique_ptr，共享用 shared_ptr，观察用 weak_ptr，尽量避免混用裸指针持有所有权。追问makeshared 比 sharedptr(new T) 好在哪？make_shared 一次分配同时容纳对象和控制块，减少一次内存分配，且提高缓存局部性。但会延迟对象内存释放：即使引用计数归零，若 weak_ptr 仍存在，对象内存不会回收，直到 weak_ptr 也销毁。uniqueptr 的自定义删除器为什么比 sharedptr 更重？unique_ptr 的删除器类型是模板参数的一部分，影响指针类型本身，可能导致不同的 unique_ptr 类型不兼容。shared_ptr 的删除器类型在运行时擦除，不影响 shared_ptr<T> 类型，使用更灵活。智能指针线程安全吗？控制块（引用计数）的修改是原子的，shared_ptr 拷贝/析构线程安全。但访问所指对象不是线程安全的，多线程读写对象本身仍需加锁。unique_ptr 整体非线程安全，移动操作需外部同步。什么时候仍需要裸指针？不涉及所有权时用裸指针或引用作为观察者，如函数参数传递、遍历容器元素。裸指针不管理生命周期，只是访问地址，比 weak_ptr 更轻量。

C++ 程序的内存分为栈（自动管理，函数结束释放）、堆（手动 new/delete）、全局/静态区（程序生命周期）和常量区（只读）。堆内存需开发者显式申请和释放，是内存泄漏的重灾区。泄漏的常见原因：new 后忘记 delete、异常导致跳过 delete、指针被覆写丢失地址。检测工具中，Valgrind 在运行时插桩检查，AddressSanitizer（ASan）由编译器插桩，开销更小、报错更直接。现代 C++ 的核心防御手段是 RAII 原则：资源获取即初始化，将资源生命周期绑定到栈对象，析构时自动释放。智能指针是 RAII 的典型应用：unique_ptr 独占所有权离开作用域自动释放，shared_ptr 引用计数归零释放，基本取代裸 new/delete。常见陷阱包括：悬空指针（访问已释放内存）、双重 delete（同一指针释放两次）、delete 配 new[] 或 delete[] 配 new 导致未定义行为。追问栈和堆的分配速度差异为何这么大？栈分配只需移动栈顶指针，相当于一次整数加法。堆分配需遍历空闲链表查找合适块，可能触发系统调用（brk/mmap），还涉及内存碎片整理。AddressSanitizer 和 Valgrind 怎么选？开发阶段优先 ASan：编译时加 -fsanitize=address，运行开销约 2x，报错精确到源码行。Valgrind 无需重编译，但开销 10-20x，适合测试第三方二进制或无法重编译的场景。循环引用导致 shared_ptr 泄漏怎么办？将其中一方改为 weak_ptr，它不增加引用计数，打破循环。访问时通过 lock() 提升为 shared_ptr，若对象已释放则返回空。RAII 只适用于内存吗？不是。文件句柄、锁（lock_guard）、网络连接、数据库连接等有限资源都适用 RAII。核心思想是资源生命周期与对象绑定，析构函数负责释放。

模板特化允许为特定类型提供与通用版本不同的实现。全特化指定所有模板参数，为某一具体类型提供完全定制版本，全特化后的模板不再有模板参数。偏特化仅适用于类模板和变量模板，对部分参数做约束，保留剩余参数的通用性。例如 template<typename T> class A<T*> 为所有指针类型提供统一实现，T 仍为参数。函数模板不支持偏特化，只能用重载或全特化替代。SFINAE（替换失败并非错误）是模板元编程的基础规则：在模板实参替换阶段，若某个候选的替换导致类型错误，该候选被静默剔除而非编译报错。std::enable_if 利用 SFINAE，通过条件编译控制模板是否参与重载决议，是 C++17 之前约束模板的主要手段。追问全特化和偏特化的实例化优先级如何？编译器优先选择最特化的版本。全特化比偏特化更特化，偏特化比通用模板更特化。若两个偏特化同等特化则二义报错。函数模板为什么不能偏特化？函数模板支持重载，重载已能实现类似效果。若允许偏特化，与重载决议的交互会带来复杂歧义，标准因此禁止。enable_if 的 ::type 在条件为 false 时是什么？不存在。enable_if<false, T> 没有嵌套 type 类型，导致替换失败触发 SFINAE，该模板被剔除。C++14 提供了 enable_if_t 别名简化写法。C++17 的 if constexpr 能替代 SFINAE 吗？部分场景可以。if constexpr 在编译期根据条件丢弃分支代码，比 SFINAE 更直观。但它无法控制函数签名层面的重载决议，仍需 SFINAE 或 C++20 concepts。

C++11 引入移动语义解决不必要的深拷贝问题。核心在于区分左值（可取地址、具名）和右值（临时、不可取地址）。右值引用 T&& 可绑定到右值，表示该对象资源可被"窃取"而非复制。移动构造函数和移动赋值运算符通过转移资源（如指针、文件句柄）而非复制，显著提升性能。std::move 本质是无条件转为右值引用的 static_cast，并不移动任何东西，只是让重载决议选择移动版本。完美转发指函数模板将参数以原始值类别（左值/右值）传递给另一函数，借助 std::forward<T> 实现。T&& 在模板推导中是万能引用：实参为左值时 T 推导为左值引用，实参为右值时 T 推导为非引用类型，配合 std::forward<T> 按原始类别转发。引用折叠规则决定了最终类型：只有 T&& && 折叠为 T&&，其余均折叠为 T&。追问std::move 之后原对象还能用吗？可以，但处于"有效但未指定"状态。可安全赋值或析构，不应读取其值。移动后应将原对象置空或重置，保持语义清晰。万能引用和右值引用怎么区分？看 T 是否需要推导：template<typename T> void f(T&& x) 中 T&& 是万能引用；void f(std::string&& x) 中是右值引用。auto&& 也是万能引用。完美转发中为什么必须用 std::forward 而非 std::move？std::move 总是转为右值，会错误地将左值参数也转为右值。std::forward<T> 仅当 T 为非引用类型时才转为右值，保留原始值类别。引用折叠的四种情况是什么？T& & → T&、T& && → T&、T&& & → T&、T&& && → T&&。只有右值引用到右值引用折叠为右值引用，其余均折叠为左值引用。

C++ 多态分编译时和运行时两种。编译时多态通过函数重载和模板实现，编译器根据参数类型或模板实参在编译期确定调用目标，零运行开销。运行时多态依赖虚函数机制：每个含虚函数的类拥有一张虚函数表（vtable），存储各虚函数的入口地址；每个对象实例持有指向所属类 vtable 的虚指针（vptr）。调用虚函数时，通过 vptr 查 vtable 完成动态绑定，实现了根据实际对象类型调用对应版本。纯虚函数使类成为抽象类，强制子类必须实现。析构函数声明为虚函数可确保 delete 基类指针时正确调用派生类析构，避免资源泄漏。多重继承下对象可能包含多个 vptr，分别指向不同基类的 vtable。追问vtable 存在哪里？每个对象都有独立的 vtable 吗？vtable 通常在编译期生成，存于只读数据段。同一类的所有对象共享同一张 vtable，各对象只存一个 vptr 指向它。构造函数可以是虚函数吗？不能。构造时对象类型尚未完整，vptr 还未初始化完成，虚函数机制尚未就绪，无法进行动态绑定。虚函数调用一定有运行开销吗？大多数情况有一次间接寻址开销。但编译器若能在调用点确定实际类型（如通过 final 类或显式限定），会进行去虚化（devirtualization）优化为直接调用。多重继承下 vptr 怎么布局？对象按继承顺序排列各基类子对象，每个有虚函数的基类子对象各有一个 vptr。通过不同基类指针访问时，指针值可能需要偏移调整（this adjustment）。