C++ 高频知识体系 · 导航目录

这是本知识库的总目录，目标是把 C++ 从入门讲到能独立做性能优化和工程架构。每一篇都能独立看懂：示例全部真编译真运行过，涉及性能与内存的地方都写清了「哪种写法更优、为什么」。

怎么用：第一次来，按体系顺序从前往后读——前面的体系是后面所有内容的地基；已经有基础了，直接跳到你关心的那一节。每篇都是独立文章，点标题直接进。

总览

类型与基础语法

• 《auto 类型推导到底推成了什么：与 decltype 的差异》 —— auto 不是把右边类型原样抄过来，它会丢掉顶层 const 和引用；decltype 则追求表达式的真实类型。
• 《const 该放哪：从顶层 const 到 const 成员函数》 —— const 放在 * 左边还是右边天差地别。
• 《constexpr / constinit / consteval：编译期常量三兄弟怎么选》 —— constexpr 保证编译期常量，constinit(C++20) 保证静态初始化避免跨 TU 初始化顺序陷阱，consteval(C++20) 强制编译期求值。
• 《nullptr 取代 NULL 和 0：空指针的三种写法和唯一正确解》 —— NULL 在多数实现里就是 0，导致重载和模板推导选错类型；nullptr 是独立的 std::nullptr_t 类型，能正确选中指针版本。
• 《enum class 为什么优于裸 enum：作用域、类型安全与内存实测》 —— 裸 enum 的枚举名会泄漏到外层作用域、还会隐式转换成 int，导致跨枚举误比较、类型信息丢失。
• 《static 的五种含义：同一个关键字，五种不同的事》 —— C++ 里 static 一个关键字身兼五职：局部静态变量、全局静态（内部链接）、静态成员变量、静态成员函数、类内 inline static constexpr 常量。
• 《inline 的真面目：从函数内联到 C++17 inline 变量》 —— 90% 的 C++ 新手都以为 inline 就是「让编译器把这个函数内联展开」，于是一通加 inline 想加速。
• 《四种命名类型转换该用哪个：static/dynamic/const/reinterpret_cast》 —— C++ 给了四种命名类型转换——static_cast、dynamic_cast、const_cast、reinterpret_cast，各有适用边界，比 C 风格的 (T)x 安全得多。

引用、指针与内存基础

• 《左值、右值、纯右值、将亡值：值类别入门》 —— 每个 C++ 表达式都带一个隐形「值类别」标签，它决定了能不能取地址、能不能移动、该调用哪个重载。
• 《左值引用、右值引用与万能引用：引用折叠全解》 —— 右值引用（T&&）是引用不是「右值」，具名右值引用变量本身是左值——这是最易混的一点。
• 《指针还是引用：什么时候必须用指针》 —— 别再纠结「引用是不是永远比指针好」。
• 《裸指针还能不能用：不拥有与拥有的边界》 —— 网上常说「裸指针是坏味道」，但 C++ Core Guidelines 的观点是：裸指针本身没错，错在用它表达所有权。
• 《size_t 与 int 混用陷阱：有符号无符号比较与整数提升》 —— 为什么 -1 > 0u 在 C++ 里是 true？这篇用真实编译输出讲清有符号数被转成无符号后补码变巨大的机制，整理整数提升（integral promotion）与寻常算术转换（usual arithmetic conversions）规则表，复现 for(int i=0;i<v.size();++i) 的经典 -Wall 警告和空容器 size()-1 下溢，并给出 std::ssize / std::cmp_less（C++20）等四种规避写法及对比。
• 《指针算术与数组退化：数组名到底是不是指针》 —— 数组名在大多数表达式里会退化成指向首元素的指针，但它本身不是指针：sizeof(arr) 是整个数组的字节数，&arr 的类型是 int(*)[5]。
• 《二级指针与指针引用：为什么改指针要传 T*&》 —— 想在函数里修改调用方的指针本身（比如从函数里“种”出一个堆对象的所有权），必须传 T*&（指针的引用）或 T**（二级指针），因为按值传 T* 只改了副本。

对象生命周期、拷贝与移动

• 《对象存储期全解：automatic / static / dynamic / thread》 —— 存储期（storage duration）决定对象活多久，作用域（scope）决定名字在哪儿可见，两者是正交概念——很多人把它们混为一谈。
• 《new/delete 与 malloc/free：为什么绝对不能混用》 —— 这篇用实跑代码对比 new/delete 与 malloc/free 的本质差异——前者管「内存+构造/析构」，后者只管「内存」。
• 《对象构造与析构顺序全解：声明顺序、继承链与逆序析构》 —— 这篇用实跑代码把 C++ 对象的构造/析构顺序彻底讲清：成员按声明顺序初始化（与初始化列表书写顺序无关）、基类先于派生类构造、析构完全逆序、局部对象出作用域逆序、静态局部在 main 之后逆序析构，以及经基类指针删除时为什么基类析构必须是 virtual。
• 《Rule of Three/Five/Zero：六个特殊成员与编译器的隐式生成陷阱》 —— 这篇系统梳理 C++ 的六个特殊成员函数（默认构造、析构、拷贝构造、拷贝赋值、移动构造、移动赋值），讲清 Rule of Three→Five→Zero 的演进，并用实跑代码揭示一个致命性能陷阱：只要声明了析构函数，隐式移动操作就不再生成，std::move 会悄悄退化成拷贝。
• 《拷贝构造与拷贝赋值：调用时机、深浅拷贝与复制消除》 —— 这篇用实跑代码厘清 C++ 拷贝构造（copy constructor）的三个触发场景、拷贝构造与拷贝赋值的本质区别、拷贝初始化与直接初始化的差异、复制消除（copy elision）如何让拷贝凭空消失，以及浅拷贝为何导致 double free、深拷贝如何避免。
• 《手写一个安全的 String 类：把深浅拷贝讲透》 —— 从一个会 double free 的浅拷贝反例入手，用 Rule of Five 写出拷贝安全、移动高效的 String 类。
• 《C++ 移动语义：std::move 其实什么都没搬》 —— 从「std::move 之后原对象怎么还在」这个疑问切入，讲清左值/右值/右值引用、std::move 的本质、移动构造该怎么写。
• 《移动构造与移动赋值：把资源偷过来》 —— 聚焦「怎么正确实现移动操作」而非 std::move 本身。
• 《RVO 与 NRVO：为什么 return std::move(x) 是反优化》 —— 复制省略是标准允许改变程序可观察行为的少数情况之一。

