第6章：面试挑战

从“答案能否被反例击穿”开始

面试题常把多个概念压在一句话中，例如“static 放哪”“二维数组能不能传给 int**”“auto 是不是动态类型”。高质量回答不靠背一个地址或 instruction，而是先拆维度：language rule、object lifetime、type/shape、ABI lowering、optimizer freedom 和 runtime evidence。只要更换 compiler、target 或 optimization 就失效的结论，必须标记为 implementation-specific。

先预测每道题可能出现的反例：local 不一定在 stack，static 不一定具有 external linkage，int** 不等于二维数组，auto 不在 runtime 变类型，thread_local 也不让 shared object 自动线程安全。

6.1 static、global以及local

global 通常指 namespace-scope object，描述的是 declaration location；local 指 block-scope name；static keyword 在不同 context 影响 storage duration、linkage 或 class membership。scope、linkage 和 storage duration 不能合成一个“变量位置”问题。

int externalGlobal = 1;          // namespace scope, external linkage by default
static int internalGlobal = 2;  // namespace scope, internal linkage
 
int nextId() {
    static int counter = 0;      // block scope, static storage duration
    int snapshot = counter;      // block scope, automatic storage duration
    ++counter;
    return snapshot;
}

namespace-scope and local static objects have static storage duration, but local static initialization occurs when control first passes declaration; since C++11，语言保证并发初始化协调，之后对 mutable object 的普通访问仍需 synchronization。dynamic initialization across translation units 可能产生 initialization-order problem，function-local static 或 explicit composition 可降低依赖。

automatic local 可能存 stack、register 或被优化掉；static object 可能落 data/BSS、TLS-like platform section 或被 constant-fold。source rule 决定 lifetime/identity，section name 是一次 binary evidence。

6.2 数组和双重指针

int matrix[2][3] 是一个含两行、每行三个 int 的连续 object。多数表达式中它 decay 为 pointer to row，type 是 int (*)[3]；加 1 跨过一整行。int* rows[2] 则是连续的两个 pointer objects，每个 pointer 可指向独立 allocation。int** 只表示 pointer to an int* object，不承诺后面有几行或任何连续 matrix。

void fillContiguous(int (*matrix)[3], std::size_t rows);
void fillJagged(int** rows, const std::size_t* lengths, std::size_t rowCount);

把 int[2][3] 强制转为 int** 后，callee 会把前几个 int bytes 当成 pointer value，再解引用随机 address，type/shape contract 已破坏。现代接口优先 std::span<std::array<int, 3>>、flat span + dimensions，或 owner container，使 extent 与 storage model 明确。

函数 parameter 写作 int values[] 实际调整为 pointer parameter，array extent 丢失；template reference T (&values)[N] 才可在 compile time 保留 N。回答数组题时必须指出在哪个表达式发生 decay，以及 sizeof 在 caller array 与 callee pointer 中为何不同。

6.3 指针为什么这么难

指针难不是星号语法本身，而是一个 machine-sized value 没有完整编码 nullable、owner、extent、lifetime、mutability、thread-safety 和 dynamic type。相同 T* 可表示 owning allocation、borrowed single object、array first element、optional value、memory-mapped register 或 C API handle，每种 contract 不同。

struct BufferView {
    std::byte* data;
    std::size_t size;
};

第一层分析 pointer object 自己存在哪里、活多久；第二层分析 pointee 是什么 object、extent 多大；第三层分析谁释放、何时 invalidate；第四层分析 aliases 和 concurrent accesses。double pointer 再重复一层，不能用“指针就是地址”结束。

RAII owner (unique_ptr, container)、borrow view (span, reference)、nullable wrapper 和 value type 把 contract 编进 type。raw pointer 仍适合 non-owning interoperability，但接口文档要补全 missing dimensions。sanitizer 能发现部分越界/use-after-free，却不能替代 ownership design。

6.4 auto的工作原理

auto的工作原理接近 template argument deduction，而不是 runtime dynamic typing。plain auto 通常丢弃 top-level const/reference，auto& 保留 reference binding 与 cv，auto&& 根据 initializer value category 发生 reference collapsing；decltype(auto) 使用 decltype rules，括号可能改变结果。

const int value = 7;
auto copy = value;          // int
auto& reference = value;   // const int&
auto&& forwarding = copy;  // int& because copy is an lvalue
decltype(auto) exact = (copy); // int&

