"C++ 很糟"早就是陈词滥调了。这些抱怨都不新。这篇文章想说的是另一件事:下面每一个问题、每一个例子,背后都是同一个设计决定
——向后兼容优先于其他一切。
这篇文章写得比较长,因为它不打算只列"C++ 的十宗罪",而是把每一处毛病的历史挖出来:为什么它会变成这样,以及为什么今天改不了。
从地狱最里面一圈开始:每个程序的开头——创建一个变量。
在大多数语言里这是一步操作。在 C++ 里,有人为它写了整本书,发了论文,做了会议演讲,把每个角落的边界情况都剖开看了一遍。
如果数一数不同的初始化语义,大概有十种形式(= v、(v)、{v}、= {v}、{}、= {}、new 里的 () 等等),它们映射到九种语义类别。语法和语义远不是一一对应的:同一个 {},取决于右边的类型,可能是值初始化、列表初始化,也可能是聚合初始化。
甚至有一本专门讲 C++ 初始化的书,三百页。不是玩笑。作者的朋友推荐过,书真的存在,真的三百页。
每一种初始化形式的行为都略有不同。作者最喜欢的一对是 int e{}; 和 int f;——一对大括号的有无,决定了你的变量里是 0,还是上一次函数调用留在栈上的那些位。
这一堆写法,本来是为了消灭初始化乱象才长出来的。2011 年,委员会真的想用一个统一语法把所有东西收编,结果又给动物园添了一个新展馆。
从 C 那里,C++ 继承了两种初始化:声明时的 int a = 5;,以及给数组、结构体这类聚合用的 int arr[] = {1,2,3};。在 C 里,大括号只是把值分给 POD 聚合的成员,没打算干别的。
后来 C++ 加了构造函数。有了构造函数,就得有在对象创建时运行它的方式。圆括号看起来最自然——构造函数调用长得很像函数调用,于是 Widget w(args);。很合理。
直到某天你写下 Widget w();,然后意识到自己声明了一个返回 Widget 的函数。这就是著名的 most vexing parse。它不是实现 bug,是 C 语法的直接后果:声明被设计成"长得像使用",于是函数声明和"用空括号构造对象"在语法上无法区分。
然后是 C++11 的伟大发明:统一初始化。目标很漂亮——引入唯一一种 {} 语法,聚合、带构造函数的类、标量、容器全适用。附带的收益是消灭 most vexing parse(Widget w{}; 永远不可能被解析成函数),还能拒绝窄化转换(int x{3.5}; 是编译错误,而 int x = 3.5; 悄悄截断小数)。
换句话说,{} 本不是"又一种初始化语法",它本应是唯一的初始化语法,最终取代其他所有写法。
然后撞上了那个能解释 C++ 一切的问题:要让 {} 成为唯一语法,语言就得删掉 = 和 ()。可这两个东西出现在几十亿行代码里——引擎、库、第三方 API 全指着它们。
于是旧语法删不掉,新语法也没取代旧的,只是给自己找到了一块地盘。那个本来要关掉动物园的特性,成了动物园里最著名的展品。
int f; 里是垃圾值int e{};(0)和 int f;(垃圾值)的差别是另一段故事。这个行为来自 C:自动变量从不默认清零。
这不是疏忽,是刻意的设计选择——清零要花 CPU 周期,而 C 的哲学一直是"你不用的东西,不该付费"。想要 0,就自己写。
所以 int f; 会留下上一次函数调用栈帧里的位。这是设计使然,是 1972 年前后的一个特性。后来 Stroustrup 想提供一个安全的、零初始化的默认值,但他没法把它变成语言默认——那会同时破坏向后兼容和 C 的核心哲学。于是安全选项存在,只是不是默认,因为默认在半个世纪前为了性能被定死了。
到这一步,把这些统一成一种语法已经不可能了。每种形式都积累了自己的代码、语义和规则。所以当又一本三百页的初始化书出现,或者有人拿出一张占满半个屏幕的流程图时,那不是作者在炫耀——那是过去四十年塞进这门语言的所有东西的账单。
同一行代码,取决于你按哪个标准版本编译,得到的类型不一样。不是结果不一样,是类型不一样。
生成一个随机数,是"简单的事情被搞复杂"的教科书级案例。Java 或 Python 一行 random.randint(1, 100) 就结束了。
代码可读性还行,但作者每次用都得回去翻 cppreference,还得搜一下 mt19937 到底是什么。答案是梅森旋转算法。恭喜,你现在知道了一个伪随机数生成器的名字——显然,在 C++ 里掷个骰子需要这个知识。
C++11 之前,语言用的是从 C 继承的 rand()。它返回一个受 RAND_MAX 限制的数,标准只保证 RAND_MAX 至少 32767。在某些平台上,这意味着你根本没法在一个较宽的区间里拿到均匀分布。
熟悉的 rand() % 100 会引入取模偏差,因为 100 不能整除可能的输出总数——某些值出现得更频繁,而且序列在不同编译器之间都不可复现。换句话说,rand() 是一种极其简便的自伤方式。
所以 C++11 从 Boost.Random 借来一套全新设计,刻意把 rand() 混在一起的东西拆开:引擎(原始随机位的来源,mt19937,松本和西村 1997 年设计的梅森旋转)、分布(把原始位变成指定区间内的均匀值,且不引入偏差)、以及独立的种子来源。
这套设计出自需要可复现蒙特卡洛模拟的科学计算人群,对那个场景它很出色。问题是:他们造了一座宏伟的大教堂,却没顺手开一扇写着"掷一个 1 到 100 的数"的小侧门。直到今天,C++ 标准库也没有一行的 randint()。
首先,mt19937 内部状态接近两万位,我们通常只用一个 32 位的 std::random_device 值去播种——严重欠采样。
其次,std::random_device 本身,标准明确允许实现是确定性的。很多年里,老版本 MinGW 每次程序启动都返回同一串序列。
所以那串又长又"正确"的咒语,确实又长又正确,但在所有平台上并不可靠。而 rand() % 100 更短,而且还真的能用。
转换是另一个故事。Java 里把目标类型放括号里就完事了。C++ 里有一整套:static_cast、dynamic_cast、reinterpret_cast、const_cast、bit_cast——每一个都有完整名字,每次都得拼出来。还有一个隐藏的 rvalue_cast,等下会说。
初学者常被烦到,于是自己造一个短别名:
有人干脆 #define CAST(T, x) static_cast<T>(x)。
这就是语言开始折磨人的地方:正确的 C++ 代码,看起来往往是不正确的。 因为短小优雅的写法通常有 bug 或者有微妙的缺陷,而正确的写法看起来像是作者刻意给全团队添堵。培养"好的 C++ 长什么样"的直觉要几年。在那之前,你总觉得自己在做错事。剧透一下:你可能确实在做错事,这门语言就是这样。
C 有 (T)expr 这种 C 风格转换,它什么都能干:改值、重解释指针、剥掉 const、窄化类型,全用同一个语法。结果就是在任何代码库里,你都看不出谁在哪里把 const 转掉了——那些转换和普通转换长得一模一样。
C++ 把这把瑞士军刀拆成四个具名操作,恰恰是因为在 C 里它们无法区分。目的是让意图显式,让削弱 const 的 const_cast 能一眼被 reviewer 看到,也让每个 reinterpret_cast 都能被 grep 出来检查。
转换被当作"必要的恶",所以设计者刻意把它做丑。Andrei Alexandrescu 有句名言:转换是代码异味。Stroustrup 故意选了啰嗦的语法,让显式转换打起来手疼,在代码评审里一眼就跳出来。旧的 C 风格转换太轻巧了,而这正是它危险的原因。
所以 C++ 里"正确"的写法常常看起来是错的,不是意外,是设计。短小优雅的版本通常是删不掉的遗留物;正确的那一版是故意写得又长又别扭的,它的作用就是逼你停下来,想一遍每一次显式转换。
在一个正常的世界里,关键字描述它做的事。在 C++ 里,这更像一个可选特性。
static 有几个意思?第一,让变量在函数调用之间存活;第二,让变量或成员函数属于类的所有实例;第三,在 .cpp 文件里放在函数前面,让这个函数对外不可见——它的行为像 private,但名字叫 static。为什么不叫 internal、private、file_local?因为事情就是这样,而这句话能回答本文里大概一半的问题。
C++11 之后,static 还隐含了"轻量级互斥锁保护"——函数内的 static 变量初始化是线程安全的。为了实现这点,编译器会生成一个隐藏的 guard,保证只初始化一次:
展开之后大致是:先快速检查 guard 的最低位是不是 0,是就说明已经初始化过;否则进入慢路径 __cxa_guard_acquire,抢到的线程负责构造,其他线程在里面睡着,构造完 __cxa_guard_release 唤醒它们,同时注册析构。
在 C 里,static 已经有两个不同含义。一个是存储期——变量在程序整个生命周期内存在。另一个是内部链接——名字在翻译单元外不可见。语义上这两件事几乎毫无关系:一个讲对象生命周期,一个讲符号可见性。但 K&R 把它们塞进了一个关键字,理由很简单:C 应该尽量少的关键字,而 static 和"静态分配"听着够近了。
C++ 原封不动继承了这两个含义。删掉任何一个都意味着破坏与 C 的兼容——正是这门语言想避免的结果。
后来 Stroustrup 要引入"被所有实例共享的类成员",他本可以加一个新关键字,比如 shared、classwide,或者按 private、protected 的路子起个描述性的名字。但到那时候,已经很清楚了:每加一个新关键字,都是给开发者埋一颗地雷。
因为那时候,几乎肯定已经有人把变量命名成 shared、internal 或 classwide 了。这些词一旦变成关键字,他们的代码立刻编译不过。所以设计者尽可能复用现有关键字,而不是发明新的。static 已经在语言里,含义本来就有点过载,再加一个解释,不会破坏谁的生产代码。于是 static 拿到了第三个含义——不是因为语义最贴切,而是因为这个词已经在手边,复用它保住了向后兼容。
第四个行为是 C++11 带来的:函数内 static 变量的初始化被做成线程安全,编译器开始发隐藏 guard。
中间有过一次清理尝试。C++98 时,用文件作用域的 static 做内部链接被官方不推荐,建议改用匿名命名空间。但 C++11 把这个建议撤回了——因为打破开发者几十年习惯的代价,比改语言还高。换句话说,C++ 连一个自己宣布过时的含义都删不掉。
现实点看,这四个含义现在一个都动不了。每一个都有代码依赖:一个局部计数器、一个私有辅助函数,或者一个被几十万开发者使用的公共 API 里的类成员。
inline 曾经是提示编译器把函数内联展开。今天编译器自己会判断,inline 基本变成了处理链接和单一定义规则(ODR)的工具。
更怪的是,它用在不同的东西上,意思几乎相反:对函数,它允许代码重复;对变量,它禁止数据重复。
早期 C++ 里,inline 是 #define 宏的类型安全替代品:不在调用点做函数调用,而是把函数体直接替换进去。字面上就是基于内联展开的优化——名字由此而来,也是很多开发者至今仍以为 inline 的意思是"让它更快"。这个说法至少十五年前就不成立了。
今天它的主要用途跟优化关系不大:inline 允许一个实体在多个翻译单元里有定义(比如你把定义放在头文件里到处 include),链接器负责把它们合并成一个,而不是报 multiple definition。
那它跟真正的内联还有多少关系?很少。作为优化提示,它纯粹是建议性的。现代编译器经常直接忽略它,因为它们依赖复杂的成本模型:没标 inline 的函数照样内联,标了 inline 的照样不内联。开了 LTO,编译器甚至能跨翻译单元内联,关键字在不在都无所谓。
现在要强制内联,得用 __forceinline(MSVC)或者 __attribute__((always_inline))——而且碰到递归、可变参数、或者取了函数地址,连这些也经常失败。
名字是那个"它真的这么工作"的年代留下的化石。今天它只是一条发给链接器的消息。
const 本意是不可变,但你把它写在类型的左边或右边,两种形式完全等价——纯粹为了让你多留个心眼。
更妙的是,mutable const 有时是合法代码;你还可以手动把 const 性去掉,不理想,但技术上可行。
判断指针声明里的 const 到底修饰指针还是修饰指向的值,官方建议是从右往左读,而大多数人是从左往右读。
const 这个词其实是 C++ 造出来、后来被 C 借走的,不是反过来。Stroustrup 在"带类的 C"里引入它,最初的工作名叫 readonly。它后来进了 C89 标准,然后有了自己的生命。讽刺的是,这个为了带来秩序而生的关键字,立刻继承了它所落进的语法的怪癖。
首先,const int 和 int const 字面上就是同一件事:const 是类型限定符,住在 decl-specifier-seq 里,也就是声明说明符序列。而这个序列在 const 出现之前就已经是无序的了——原因和 unsigned long 与 long unsigned 是同一个类型一样。所以 const 继承了一个老毛病:说明符的顺序本来就不重要。
更一致的形式其实是 int const,因为 const 概念上修饰紧邻它左边的东西。另一种写法 const int 主要是语法上的让步,因为早期编译器已经允许了。
这就是 east const 的由来。不是有人故意造了两种等价拼写,而是语法自然长出来的:方便,而且不破坏现有代码。
至于 const 相对星号的位置为什么重要:在星号左边,它成为说明符序列的一部分,修饰指针指向的东西;在星号右边,它成为声明符的一部分,修饰指针本身。这遵循了原始的设计原则——声明应该长得像以后使用这个变量的表达式。这对 int p; 很合适,对 int (f)(int); 就是个残酷的玩笑。再叠上 const,一个本来就难读的语法更难读了。
还是那句话:改不了。C++ 从 C 继承了 const 的解析规则,实际上已经石化了。改它会同时破坏 C 和这两个语言四十年来的代码。
所以 const 看起来像门上的锁,其实更像一张"请勿入内"的告示,字还朝着门里。
C++ 有多少种整数类型?算上定宽别名,大约五十种。更有意思的是,它们并不都有固定大小——实际大小取决于编译器和目标平台。
int 不代表 32 位。它代表至少 16 位,也可能是 32 位。标准只保证一条链:short <= int <= long <= long long。64 位 Linux 上 long 是 64 位;64 位 Windows 上 long 还是 32 位——全是为了向后兼容(记住这句话)。要保证 64 位就用 int64_t。
作者到现在也不理解为啥它要带 _t 后缀——又不是 90 年代了。但这又是一个改不了的东西。
字符类型值得单独说。有七种,迟早你会开始想:为什么一个字符要像整数一样分有符号和无符号?char 和 signed char、unsigned char 有什么区别(三个不同类型,不是两个)?wchar_t 到底是什么?std::string 和 std::wstring 差在哪,为什么这个差别会突然把你的编码搞乱?
类型动物园本质上是一份古生物记录,记着 C 跑过的每一台机器。
C 诞生在 70 年代初,那时计算机架构差异极大。PDP-11 用 16 位字;C 早期移植到的 Honeywell 系统用 36 位字;CDC 机器用 60 位字;有些架构用 6 位或 9 位字符。历史上,一个 C 字节从来不保证是 8 位——在 C 标准里,CHAR_BIT 是最小可寻址内存单元的位数,所以一台 CHAR_BIT == 9 的机器完全合法。
考虑到这些,Ritchie 做了唯一合理的决定:根本不固定大小。int 只表示"这台机器最自然的字长——处理器处理起来最高效的那个——但至少 16 位"。
语言只保证最小范围和顺序,实际大小交给目标平台。正因为这个决定,同一份源码可以高效地编译到 16 位 PDP-11、36 位 Honeywell 和十几种其他架构上。int 没有固定大小,恰恰是 C 可移植的原因。
然后 32 位机成了常态,int 落在 32 位。64 位系统来了,int 没动。因为那时候全世界已经充满了把 sizeof(int) == 4 写死的代码,把 int 加宽到 64 位会全部打断,更不用说无数 ABI。
微软连 long 都留在 32 位。为什么?庞大的存量代码、巨大的产品生态、几百万用户。或者简单点说:向后兼容。无数行代码和 Win32 API 本身都把 long 当四字节用,和 int、DWORD 混着用,按四字节序列化到磁盘和网络。修这个太贵了。所以 long 在不同平台上意思不同,仅仅因为 90 年代末两个生态做了不同的兼容性取舍。
int64_t 和它的 _t 后缀,本质上是在承认:这门语言没能让它最基础的整数类型变得可预测。几十年后,又在一个单独的头文件 <stdint.h> 里补了一族定宽类型。_t 不是 90 年代的遗物,是 70 年代的——它来自 Unix 的 typedef 命名约定,size_t、time_t、wchar_t,以 _t 结尾的名字留给实现使用,这样标准可以引入新类型而不撞上用户定义的名字。
如果目标是尽可能迷惑初学者,就照着 STL 的方式命名。
最常用的容器叫 vector,可它其实是动态数组。通常意义上,vector 是一个带方向的量。连 STL 的作者 Alexander Stepanov 后来都承认这名字是个错误。
要哈希表呢?你可能伸手去拿 std::map。但那不是哈希表,是平衡树,对数查找。真正的哈希表叫 std::unordered_map。而剧透一下:这个也最好别用,因为它慢。
unordered_map 慢不是实现偷懒,是标准规定的。标准要求分离链接加节点,并且要求指向元素的引用和指针在插入、删除(被删的那个除外)之后保持有效——连 rehash 都不许让已有元素的指针失效。
这就只有一种实现方式:每个元素单独在堆上分配(std::pair<const Key, Value> 加一个指向下一个元素的指针),每个桶是一条链表。换句话说,标准描述的不是"数组里的哈希表",而是"一个指针数组,指向散落在堆上的链表"。
operator[] 的坑更日常:
一个"检查键是否存在"的动作,把键创建了出来。要检查就用 find 或 contains。
然后是 empty()——听起来像清空容器,其实只是告诉你它是不是空的。按命名习惯它该叫 is_empty()。remove() 根本不删除任何东西,只是把匹配的元素挪到末尾返回迭代器,还得再用 erase-remove 惯用法删掉。还有 std::stoi、std::stol、std::stoll、std::stof、std::stod、std::stold,开发者就是得知道它们是什么。你知道吗?
要理解标准库为什么有时候像是照着和开发者作对设计的,可以记住一件事:它出自一位数学家之手。
Alexander Stepanov 花了数十年发展泛型编程的概念,核心想法是算法应该依赖抽象的类型要求,而不是具体的数据结构。在 C++ 之前,他先在 Scheme 里试,又和 David Musser 在 Ada 里试。最后他来到 C++,发现模板——本来是为完全不同的目的设计的——强大到足以表达他的全部想法。1993 到 1994 年,他把成果带到委员会,几乎原封不动地进了 C++98,这在语言史上相当罕见。
vector 就是这么来的。在 Scheme 的计算模型里,vector 就是一维连续数组,所以对 Stepanov 来说这名字完全合理。后来说 array 更合适,可那时 vector 已经进了标准草案和无数代码库。改名不再是选项——这个故事在 C++ 里会反复出现。
map 的历史类似。名字准确描述了抽象:从键到值的映射。问题在于很多开发者来自 Java 或 Python,那里的 map 或 dict 通常意味着哈希表,于是本能地期待同样的行为。等 C++11 终于引入真正的哈希表时,最显然的名字 hash_map 已经不能用了——SGI、微软、Dinkumware 等厂商各自的实现早就占住了它。为了不破坏整个生态,委员会只能选那个唯一没被占、但相当别扭的名字:unordered_map。
那个丑名字算不上设计失误,它是向后兼容这道承诺留下的又一道疤。
顺便把剩下的都补上:lvalue、rvalue、glvalue、prvalue、xvalue。有印象吗?
某些情况下 std::move 会变成拷贝,你真正需要的是 std::move_if_noexcept。
说回移动语义,std::move 从一开始就起错了名字。它根本不移动任何东西。它只是把参数转成右值引用,让它有资格绑定到移动构造或移动赋值上。它本该叫 rvalue_cast。不过话说回来,C++ 大概真的不需要再多一种 cast 了。
C 只有两个值类别:左值和右值。C++11 引入移动语义后,两个不够用了。语言必须区分"一个有名字、你不该动的对象"和"一个临时值、你可以把它的值拿走"。这是两个独立的属性,组合起来得到五个值类别。xvalue(eXpiring value,将亡值)就是其中一个:有身份,但它的值可以被安全地移走。
为了把一个对象标记成 xvalue,语言需要专门的操作。rvalue_cast 会是显然的名字,但委员会不想再引入一种 cast,于是 Howard Hinnant 和其他设计者选了一个反映意图而非机制的名字。所以每次你写 std::move,请读作:"这个对象我用完了,你可以把它的值拿走。"
标准库里还有第二个 std::move——那个真的会移动元素。所以别把会移动的和不移动的搞混。有人给作者看过一份 70 页的 PDF,专门解释什么时候该用哪一个,标题他忘了。
还没算上 C++ 各种习语的名字。
RAII 是什么?Resource Acquisition Is Initialization,资源获取即初始化。可这个名字指向的是这个习语里最不重要的部分。RAII 真正讲的是反过来的事:对象离开作用域时,在析构函数里自动释放资源。它本该叫 CADR(Constructor Acquires, Destructor Releases),因为这才是它干的事,而不是"构造函数获取了一个资源"这个事实。
CRTP 也一样。Curiously Recurring Template Pattern,奇异递归模板模式——这个名字完全没描述这个模式做什么,它描述的是作者的反应:他在不同代码库里反复碰到同一种模板写法,觉得很好奇,就起了这个名字。
头文件是 1970 年代的产物。当时机器内存只有几十 KB,编译器只能单遍扫描,于是把声明和实现拆开,用 #include 做文本复制。
五十年过去,这套机制还在。
一百个文件的项目变成两百个,PR 数量和 review 工作量翻倍。一个类要写构造函数,类名得在头文件里写两次、在 cpp 里写两次,四遍之后才能开始写实现。#include 就是美化的复制粘贴,传递依赖导致重复定义,撞上 ODR 就报编译错误。
解法是 include guard,每个头文件都要加。或者 #pragma once——它至今不在 C++ 标准里,有人说永远别用,有人说两个都写保险。争论掩盖了真正的问题:编译器本来就该默认只包含一次,需要多次包含时才显式 opt-in。
更麻烦的是抽象泄漏。头文件里声明的类,会把 private 成员一起暴露出去;改一个私有成员,所有包含它的文件全部重编译。PIMPL 能挡住一部分,代价是多一层间接和性能损失。
还有自动补全污染:#include 把一个依赖树里所有符号倒进你的代码,#include <windows.h> 就等于往命名空间里倒进上百万个名字。作者的 IntelliSense 长期处于半瘫痪状态,他几乎不敢依赖 Tab 补全。
宏则是另一回事。它做的是编译前的文本替换,不认类型、不认作用域、不认命名空间。作者打的比方很到位:这就像请人进你家,他不安分坐着,开始偷偷重新摆放你的家具。windows.h 里有个 SendMessage 宏,会直接覆盖你写的 SendMessage 函数。还有人写过把 private 变成 public 的宏来做单元测试,结果所有私有成员一起裸奔。
命名空间本来是为了解决这个问题,可它带来了新的问题。C++ 的符号查找发生在不断扩大的作用域里:函数 → 当前命名空间 → 父命名空间 → 全局。如果有人新增了一个匹配命名空间层次的名字,编译期找到的符号会静默地改变——他不用碰你的代码,就能改掉你的代码的行为。原文举的例子是:company 命名空间里的 log 被 company::team 里新增的 log 劫持;如果换成认证系统里的哈希函数被静默切换成不安全的实现,那就是一个安全漏洞。
所以原文的结论反直觉:不要在 C++ 项目里用深层嵌套的命名空间。每个项目只该有一个独特的顶级命名空间。命名空间是对 C 头文件设计缺陷的脆弱变通,本身还带来"脚底开枪"的风险。
原文对头文件的评价最重:1970 年代为了省内存做的一个决定,折磨了几代程序员,造成了数十亿美元的浪费和"数百万小时的集体人类心理痛苦"。作者用的词是"反人类罪",是对开发者的犯罪。他还补了一句:C 和 C++ 从来就不是为大型软件项目设计的。
模块(Modules)是官方解法,可语言太复杂,编译器实现困难,长期只有 MSVC 支持。有人开玩笑说,按这个进度,模块要到 2547 年才能用上。
没有标准编译器,没有标准构建系统,没有标准包管理器,没有标准 ABI。
在役的编译器至少三个:MSVC、GCC、Clang,各有扩展、各有 bug、各有优化脾气。维基百科说有三十一种。
ABI 是这里最要命的东西。API 说的是"你能调用什么",ABI 说的是"二进制层面怎么调用"——参数放寄存器还是栈、符号名怎么修饰、虚表怎么排布。C++ 没有标准 ABI,同一个库用不同编译器版本编出来都可能链不上。
所以大量 C++ 库选择套一层 C 接口发布。C 才是系统编程事实上的互操作层——哪怕你只想写 C++,也躲不开一点 C。
CMake 是事实标准,也是被骂得最多的工具。它有自己的脚本语言,既不是声明式也不是函数式;作用域规则反常;变量展开不可预测;错误信息不友好;为了向后兼容保留了好几套写法。学它要读一本七百页的书——为了构建一个 hello world。
包管理则是另一个故事:vcpkg、Conan、Hunter,没有标准,只能祈祷你要的库在里面。作者用 vcpkg 踩过一个坑:它默认下载 32 位版本,而项目是 64 位,构建时报出一堆完全看不懂的错,查了很久才发现根因。
于是 header-only 库流行起来了:整个库就一个头文件,复制粘贴即可使用。它流行的原因不是优雅,而是集成第三方库太痛苦。代价是每次 #include 都要把头文件里几万行从头编译一遍。原文的说法是:header-only 这么流行,是"C++ 的依赖管理方法有严重问题"的一个明确迹象。它也没解决依赖冲突和宏的问题。
原文对默认设置的批评最集中。它讨论的不是"哪条语法难看",而是"这门语言把安全设成了要额外付费的选项"。
const。所以 const 像垃圾邮件一样撒满整个代码库。Rust 反过来:默认不可变,要改得写 mut。int x; 不初始化就是内存里的残留值,读它是未定义行为。合理的默认是 0 和 nullptr,真在意性能的人再显式要求"别初始化"。void feed(Animal a); 之后 feed(5); 能编译通过。修法是给构造函数加 explicit——每个本该默认的语义,都要你手动补一个关键字。delete 派生类对象是未定义行为,通常表现为内存泄漏。switch 的 case 默认贯穿,要自己写 break。vector 的 operator[] 不检查越界,越界即未定义行为;会检查的版本叫 .at(),但大多数人不用,因为它"慢"。[[nodiscard]] 是个好特性,忽略返回值就警告。可它本该是默认行为,不想被警告的人再写 [[discardable]] 才对。原文的总结是:它对琐碎的操作极度啰嗦,对昂贵的操作保持沉默。
拷贝是最典型的例子。a = b 这一行,可能是浅拷贝(共享指针),可能是深拷贝(复制 100MB 内存),也可能触发一次数据库查询——语法上看不出来。想知道一次函数调用发生了几次拷贝,你得读懂拷贝构造、移动构造、返回值优化、隐式转换构造这一整套规则。反过来,把一个 int 转成 long,你要敲 static_cast<long>(x),还得祈祷类型没写错。
隐式转换同样危险。原文举的例子是:一组同名重载函数,一个收字符串、一个收 bool,你传了一个字符串字面量,结果走进了 bool 版本——因为字符串字面量可以先转成 const char*,再转成 bool。而在金融、医疗这类系统里,一个 64 位 ID 被存进 32 位变量,高位静默截断,不报错不崩溃,数据就这样烂掉了。
还有调用点的问题:C++ 没有 Rust 那样的引用语法,你光看调用处无法知道传进去的参数会不会被改,必须回去查函数签名。
编译的时候,你会见到错误信息。C++ 能把一个放错的字符变成一千行几乎读不懂的垃圾,真正的原因埋在中段。等你挖出来,脑子已经放弃了——因为输出里一半是标准库内部实现泄漏出来的东西。
模板实例化的错误读起来像一门用尖括号写成的、看不懂的中文方言。它横向拉得那么长,4K 显示器都放不下。作者不是开玩笑:他是看了这些错误之后,才开始理解超宽屏的意义。中间有一段时间他干脆关掉了自动换行,因为自动换行只会让错误更难读。难怪那么多 C++ 开发者最后都有超宽屏、眼镜和慢性颈椎病。
模板不是代码。当你提供具体类型时,编译器通过把那些类型替换到定义中来实例化它,然后才检查生成的代码有没有错。它会把整个模板实例化,把每一处出现都替换成你的类型。
现在想象真正的问题藏在一个算法深处,因为你的类型不满足 sort 的要求。等编译器发现错误时,它已经展开了十层模板,而回到根因的唯一路径,就是把整条实例化链倒在你屏幕上。
某种意义上,这是编译期的鸭子类型:模板内部的操作只要合法就能工作。副作用是鸭子类型的报错风格——问题不在你写错的地方冒出来,而是在别人的库深处、真正用到那个操作的地方冒出来。模板根本不知道它在那里调用的是什么,因为它还不是代码,它只检查交给它的东西合不合手。
三十年来,模板没有办法表达自己的要求。你写不出"这个模板需要一个可比较的类型",因为在鸭子类型下,要求永远是隐含的。编译器也没法说"你违反了第 X 条要求",因为这条要求在任何地方都不存在。它最多能把你拖到 <algorithm> 深处第 4212 行,指着说你的类型没定义 operator<;为了让你相信问题真从那儿开始,它还得把整条实例化栈倒出来。
concepts 就是那个终于能给这些要求命名的特性。它的根在 Stepanov 八十年代末提出的非正式概念,本来排在 C++0x 里,结果因为设计太复杂被委员会从 C++11 里拿掉了,直到 C++20 才落地——所以我们现在才写 requires。
过去二十年,C++ 一直把自己营销成"零成本抽象"的语言。但每一种抽象都有成本。
以 std::unique_ptr 为例:它比裸指针慢,因为它有一个非平凡的析构函数,而在 Itanium ABI 下,这意味着它不能通过寄存器传递,只能走栈——裸指针本来是可以进寄存器的。
不止智能指针。任何有非平凡析构函数的类型都一样:shared_ptr、string、vector,按值传递时都会经过内存。移动语义也不是免费的:真正的成本来自析构函数——C++ 用的是非破坏性移动,被移走的对象仍然要跑一遍析构,而精心手写的代码可以比等价的移动实现更快。
标准库的正则表达式是出了名的差。某些情况下比替代方案慢几十甚至上百倍,光是 #include <regex>,就能给每个翻译单元加上大约一秒的编译时间。
unordered_map 也算不上快:它对缓存不友好,性能真正重要的场合,开发者会去用 absl 的 flat_hash_map 或者 Folly 的 F14。
看出规律了吗?C++ 里很多东西本可以快得多,但大概永远不会。因为让它们变快会破坏 ABI 兼容——这就说到了正题。
上面所有抱怨——别扭的名字、慢的容器、static 动物园、看不见的拷贝——最后都指向同一个结论。
人们以为 C++ 把性能放在第一位。实际上,它的最高优先级是向后兼容。性能排第二,开发体验排第二,整体编程体验排第二,所有东西都排第二。
正是这个对兼容性的承诺,把语言变成了今天这个怪物。vector 改不了名,因为几十亿行代码会挂;unordered_map 没法显著提速,因为那会改 ABI;破坏性移动语义更是想都别想——那个窗口十几年前就错过了,破坏现有代码根本不在桌面上。
语言里每一处丑陋,都是某个早已被遗忘的设计决定石化后的结果。你删不掉它,因为已经有东西靠在上面:某个人的库、某个引擎、某个应用,或者一整条构建流水线。
讽刺的是,人们批评 C++ 的那个特性,也正是它支撑起半个世界软件的原因。向后兼容既是这门语言最大的缺陷,也是它活下来的关键。你二十年前写的代码,今天往往还能编译——稍微调一调,偶尔献祭点什么。2008 年就废弃的库,还能链到现代应用上。对游戏这种重写一遍要花几十人年的行业,这不是缺点,这是承重墙。
评论区一直有人问怎么看 Rust。希望这次不要再变成一场语言战争——它只是另一门语言。
从设计上看,Rust 好得多。它有标准编译器、标准构建系统、标准包管理器,没有头文件。作者见过的最好的编译错误信息、合理的默认值、没有隐式转换、正确的 UTF-8 支持、sum type、编译期内存安全。C++ 还没解决、而且很可能未来十年也解决不了的问题,很多在 Rust 里早就处理掉了。
但"设计更好"不等于"就该选它"。
游戏开发靠的是快速迭代、创意上的混乱,以及"我们试试这样会怎么样"。Rust 不太容得下这种风格——公平地说,现代 C++ 也不容了,不管每个新标准往上堆多少特性。这也是游戏开发越来越多转向脚本语言、DSL 和声明式编程的原因之一。
Rust 的核心是正确性和纪律,这就产生了根本性的张力。越来越多的游戏项目用 Rust 起步,然后正是因为这一点离开了它。
然后是生态。不管你怎么绕,CUDA、游戏引擎、工具链、几十上百亿行现成代码,全都围绕 C++。这一点短期内不会变。
C++ 是一门糟糕的语言。该啰嗦的地方不啰嗦,不该沉默的地方沉默。它带着一个类型动物园、一堆说谎的关键字、看不见的拷贝、读不懂的错误信息,以及一个直接从地狱里搬出来的构建系统。
写好的 C++ 需要对"规则的例外"有百科全书式的记忆;等你把这些例外背下来,还得再学"例外的例外"。
可 C++ 活得很好,而且很可能再活几十年。它有巨大的惯性,是少数把向后兼容放在第一位的语言,代价可能是其他一切。正是这一个决定,让 C++ 同时变得不可忍受和不可替代。今天半个软件世界跑在它上面,而且还会跑很久,不管我喜不喜欢。
作者说自己写这门糟糕的语言,把它的复杂性浪漫化,以此向自己证明自己聪明。他还会继续写,因为在他的领域里,它是目前唯一能提供所需性能的语言。它已经成了一堵承重墙。在一栋有人住、还在不停翻修的房子里换掉这堵墙,不是"用时髦语言重做几个房间"那么简单——你得把整栋楼推倒重建,自己先在棚子里住上两年。
所以,是的,C++ 是一门糟糕的语言。现在,打开你那个糟糕的 IDE,继续用世界上最糟的语言写代码吧。
本文整理自 Sergey Kushnirenko 为 PVS-Studio 撰写的文章《The worst programming language of all time /s》(2026-09-04),及其讨论的同名 YouTube 视频。观点属于原作者,事实细节经过核对,篇幅做了归并与取舍,未改动原意。
往期推荐:
感谢你读到最后,帮我点个“赞” + “推荐”,并“分享”给更多人吧。
学编程有问题,欢迎加我微信聊聊:lh35221199