智能指针与资源管理

• 《unique_ptr 完全指南：独占所有权与零开销》 —— 讲透 std::unique_ptr 的独占所有权语义、make_unique/get/release/reset/swap、release 与 reset 的区别、自定义删除器对 sizeof 的影响（无状态删除器零开销、函数指针删除器多一个机器字），以及数组特化与作为函数参数/返回值表达所有权转移。
• 《shared_ptr 完全指南：引用计数、控制块与开销》 —— 讲透 std::shared_ptr 的共享所有权语义、控制块（control block）里究竟存了什么、use_count 为什么只能调试用、为什么它有两个指针大（sizeof 实测 16 字节）、拷贝为何涉及原子操作、解引用到底有没有多一次间接寻址，以及没有共享需求时它只是白付开销——附与 unique_ptr 的对比表、别名构造实测和内存布局 ASCII 图。
• 《weak_ptr 详解：打破 shared_ptr 循环引用》 —— 讲透 std::weak_ptr 如何打破 shared_ptr 的循环引用导致的内存泄漏。
• 《enable_shared_from_this：类内部安全拿到 shared_ptr》 —— 讲透为什么不能直接 std::shared_ptr(this)——它会让同一个对象拥有两个控制块，析构时被 delete 两次（double free）；正确解法是继承 std::enable_shared_from_this 再用 shared_from_this()。
• 《make_unique / make_shared vs 裸 new：三个理由与反直觉权衡》 —— 讲透为什么优先 std::make_unique / std::make_shared 而非裸 new：①异常安全（分配与接管被拆开时 g() 抛异常会泄漏）②类型名只写一次 ③make_shared 只做一次分配、缓存局部性更好。
• 《自定义删除器：让智能指针管住 FILE*、socket 与数据库连接》 —— 讲清为什么非 new 出来的资源（FILE*、socket、数据库连接）不能用默认删除器释放；对比三种自定义删除器写法（函数指针、无状态 lambda/仿函数、std::function），并用 sizeof 实测揭示关键性能点——无状态删除器被空基类优化（EBO）吃掉、unique_ptr 仍是 1 个指针，而函数指针删除器会让它变成 2 个指针；顺带讲 shared_ptr 的删除器存进控制块、不影响其大小。
• 《shared_ptr 的线程安全边界：计数安全不等于对象安全》 —— 拆开 shared_ptr 线程安全最常见的误区——引用计数是原子的，但它指向的对象不是；多线程同时读写同一个 shared_ptr 实例本身仍是数据竞争。

类与对象设计

• 《构造函数详解：默认、委托、转换与 explicit 到底写在哪》 —— 把构造函数拆成四件事讲透——默认构造的隐式生成、= default 与 = delete 的用法、委托构造避免初始化逻辑重复、转换构造函数与 explicit 的落点。
• 《成员初始化列表与初始化顺序陷阱：按声明顺序，不是书写顺序》 —— 成员初始化的铁律是「按声明顺序初始化，与初始化列表的书写顺序无关」，顺序写反就是未定义行为的温床。
• 《friend 友元：什么时候值得破坏封装》 —— 友元（friend）是 C++ 里唯一能绕过 private 访问控制的受控后门。
• 《运算符重载入门：算术、比较、下标、函数调用》 —— 运算符重载（operator overloading）只是给函数调用换了个语法糖。
• 《运算符重载该写成成员还是非成员》 —— 运算符重载写成成员还是非成员，直接决定表达式能不能对称。
• 《静态成员与 Meyers 单例》 —— 静态成员变量与静态成员函数的语义（共享、无 this、可当回调），C++17 的 inline static 如何免掉类外定义，再到 C++11 起标准保证的「局部静态变量线程安全初始化」—— Meyers 单例正是它的一行应用。
• 《mutable 与逻辑常量性：const 成员函数里到底什么能改》 —— const 成员函数承诺不修改对象的可观察状态，但缓存、互斥量、统计计数这类「内部状态」改了不影响语义。
• 《pimpl 惯用法：屏蔽实现、减少编译依赖的一层间接》 —— pimpl（pointer to implementation）把类的私有实现藏到 .cpp 里，头文件只留一个 unique_ptr 指向前置声明的 Impl。

继承、多态与虚函数