braced initializer 有额外规则：auto values = {1, 2, 3} 推导 std::initializer_list<int>，但元素类型不一致会失败；auto value{1} 在现代标准中推导 int。return type deduction、generic lambda parameter 与 structured binding 又有各自 context，回答时要先写完整 declaration form。

type 在 compile time 固定，generated code 与显式写出该 type 通常等价。auto 的价值是避免重复、保留 iterator/lambda 精确类型和让 refactoring 更稳；风险是隐藏 costly copy、proxy type 或意外 initializer_list，应通过 auto&/const auto&、concept 或显式 type 表达 intent。

6.5 thread_local的工作原理

thread_local的工作原理是“一个 declaration，对每个 thread 形成独立 object identity”。访问通常通过 thread pointer/TLS base 加 module/variable offset，或调用 runtime resolver；具体 TLS model 取决于 executable/shared-library、linkage 与 platform ABI。

struct ThreadStats {
    std::uint64_t calls = 0;
};
 
thread_local ThreadStats stats;
 
void recordCall() {
    ++stats.calls;
}

不同 threads 读取 &stats 通常得到不同 virtual addresses/objects；同一 thread 多次访问得到同一实例。它减少对该 instance 的数据竞争，却不自动同步 stats 指向的 shared resources。把 TLS pointer 传给另一 thread 或在原 thread 退出后保存引用，会造成 lifetime risk。

dynamic TLS initialization 可在每 thread 首次 odr-use 前发生，destructor 在线程退出时运行；destruction order、shared-library unload 和 process shutdown 边界复杂。TLS 适合 per-thread cache、errno-like state、scratch buffer，但会隐藏 dependency、增加 memory per thread，并使 task 在 thread pool 中迁移时看见不同 state。

6.6 面试的技巧

面试的技巧不是抢答固定结论，而是在有限时间展示可校验推理。可使用四步：先复述问题并锁定 standard/platform/compiler；再画 object/type/control-flow model；然后给出一两个反例排除过度概括；最后提出 Compiler Explorer、debugger、sanitizer 或 trace 的验证方法。

1. Language: what behavior, type, lifetime, and ownership are required?
2. ABI: how are values, TLS, calls, or objects represented on this target?
3. Optimizer: what storage/calls may disappear under the as-if rule?
4. Evidence: which assembly, symbols, maps, sanitizer, or trace confirms it?

回答“local 在哪里”时先说 C++ 不承诺 stack，再给未优化 frame 和优化 register 两个例子；回答“virtual 几次访存”时先说明 vtable 是常见 ABI，实现可 devirtualize；回答“线程安全”时先定义 data race/happens-before，再谈 volatile/atomic/mutex。这种回答比背寄存器名更稳。

当题目含糊，明确假设不是逃避：例如“以下按 x86-64 SysV、Clang O2 讨论”。若不确定具体 threshold，说明“由 ABI classification 决定，我会查 ABI 或做最小反汇编”，比编造固定数字可靠。最后用边界条件收束，不无限发散。

六类题的验证清单

1. static/global/local：分别写 scope、linkage、storage duration、initialization 与 thread safety。
2. 数组和双重指针：画每层 object、extent、stride、decay point 和 owner。
3. 指针：检查 null、bounds、alignment、lifetime、alias 与 synchronization。
4. auto：逐 token 应用 deduction、cv/ref 和 value-category rules。
5. thread_local：写每线程 object count、initialization、access model 与 destruction。
6. 面试回答：给 language、ABI、optimizer、evidence 四层并提供反例。
7. 所有实验固定 compiler、version、target、standard 和 flags。
8. 结论注明可移植范围，不把一次地址或 instruction 当语言规则。

小结

• static、global以及local 必须拆成 scope、linkage、storage duration、初始化与对象数量
• 二维数组、指针数组和 int** 具有不同 shape，数组 decay 也会丢失 extent
• 指针为什么这么难，在于类型未完整编码 owner、bounds、lifetime、alias 与线程契约
• auto的工作原理是 compile-time deduction，plain auto 与 auto&/auto&&/decltype(auto) 规则不同
• thread_local的工作原理是每线程独立 object 和 TLS addressing，不是通用同步机制
• 面试的技巧是分层论证、主动限定条件、给反例并提出可复现实验
• 非空地址、固定 section、固定 register 与固定性能倍数都不是跨平台 C++ 结论