• 《虚函数与虚函数表：一次调用到底跳了几次》 —— 虚函数的动态绑定靠每个对象隐藏的 vptr 和每类一份的 vtable。
• 《虚析构函数：不加会发生什么》 —— 通过基类指针 delete 派生对象时，基类析构非 virtual 就是未定义行为，典型表现是派生类析构被跳过、资源悄悄泄漏。
• 《override 与 final：把多态错误拦在编译期》 —— 派生类想重写基类虚函数却写错签名，编译器一声不吭，运行时多态静默失效——这是最隐蔽的 bug 之一。
• 《纯虚函数与抽象类：接口该怎么设计》 —— 纯虚函数定义抽象类、强制派生类实现接口，但两个反直觉点常被忽略：纯虚函数可以有定义（类外），纯虚析构函数必须给定义否则链接失败。
• 《多重继承与菱形继承：虚继承到底解决了什么》 —— 一个类继承两个基类，C++ 允许；但两个基类若有共同祖先，就长出菱形——D 里出现两份 A 子对象，访问成员直接编译报错。
• 《对象切片（object slicing）：多态失效的隐形杀手》 —— 把派生类对象按值赋给基类对象、按值传给基类参数、塞进 std::vector，派生类特有的那部分会被静默「切掉」——重写的虚函数不再被调用、数据成员凭空消失，编译器一声不吭。
• 《CRTP 编译期多态与静态接口：没有虚函数也能多态》 —— CRTP（Curiously Recurring Template Pattern）用「派生类把自己作为基类模板参数」的技巧实现静态多态，没有 vptr、调用可被内联。

模板与泛型编程

• 《函数模板与类模板：从最简写法到参数推导规则》 —— 从最朴素的 template 讲起，覆盖函数模板的实参推导（按值传时 T 会丢掉顶层 const 与引用，规则与 auto 一致）、显式指定模板参数、多个模板参数、类模板显式指定与 C++17 的 CTAD 类模板参数推导、默认模板参数、非类型模板参数（编译期常量），以及「为什么模板成员函数要放头文件」。
• 《模板特化与偏特化：为特定类型开小灶》 —— 全特化（template<> class A）与偏特化（template class A<T*> 只特化部分参数）的区别与适用场景；重点讲清「函数模板不能偏特化、只能用重载模拟」这个高频踩坑点；说明特化必须在使用前可见（否则未定义行为），并以 std::hash 特化、类型萃取等经典应用收尾，最后务实指出 C++17 的 if constexpr 与 C++20 Concepts 已取代大量旧特化技巧。
• 《SFINAE 入门：替换失败不是错误》 —— SFINAE（Substitution Failure Is Not An Error）指模板参数替换失败时，编译器只是把该候选从重载集里静默剔除，而不是报编译错误。
• 《type_traits 常用工具速查：查询类、变换类与 _v / _t 后缀》 —— 把 <type_traits> 拆成查询类（is_integral / is_same / is_base_of / is_constructible / is_convertible）与变换类（remove_reference / decay / enable_if / conditional）速查，讲清 C++17 的 _v / _t 后缀为什么比 ::value / ::type 好用，用 static_assert 实证 std::decay 的去引用、去 cv、数组转指针三步。
• 《可变参数模板与 C++17 折叠表达式：从递归展开到一行求和》 —— 从 C++11 时代的递归展开讲起，说清可变参数模板（variadic template）为什么必须有基准情形与递归步；再进入 C++17 折叠表达式（fold expression），用对照表与求值顺序图讲清一元左/右折叠、二元左/右折叠四种形式，用求和、打印、逻辑与三个例子对比递归版的代码量与编译期开销，并用真实输出实证空参数包下 && 返回 true、|| 返回 false、逗号折叠返回 void 这个细节。
• 《if constexpr：C++17 编译期分支，为什么它能取代 SFINAE》 —— if constexpr 与普通 if 的本质区别在于「未被选中的分支不实例化」，这正是它能取代 SFINAE 的关键。
• 《CTAD 与推导指引：C++17 类模板参数推导怎么用、哪里会踩坑》 —— C++17 的 CTAD 让 std::pair、std::vector 这类类模板不用再写模板参数。
• 《std::forward 到底转发的是什么：完美转发与四类转发失败》 —— std::forward(arg) 转发的既不是对象也不是引用，而是实参原本的值类别（value category）。

STL 容器

• 《vector 扩容策略与迭代器失效全解》 —— vector 的 size 与 capacity 为什么分开、push_back 触发的扩容到底做了什么、迭代器在哪些操作后会失效——这篇用三指针内存布局图讲清 vector 的结构，用真跑的地址变化和元素拷贝计数实证扩容与 reserve 的差别，给出迭代器失效场景全表，并对比 emplace_back 与 push_back 的开销，最后落到一个完整的 erase-remove 示例。
• 《std::string 高频用法与 SSO 小字符串优化》 —— 为什么创建一个小字符串完全不碰堆、string 对象里那 32 个字节都装了什么？这篇用内存布局图和「数据地址是否落在对象内部」的真跑布尔值实证 SSO（小字符串优化），讲清 append/substr/find/compare/c_str/starts_with 的高频用法，指出 substr 会拷贝而 string_view 零拷贝的性能陷阱，并用一个自定义 streambuf 数出 ‘\n’ 与 std::endl 在刷缓冲上的差别。
• 《std::array 与裸数组、vector 怎么选》 —— std::array 是裸数组的零开销封装——sizeof 完全相等、没有额外间接、size() 还是 constexpr，但它补上了裸数组最要命的三个短板：长度不丢失、可以整体拷贝赋值、能当值传递。
• 《list 与 forward_list：链表真的比 vector 快吗》 —— 用计数分配器和实测耗时把 std::list / std::forward_list 的真实开销算清楚：存 int 时每个 list 节点要 24 字节（vector 只要 4），内存膨胀 6 倍；顺序遍历因为节点散落在堆上、缓存局部性差，反而比 vector 慢一个数量级。
• 《deque 与容器适配器全解：stack、queue、priority_queue 到底套了什么》 —— 讲透 std::deque 的分段连续内存结构——固定大小的缓冲块加一个中控数组，这才是它两端插入都 O(1) 的原因，也是它 sizeof 比 vector 大三倍多的出处；用元素搬动计数实测证明 vector 头部插入 1000 次要搬 50 万次元素、deque 是 0 次。
• 《map / set 完全指南：红黑树与有序容器》 —— 讲透 std::map / std::set 背后那棵红黑树——有序和 O(log n) 是同一套结构的两个结果；实测 1000 个 key 时 map::find 只要 11 次比较，而 std::find_if 要扫 501 次，很多人就是在这里把 O(log n) 写成了 O(n)。
• 《unordered_map / unordered_set 完全指南：哈希表、rehash 与自定义哈希》 —— 讲透 std::unordered_map 的哈希表结构——桶数组加链表（具体实现由标准库定义），load_factor 与 max_load_factor 怎么决定 rehash 的时机、rehash 为什么要重排全部元素；实测塞 10000 个元素会触发 10 次 rehash，先 reserve 则是 0 次；用计数相等谓词实测最坏情况：好哈希查一次命中，坏哈希要比较 1000 次，这就是「平均 O(1)、最坏 O(n)」的真身。
• 《C++ map 与 unordered_map 怎么选：底层结构、复杂度与决策流程》 —— std::map 和 std::unordered_map 接口几乎一样，底层却完全不同。
• 《C++ pair 与 tuple：从 std::tie 到 C++17 结构化绑定》 —— 一个函数要返回两个值、一个结构体要当排序键、一次遍历要同时拿到 key 和 value —— 这些都是 pair / tuple 的活儿。

迭代器与 STL 算法

• 《C++ 迭代器五分类与失效场景汇总：一张表避开所有 UB》 —— 为什么 std::sort 不能用在 list 上？为什么范围 for 里删元素会崩？答案都在「迭代器类别」和「迭代器失效规则」这两件事上。
• 《C++ sort 与自定义比较器：为什么比较器不能用 <=》 —— std::sort 的比较器必须满足「严格弱序」，写成 <= 就可能越界崩溃 —— 这不是风格问题而是未定义行为。
• 《C++ 查找算法：std::find 与容器成员 find 的性能差距》 —— 在 map 上用 std::find 找 key，十万个元素要跑十万次比较，而 m.find(key) 只要几十次 —— 同样叫 find，复杂度差一个数量级。
• 《C++ 变换算法：std::transform 与 for_each 的返回值》 —— std::for_each 的返回值几乎人人都在丢 —— 但它正是取回统计结果的唯一通道：传入带状态的函数对象，返回的副本里就装着累加好的 count / sum / min / max。
• 《C++ erase-remove 惯用法：为什么 remove 不删元素》 —— std::remove 跑完之后容器 size() 一点没变 —— 这不是 bug，而是 STL「算法与容器解耦」这条设计哲学的直接后果：算法只拿得到迭代器，不知道容器的存在，所以它只能把要保留的元素往前挪、返回一个新的逻辑结尾，真正删掉还得靠容器的 erase。
• 《C++ 二分查找：lower_bound 与 upper_bound 的精确语义》 —— lower_bound 是「第一个 >= value 的位置」，upper_bound 是「第一个 > value 的位置」—— 定义好背，用起来天天出错：区间没排序就是未定义行为、降序容器忘了传 std::greater<> 结果全错、想要位置却只调了 binary_search。
• 《C++ 数值算法：accumulate 初值陷阱与 iota/inner_product/reduce 全解》 —— std::accumulate 的第三个参数既是初值、也是返回类型，对 vector 传 0 会让每一步都静默截断成整数。

Lambda 与可调用对象

• 《C++ lambda 表达式完全指南：从语法糖到编译器生成的闭包类型》 —— lambda 不是一个「特殊的函数」，而是编译器现场生成的一个匿名闭包类型，operator() 只是它的成员函数。
• 《C++ lambda 捕获列表详解：值捕获、引用捕获、初始化捕获与悬垂引用》 —— 捕获列表决定闭包能活多久、占多少字节、看到的是快照还是实时值。
• 《泛型 lambda 与 mutable：auto 参数到底生成什么，值捕获的副本为什么改不动》 —— 泛型 lambda 的参数写 auto，编译器就把 operator() 变成模板成员函数，每个实参类型实例化一份；mutable 则是因为 lambda 的 operator() 默认是 const，值捕获的成员不能被修改。
• 《std::function 为什么比 lambda 慢：类型擦除、SBO 与内联》 —— std::function 是类型擦除容器，能存任何可调用对象，代价是可能堆分配、调用只能走间接跳转因而难以内联。
• 《函数指针、仿函数、lambda、std::function 四方对比与选型》 —— 同一件「可调用对象」的事，C++ 给了四种写法。

并发与多线程

• 《std::thread 入门：启动、join、detach 与生命周期》 —— std::thread 析构前必须 join 或 detach，否则直接 std::terminate —— 这是初学者最常踩的坑。
• 《mutex 与 lock_guard / unique_lock：共享数据的正确加锁姿势》 —— 多个线程改同一个变量会怎样？这篇先讲清数据竞争（读-改-写被打断）为什么让结果随机，再讲 std::mutex 的三个接口、为什么必须用 RAII 而不是手写 lock/unlock，以及 lock_guard、unique_lock、scoped_lock 三者的开销与灵活性对比、std::lock 的死锁避免、try_lock_for 与 timed_mutex，最后给出一个能跑的线程安全统计器。
• 《std::scoped_lock 一次锁定多个互斥量：一行代码拆掉死锁》 —— 两个对象互相加锁时，先锁 A 再锁 B、另一个线程先锁 B 再锁 A 就会死锁。
• 《condition_variable 生产者消费者完整实现：虚假唤醒与丢失唤醒一次讲透》 —— 条件变量是线程间「等到条件成立」的标准工具，但两个坑几乎人人踩过：虚假唤醒让 wait 无缘无故返回，丢失唤醒让通知打在空气里。
• 《std::atomic 入门：原子操作、CAS 与它和 volatile 的真正区别》 —— 多线程里 counter++ 为什么丢更新？因为读、改、写三步之间可能被插入。
• 《memory_order 六种内存序详解：relaxed、acquire、release 到底怎么选》 —— 加了 std::atomic 结果还是错的？因为原子性只保证「这一步不可分割」，不保证「两步之间的顺序」。
• 《std::async、future、promise：异步任务的返回值、异常与三个经典坑》 —— std::thread 拿不到返回值、也传不出异常，std::async / std::future / std::promise 就是补这块的。
• 《手写一个线程池：任务队列、工作线程与停止顺序的三个设计点》 —— 每个任务起一个 std::thread 的写法，在任务短、数量多的时候会把时间全花在创建和销毁线程上。
• 《shared_mutex 读写锁该不该用，以及 volatile 的三大误解》 —— C++17 的 std::shared_mutex 让多个读者并存、写者独占，看起来很划算，但读操作很短时它的内部计数竞争会让它比普通 mutex 更慢。

异常与错误处理

• 《异常机制全解：抛出、捕获、栈展开与析构顺序》 —— 异常不只是「换个方式返回错误」，它的核心是栈展开：抛出后从抛出点向上逐层析构已构造的局部对象，直到匹配的 catch——这正是 RAII 能工作的根本保证。
• 《noexcept 为什么移动构造必须标：从 vector 扩容退化成拷贝说起》 —— noexcept 有两种用法——修饰函数和当运算符用；它不代表「不会抛异常」，而是「抛了就直接 std::terminate」。
• 《异常安全三级保证：copy-and-swap 实现强保证的完整套路》 —— 异常安全的三个等级——基本保证、强保证、不抛保证——分别意味着什么、实现代价多大。
• 《std::optional 完全指南：别再用 -1 和 nullptr 表达「没有值」》 —— std::optional（C++17）表示「可能有一个 T，也可能什么都没有」，值就存在对象内部、不涉及堆分配。
• 《std::variant 完全指南：类型安全的 union 与 std::visit 用法》 —— std::variant（C++17）是类型安全的 union：它记住自己当前持有哪个类型，读错类型会抛异常而不是未定义行为。
• 《C++ std::any 完全指南：一个能装任何类型的容器》 —— std::any 是 C++17 引入的类型擦除容器，能在运行时持有任意可拷贝类型。

I/O、字符串与格式化

• 《C++ iostream 格式化输出：setw 一次性、fixed 持久，两个坑一次分清》 —— iomanip 的操纵符真正难的不是记名字，而是分清谁只影响下一个输出项、谁会一直留在流的状态里。
• 《C++ 文件读写实战：ofstream 默认清空文件、getline 与 >> 混用的坑》 —— ifstream / ofstream / fstream 的打开模式、状态位语义、RAII 自动关闭全讲清。
• 《C++ stringstream 实用指南：分词解析、类型互转与 clear/str 的区别》 —— stringstream 是标准库里的「内存 IO」三件套，字符串转数字、数字转字符串、按空白分词、两层解析都能用它。
• 《printf 与 cout 的性能差异与混用陷阱：sync_with_stdio 到底是什么》 —— 竞赛模板里那两行 ios::sync_with_stdio(false) 和 cin.tie(nullptr) 到底改了什么？这篇用两个可运行基准测出关同步在输入侧能快三到六倍，也测出输出侧几乎没差别，并解释了为什么（libstdc++ 的 cout 并非逐字符过 stdio）。
• 《std::string_view 零拷贝字符串视图：内存布局、三大陷阱与参数选型》 —— std::string_view 是 C++17 引入的非拥有字符串视图，内部只有一个指针加一个长度，是 16 字节的轻量「只读窗口」。

C++17 / C++20 新特性与迁移

• 《C++17 核心新特性总览：一张速查表 + 8 个上手示例》 —— C++17 是「写业务代码体感变化最大」的一个版本。
• 《C++20 核心新特性总览：四大特性 + gcc 13 实测清单》 —— C++20 是继 C++11 之后最大的一次改动。
• 《C++17 升 C++20 迁移清单：编译开关、破坏性改动与报错对照表》 —— 一份可逐条执行的 C++17 → C++20 迁移手册。
• 《if / switch 初始化语句：C++17 把变量作用域关进笼子》 —— C++17 给 if 和 switch 加了 init-statement，让「为判断而生的变量」只在语句内部存活。
• 《三路比较运算符 <=>：C++20 两个运算符换六个》 —— C++20 的三路比较运算符 <=> 一次返回「小于/等价/大于」三种结论，再配合运算符改写规则，写出 == 和 <=> 两个函数就自动获得全套六个比较运算符。
• 《指定初始化器：C++20 给聚合初始化补上的最后一块》 —— C++20 的指定初始化器（designated initializers）让 Point p{.x = 1, .y = 2} 成为合法写法，成员名写在初始化式里，加成员、调顺序都不再是静默的语义炸弹。
• 《constexpr 能力扩张：从 C++11 到 C++20 的编译期计算》 —— constexpr 从 C++11 只能写单 return，一路放宽到 C++14 的循环与局部变量、C++17 的 if constexpr、C++20 的 constexpr 容器与 ，再加上 consteval 和 constinit 两个新关键字。
• 《Concepts 把模板错误拦在编译期：C++20 约束的四种写法与重载偏序》 —— C++20 的 Concepts（概念）把「模板参数必须满足什么」从注释和 SFINAE 技巧变成能编译期校验、能被重载决议使用的实体。

性能优化与内存布局

• 《性能优化总纲：先测量再优化，别拿直觉当证据》 —— 性能优化板块的纲领篇。
• 《缓存友好设计：AoS 与 SoA 的内存布局、缓存行与伪共享》 —— 从缓存层次与 64 字节缓存行讲起，用 sizeof / offsetof / 扫描字节数这些确定性指标，量化 AoS（结构体数组）与 SoA（数组结构体）在「热路径只读一个字段」时的数据搬运差距（16 字节 vs 4 字节、32MB vs 8MB），给出两者的详细内存布局图与选型对照表；再讲伪共享（false sharing）为什么让两个线程写同一条缓存行里的不同变量时互相拖累，用 alignas 填充解决，并给出一个真跑的双线程示例。
• 《虚函数调用的真实开销：vptr、vtable 与间接跳转拆开算》 —— 把一次虚函数调用拆成「取 vptr → 查 vtable → 间接跳转」三步，用 sizeof 实测证明多态对象的 8 字节 vptr 从哪来、为什么 final 不改变对象大小；按重要性给开销来源排序（间接跳转难被分支预测 > 阻止内联与后续优化 > 额外的内存加载），并说明什么时候这些开销完全不必在意；给出四种降低开销的手段（final 去虚化、CRTP 静态多态、std::variant + visit、类型标签 + switch）与完整对比表，附一个四种实现同场竞技、结果互相印证的完整示例。
• 《C++ 内存对齐：alignof / alignas 与结构体 padding》 —— 一个只有 char / int / char 三个成员的结构体，sizeof 为什么会是 12 而不是 6？这篇从这个问题切入，讲清 alignof 与 alignas 的语义、编译器为什么必须在成员之间插入 padding 字节、为什么只调整成员顺序就能把 12 字节压到 8 字节，并用 offsetof 逐字段实测内存布局。
• 《C++ 移动 vs 拷贝：什么时候真的快，什么时候白忙一场》 —— std::move 本身零开销，它只是一次类型转换，编译后不产生任何指令；真正省时间的是资源转移而不是「少复制几个字节」。
• 《C++ 编译期计算：把运行期的工作提前到编译之前》 —— 编译期计算省下的是运行时的计算时间和内存构造开销，付出的是编译时间和二进制体积。
• 《C++ 模板实例化膨胀：为什么编译慢、二进制大，怎么治》 —— 模板每遇到一个不同的实参组合就生成一份独立机器码，这就是代码膨胀（code bloat）—— 二进制变大、指令缓存命中率下降、编译时间随实例化数量增长。

陷阱、UB 与工具链

• 《未定义行为（UB）清单：这些代码为什么「能跑」却不合法》 —— 有符号溢出、越界访问、读未初始化变量……这些代码在你机器上「能跑」，但按 C++ 标准行为完全未定义（undefined behavior, UB）。
• 《悬垂指针与悬垂引用：生命周期错误的排查套路》 —— 指针没变、地址没变、代码没改，读出来的值却从正确变成了垃圾——这就是悬垂（dangling）。
• 《整型溢出：有符号是UB、无符号是回绕，这个不对称要讲透》 —— 有符号整数溢出是未定义行为（UB），无符号整数溢出是标准保证的模 2^N 回绕——这个不对称是整型题目里最容易搞错的地方。
• 《编译警告解读：-Wall -Wextra 到底在喊什么》 —— 警告是编译器送的免费代码审查，应当开满并清零。
• 《assert 与 static_assert：把假设写进代码》 —— static_assert 把类型、常量关系、平台尺寸的假设钉死在编译期，assert 检查运行期的内部不变量。
• 《用 Compiler Explorer 看汇编：从 C++ 到指令》 —— Compiler Explorer（godbolt.org）怎么用：选编译器与版本、调 -O0 / -O2 对比、用颜色高亮把 C++ 行和汇编行对上、用有没有独立函数符号判断是否被内联、直接调它的编译 API 取汇编。

工程实践

• 《CMake 入门：从单文件到多目标工程》 —— 现代 CMake 的核心是以 target 为中心：用 target_include_directories / target_link_libraries 代替全局命令。
• 《头文件组织与前置声明：编译依赖管理》 —— #include 的本质是文本替换，一个被 N 个 .cpp 包含的头文件改一次就要重编 N 个文件。
• 《ODR 单一定义规则：同名符号为什么会链接报错》 —— ODR（One Definition Rule，单一定义规则）是 C++「独立编译 + 链接」模型的地基。
• 《命名空间与代码组织：匿名命名空间、ADL 与 using 的边界》 —— 命名空间不只是「给名字加前缀」，它同时管三件事：避免全局名字冲突、表达逻辑分组、划定 ADL 的搜索范围。

底层机制与 ABI

• 《C++ 对象内存模型：vtable 布局、多继承 vptr、RTTI 与 dynamic_cast 走查》 —— 用 sizeof/offsetof/typeid/dynamic_cast 实测对象内存布局：vptr 为什么在头部、多继承为什么有多个 vptr、RTTI 的 type_info 挂在哪、dynamic_cast 跨基类转换靠什么走查，配内存布局 ASCII 图。
• 《C++ 名字修饰（name mangling）与 extern “C”：C/C++ 互操作》 —— 用 nm/nm -C 真实符号表讲清名字修饰：重载/命名空间/模板为什么需要 mangling、extern “C” 怎么关掉它、C++ 调 C 与 C 调 C++ 的标准写法、__cplusplus 宏的用法，以及为什么链接报错里总是一串 _ZN 开头的怪符号。
• 《C++ ABI 与跨库兼容：为什么换编译器要重编、符号可见性》 —— 讲清 ABI（应用二进制接口）包含什么、为什么 libstdc++ 与 libc++ 不 ABI 兼容、std::string 跨动态库传递有多危险、-fvisibility=hidden 怎么控制导出符号让 .so 变小，以及为什么 C ABI 是唯一稳定的跨库边界。
• 《静态库 vs 动态库：-fPIC、PLT/GOT、LD_PRELOAD、链接顺序》 —— 用 nm/readelf/ldd/size 的真实输出讲清静态库 .a 与动态库 .so 的本质差异：链接时复制 vs 运行时加载、动态库为什么必须 -fPIC、PLT/GOT 延迟绑定怎么工作、LD_PRELOAD 怎么劫持符号、-l 链接顺序为什么重要。
• 《异常的实现与代价：零成本异常、栈展开与 -fno-exceptions 什么时候用》 —— C++ 异常常被说「零成本」，但它的代价藏在抛出路径上。
• 《std::launder、std::bit_cast 与 placement new：合法绕过别名》 —— 想把一个 int 的位模式当 float 读，reinterpret_cast 是 UB；想原地重用一块内存，旧指针会变成悬垂指针。

无锁与高级并发

• 《无锁栈：Treiber 栈的 CAS、ABA 问题与 tagged pointer》 —— 无锁栈（Treiber stack）是理解无锁编程的入门课：push/pop 全靠一个 compare_exchange 循环，但它藏着两个坑——ABA 问题（节点地址被复用后 CAS 误判「没变」导致丢节点）和节点回收的 use-after-free。
• 《无锁队列（MPSC/MPMC）：Vyukov 环形队列与 slot 未就绪问题》 —— 队列比栈难，因为它有两个端点——头尾都要协调。
• 《无锁内存回收：hazard pointer 与 epoch-based reclamation 原理》 —— 无锁栈 pop 出来的节点为什么不能立刻 delete？因为另一个线程可能还攥着它的指针。
• 《锁进阶：atomic_flag 自旋锁、shared_mutex 读写锁与无锁的代价》 —— std::mutex 一竞争就把失败线程挂进内核（futex），唤醒要走上下文切换；临界区极短时，用 atomic_flag 手写的自旋锁在用户态空转反而更快。
• 《内存序实战：release/acquire 三种经典模式与 seq_cst 的代价》 —— 为什么原子操作默认用 seq_cst？因为它最不容易写错，但也是最贵的。

高级模板与编译期

• 《类型擦除：手写 any 与 function 的原理》 —— std::any 和 std::function 看起来是两种不同的东西，底层却是同一个套路——类型擦除（type erasure）：一个非模板接口 + 一个模板派生的「壳」+ 一次虚函数跳板，把具体类型藏进虚表。
• 《表达式模板：Eigen 式延迟求值，把 a+b+c 压成一次遍历》 —— 表达式模板（Expression Templates）让 a+b+c 不再生成中间临时对象，而是把整个表达式合成为「一棵表达式树」，赋值时才一次性求值。
• 《类型列表与编译期算法：手写 typelist 的 map/filter》 —— 编译期想对「一组类型」做运算（取第 N 个、映射成指针、筛选整型），靠的是 typelist（类型列表）加递归 + 偏特化实现的 map/filter。
• 《tag dispatch 与重载偏序实战：按迭代器类别派发算法》 —— tag dispatch（标签派发）用「空类型」当标签，靠重载偏序在编译期选出正确的实现，是 std::advance、std::distance 等算法对迭代器类别做特化的核心手法。
• 《编译期反射模拟：C++ 没有反射怎么办》 —— C++ 至今没有运行时反射，想「遍历结构体成员」「自动序列化」只能靠模拟：宏（X-Macro 展开成员）、std::tie + 结构化绑定、boost.pfr 的聚合成员推导，以及 C++20 的 consteval。

性能工程进阶

• 《自定义分配器与内存池：std::pmr 从零到 free list》 —— std::allocator 每次扩容都要向系统要内存，std::pmr（C++17）用 polymorphic_allocator + memory_resource 把「内存从哪来」变成可插拔的策略。
• 《SIMD 与自动向量化：march=native、__restrict 与 likely》 —— 自动向量化（auto-vectorization）让编译器把标量循环翻译成 SIMD 指令，一次处理 4 个 int（SSE2）或 8 个 int（AVX2）。
• 《PGO 与 LTO：profile-guided 与链接时优化》 —— LTO（链接时优化）把「跨编译单元」的优化推迟到链接期，让原本看不到对方函数体的两个 .cpp 也能互相内联；PGO（profile-guided optimization）先插桩跑一遍收集真实热点，再按热点重新编译。
• 《基准测试的陷阱：优化掉、频率漂移、缓存预热》 —— 基准测试（benchmark）的三个经典陷阱：① 结果没被观测，编译器按 as-if 规则把整个计算删掉（do_not_optimize 手法可防）；② CPU 频率漂移/节流让耗时不可比；③ 缓存冷热让第一轮结果失真。
• 《C++ 缓存预热与 prefetch：什么时候该手写》 —— 手写 prefetch（__builtin_prefetch / _mm_prefetch）到底能不能加速？这篇从缓存行与 pointer-chasing 讲起，演示软件流水线预取的正确写法，用链表实测不同预取距离的量级，给出「够早但别太早」的判据，最后总结什么时候该手写、什么时候反而更慢。

工程与架构经验

• 《C++ 错误处理策略：异常 vs 错误码 vs expected 的真实取舍》 —— 函数失败到底该抛异常、返回错误码，还是用 C++23 的 std::expected？这篇用同一个「安全除法」场景把三种写法各跑一遍，给出一张覆盖不可忽略性、可预期性、性能、跨库边界等维度的对比表，并说清 optional 与 expected 的区别，最后给出真实项目的混合策略。
• 《C ABI 与插件系统：dlopen 导出稳定接口》 —— 为什么插件系统都要用 C ABI？这篇从名字修饰讲起，说清 extern “C” 与不透明指针（opaque pointer）导出 handle 的手法，再用 dlopen/dlsym 真跑拿到函数指针，最后给出「主程序 + 插件」最小框架，并强调插件绝不能把异常抛过 C 边界。
• 《C++ 日志与单元测试：无第三方库的最小实现》 —— 不引 gtest、spdlog，手写一个能用的日志框架和单元测试框架要多少代码？这篇用 std::source_location（C++20）自动拿文件/行号/函数名，用宏封装级别与 EXPECT_EQ，说清「为什么测试框架非用宏不可」（字符串化 + 行号定位），最后拼出一个最小可用的日志 + 测试套件。
• 《C++ 序列化与版本兼容：没有反射，手写字段也能持久化》 —— C++ 没有内置反射，序列化只能靠显式声明字段。
• 《C++ 跨平台工程：特性检测与 feature-test 宏实战》 —— 一份代码要在 Windows/Linux/macOS 上都能编，关键是不写死平台和标准。

调试与二进制分析

• 《gdb 实战：断点、watchpoint、core dump 与多线程调试》 —— 程序崩了只会看日志？这篇系统讲 gdb 的断点、单步、print、backtrace、watchpoint、条件断点、frame 切换、core dump 分析，以及多线程的 thread apply all bt。
• 《perf 与火焰图：从热点到定位（接 Perfetto）》 —— 程序慢在哪？这篇讲 Linux perf 采样型 profiler 的原理（周期采样 + 栈回溯）、perf stat/record/report 用法、火焰图怎么读，以及与 Perfetto 的分工：perf 定位 CPU 热点函数，Perfetto 做端到端 trace。
• 《二进制分析：nm、objdump、readelf 看懂符号表与段》 —— 链接报 multiple definition、undefined reference，或者纠结一个变量为什么让可执行文件变大，光看源码是找不到答案的——得看编译出来的二进制。
• 《clang-tidy 与 cppcheck：静态分析落地》 —— 编译器 -Wall 能抓到的是语法和浅层语义问题，真正要命的 bug（move 后再用、整数除法截断、C 风格转换、该用 auto 没用）它抓不到。

C++23 与前瞻

• 《C++23 核心新特性：std::expected、std::print、deducing this、monadic optional》 —— C++23 没有 C++11/C++20 那种天翻地覆的变化，但补上了一批「日常高频」的拼图：std::expected 让错误处理从异常和错误码的二选一里解脱出来，std::print 让输出告别 iostream 的啰嗦，deducing this 消灭了 CRTP 模板样板，monadic optional 让可空值可以链式处理。
• 《C++20 升 C++23 迁移清单：开关、破坏性改动与收益》 —— 从 C++20 升到 C++23 是「低风险、有正收益」的一次迁移：破坏性改动几乎可以忽略，收益却实实在在（std::expected 替代错误码、std::print 替代 iostream、monadic optional 简化判空）。
• 《前瞻：std::generator、reflection 与 C++ 的未来方向》 —— C++23 之后，C++26 正在路上：std::generator 让协程写惰性序列像写 for 循环一样自然（C++23 已能实测），static reflection（P2996 提案）和 contracts 则瞄准「让类型系统自动看清自己」。