true 的补码是 true,除非它不是
摘要
一篇分析 WG21 提案 P4313R1(C++ 位掩码枚举操作)的博客文章,探讨了在小整数类型和 bool 上执行位运算(例如 ~true)时,整型提升与布尔转换所带来的陷阱。
<p><a href="https://lobste.rs/s/4bzoft/complement_true_is_true_except_when_it_s">评论</a></p>
查看缓存全文
缓存时间: 2026/10/04 13:00
# 真的补码是假的,除了它是真的时候
来源:https://dryperspective.github.io/posts/complement-of-true/
我最近读了 [P4313R1](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/p4313r1.html),这是一份标准提案论文,它为枚举添加了一组位掩码(bitmask)操作,通过一个 C++26 标注(annotation)来选择启用。核心思路是,用论文中的例子来说,给定如下代码:
```cpp
enum class [[=std::bitmask_type]] Permission
{
None = 0,
Read = 1 << 0,
Write = 1 << 1,
Execute = 1 << 2,
};
```
`[[=std::bitmask_type]]` 这个标注会自动赋予 `Permission` 一组可用的位运算,这样你就无需自己把这些运算手写出来。
这让我想到了 C++ 整数运算中那片阴暗的角落。你的 C++ 编译器会很乐意把任何整数类型的位运算作为内建运算来计算。这包括那些我们传统上并不视为整数的类型,比如 `wchar_t`、UTF 字符类型 `char8_t` 到 `char32_t`,以及 `bool`。
但这里发生的事情比你看到的要多一些。因为当你尝试执行类似 `a | b` 的运算,而 `a` 和 `b` 的类型是小于 `int` 的整数类型时,语言并不会直接对 `a` 和 `b` 的位模式进行操作。它们会经历*整数提升(integral promotion)*——被提升到 `int` 作为中间状态,这两个 `int` 的位模式被合并,然后结果仍然以 `int` 的形式返回给你。[^1]
考虑下面这段代码:
```cpp
// 两个 short
constexpr short perm_A {1 << 0};
constexpr short perm_B {1 << 1};
// 对它们进行位运算的结果类型是 int
static_assert(std::same_as);
```
就大多数情况而言,这是无害的——如果你把上面的 `perm_A | perm_B` 强制转换回 `short`,多余的字节会被截断掉,你最终得到一个 `short`,它所包含的值正好等于你直接把 `perm_A` 和 `perm_B` 作为 `short` 合并时的值。而且如果你想要确定自己保持了类型的一致性,避免静默窄化转换(narrowing conversion)这种阴险的 bug,你可以养成这样的习惯:把位运算的结果 `static_cast` 回其原始类型。
不过这里的关键是,整数提升并非可选的。与 C++ 中大多数其他领域不同,开发者没有选择余地——你的类型在进行这些运算时不可避免地会被提升。
使 `bool` 变得特别危险的第二部分是*布尔转换(boolean conversion)*,它是一种特殊情况,不会截断,而是显式地把零转换为 `false`,把非零值转换为 `true`。对于这些非零值,之前存储的任何位模式都会被丢弃,取而代之的是 `true`,其整数值为 1。
因此,如果我们看这样的代码:
```cpp
int x{10};
bool b{static_cast(x)};
```
并查看生成的汇编(这里来自未优化的 x86-64 gcc 16.2):
```asm
mov DWORD PTR [rbp-4], 10 ; 存储值 10
cmp DWORD PTR [rbp-4], 0 ; 然后与 0 比较,若 x 为零则置 ZF
setne al ; 若 ZF 未置位则向 AL 写入 1
mov BYTE PTR [rbp-5], al ; 存储结果
```
标准(具体见 [[conv.bool]](https://eel.is/c++draft/conv.bool))把转换到 `bool` 建立在 `bool` 能够持有的唯一可能取值之上——`true` 和 `false`,无论最初是用什么位模式创建它们的。
## 综合起来
现在我们已经讲完了所有这些,让我们来梳理一下当你尝试计算 `~true` 然后把结果转换为 `bool` 时会发生什么:
- 值 `true` 被提升为值为 `1` 的 `int`。
- `1` 作为 `int` 的补码被计算为 `-2`,因为自 C++20 起必须使用二进制补码(two's complement)行为。
- 然后 `-2` 的值被转换回 `bool`,经历布尔转换,由于 `-2` 是非零的,因此变成 `true`。
这就是结论:`true` 的补码是 `true`,用 C++ 拼写出来就是 `static_cast(~true) == true`。
这让我们回到了枚举。枚举被允许使用任何整数类型作为其底层类型,包括我们的好朋友 `bool`。所以让我们来定义一个:
```cpp
enum class [[=std::bitmask_type]] boolean : bool
{
FALSE,
TRUE,
};
```
我们再来看看 P4313R1 中给出的按位取反运算符:
```cpp
template
constexpr T operator~ (T lhs) noexcept
{
return static_cast(~to_underlying(lhs));
}
```
到此为止,那个运算符的工作原理你应当已经熟悉了——首先我们将枚举转换为其底层类型(在我们的例子中是 `bool`),然后如果该类型的等级低于 `int`,就会应用整数提升,接着我们执行位运算,最后把结果转换回枚举类型。
如我们所料:
```cpp
static_assert(~boolean::TRUE == boolean::TRUE);
```
[Godbolt 在这里](https://godbolt.org/z/PW1EEvMex)。
这完全有可能成为语言中一个稍显费解的边界情况。这里还有一种特殊情况使问题进一步复杂化。如果我们尝试在 gcc 中运行同一个例子,我们会得到不同的结果:
```cpp
static_assert(~boolean::TRUE == boolean::FALSE);
```
[Godbolt 在这里](https://godbolt.org/z/xWzjarEz8)。
那么 gcc 是怎么回事?如果我们把运算移到运行时,定义两个依赖它的函数,该值在运行时给出:
```cpp
enum class boolean : bool
{
FALSE,
TRUE,
};
void f(int x, bool& out)
{
out = static_cast(x);
}
void g(int x, boolean& out)
{
out = static_cast(x);
}
```
然后查看汇编(同样是没有优化的 x86-64),我们得到:
```asm
"f(int, bool&)":
push rbp
mov rbp, rsp
mov DWORD PTR [rbp-4], edi
mov QWORD PTR [rbp-16], rsi
cmp DWORD PTR [rbp-4], 0
setne dl ; 与之前 [conv.bool] 中相同的 setne 模式
mov rax, QWORD PTR [rbp-16]
mov BYTE PTR [rax], dl
nop
pop rbp
ret
"g(int, boolean&)":
push rbp
mov rbp, rsp
mov DWORD PTR [rbp-4], edi
mov QWORD PTR [rbp-16], rsi
mov eax, DWORD PTR [rbp-4]
and eax, 1 ; 将最低位存储在 eax 中
mov rdx, QWORD PTR [rbp-16]
mov BYTE PTR [rdx], al ; 并将 al 移动到输出参数
nop
pop rbp
ret
```
我们看到的是:当类型不是拼写为 `bool` 时,gcc 会截断到最低位,而不是执行布尔转换。任何偶数在向下转换时都会产生 `boolean::FALSE`,而任何奇数都会产生 `boolean::TRUE`。
这对枚举类型来说是特有的,gcc 在直接处理 `bool` 时通常表现一致:
```cpp
constexpr boolean b{boolean::TRUE};
static_assert(static_cast(~b) == false);
static_assert(static_cast(~true) == true);
static_assert(std::to_underlying(~b) == false);
static_assert(static_cast(~std::to_underlying(b)) == true);
```
相比之下,Clang 和 MSVC 会把这四个取反加转换组合的全部结果都求值为 `true`,而这正是标准规定它们必须如此。完整的 [godbolt 对比在这里](https://godbolt.org/z/5vK3zM7Y9)。
这看起来是 gcc 中一个存在了相当长时间的一致性 bug。
但标准中有一个地方,整数提升规则走得更远,在进行这些位掩码运算时为未定义行为(UB)进入你的程序开辟了一个新的途径。
考虑这段代码:
```cpp
enum nums
{
zero,
one,
two,
three,
};
// 这是实现定义的,但在 gcc 和 Clang 上都成立
static_assert(std::is_same_v, unsigned int>);
// nums 使用 unsigned int 作为其基础,因此可表示值的整个域都是 >= 0 的
// 所以我们来测试一下:
static_assert(~one >= 0); // 失败
```
[Godbolt 在这里](https://godbolt.org/z/csW7GarKc)
查看诊断信息,gcc 给我们的是:
```text
:15:20: error: static assertion failed
15 | static_assert(~one >= 0); // 失败
| ~~~~~^~~~~
| 该比较化简为 '(-2 >= 0)'
```
那么这里发生了什么?标准中涉及整数提升的段落 [[conv.prom]](https://eel.is/c++draft/conv.prom#3) 专门为没有固定底层类型的非作用域枚举类型划出了一个特殊条款,使其在提升时的行为与整数类型不同。
如果整个值域可以存储在 `int` 中,那么它就提升为 `int`,然后尝试 `unsigned int`,如果也不行,就对 `long` 和 `long long` 重复这种先有符号后无符号的模式,直到找到一个合适的类型。
但是,与普通整数类型不同的是,它只考虑可表示值的*有效范围*;因此,一个以 `unsigned int` 为支撑的枚举,即使按正常的转换规则这在整数类型中是被禁止的,它仍然会提升为 `int`。
和之前一样,你通过 `~one` 调用内建运算符这一事实会不可避免地把它提升为 `int`,其补码被计算为 `-2`,然后两个 `int` 之间进行比较,于是失败了。
如果你改为先转换到底层类型,你就会真正看到这种不对称性——`static_assert(~std::to_underlying(one) >= 0);` 成立,而且它空洞地成立,以至于 gcc 甚至会警告它的冗余性。
但这只是战斗的一半,我们还需要谈论把位运算的结果转换回枚举类型,而 UB 就是在这里悄悄潜入的。
一个没有指定底层类型的非作用域枚举,其定义方式基于一个由其枚举子(enumerator)独立确定的有效值域,而与编译器实际用来支撑它的任何类型的范围无关。[[dcl.enum]](https://eel.is/c++draft/dcl.enum) 告诉我们,这样的枚举的值域是一个假想的整数类型 M 位宽度的值域,其中 M 是表示所有枚举子所需的最小位数。
为了说明,考虑几个例子:
```cpp
enum small
{
// 枚举子的范围是 0..1,因此值域是无符号一位整数的值域
a = 0,
b = 1,
};
enum medium
{
// 枚举子的范围是 0..7,因此值域是无符号三位整数的值域
c = 0,
d = 4,
e = 7
};
enum large
{
// 枚举子的范围是 -1..100,因此值域是带符号八位整数的值域
f = -1,
g = 10,
h = 100,
};
```
尽管你的编译器很可能把这些枚举存储为 `unsigned int` 和 `int`,但只有其中一部分可能的可表示值是可以合法使用的——即那个 M 位整数的值域。标准中的 [[expr.static.cast]](https://eel.is/c++draft/expr.static.cast#8) 明确指出,将该范围之外的值强制转换到枚举类型属于未定义行为。
所以,使用上面例子中的枚举子:
```cpp
static_cast(1); // 定义良好
static_cast(2); // UB
static_cast(3); // 定义良好:虽然不是枚举子的值,但在无符号三位整数的范围内
static_cast(8); // UB
static_cast(-128); // 定义良好
static_cast(128); // UB
```
这就是我们的危险区域。位运算符,尤其是 `operator~`,可能产生超出 `enum` 定义良好值域的值,而试图把这个值向下强制转换回枚举类型的用户自定义运算符就会引发 UB。
不过,你可能会喊了:之前 `~one` 的例子呢?我们看到它给出了 `-2`,这超出了 `nums` 的值域。这确实如此,但这里正是整数提升真正拯救了我们的地方——`one` 在我们计算其补码之前就已经被提升为 `int` 了,它从未被再次向下转换回枚举类型去触发我们的 UB。我们只有在用户自定义的运算符把运算的结果向下转换回原始枚举类型时,才会进入危险的领域。
同样值得注意的是,这种 UB 风险只适用于没有固定底层类型的非作用域"普通"枚举。所有作用域枚举(scoped enum)类型都有固定的底层类型,即使它们没有指定(这种情况下是 `int`);而所有指定了固定底层类型的非作用域 `enum` 类型都会继承该类型的值域,而不是自创一个。
## 在你自己的代码中避免这种情况
假设你像 P4313 那样,正在为自己的代码给枚举添加位掩码运算。既然我们已经发现了 C++ 这个领域中更多的怪异之处,你该如何确保自己的代码既正确又不令人困惑?
避免 `bool` 的情况很简单——只要用约束(constraint)排除底层类型为 `bool` 即可,无论是对所有枚举都排除,还是只对取反运算符排除。但标准并没有提供方便的类型特性(type trait)或反射元函数来专门检测没有固定底层类型的非作用域枚举。
幸运的是我们可以自己造一个:
```cpp
template concept unfixed_enum =
std::is_enum_v && !requires { E{0}; };
```
[[dcl.init.list]](https://eel.is/c++draft/dcl.init.list#3.8) 只允许对具有固定底层类型的枚举以这种方式(花括号初始化列表)从标量进行初始化,而 0 是对所有可能的枚举都可表示的唯一可能取值。为了覆盖边界情况,标准把一个没有枚举子的枚举定义为具有无符号一位整数的值域;而把 1 排除在可能取值之外的是 `enum E{ a = -1 };`,其范围是 `[-1, 0]`。
务必不要忘记 `std::is_enum_v`。毕竟,有很多类型对 `T{0}` 是非法的(ill-formed),而它们中的大多数并不是枚举。
本文主要聚焦于按位取反运算符,但无固定底层类型的枚举的 UB 陷阱同样适用于按位左移运算符。如果你选择按运算符逐个约束的路线,别忘了这一点。
这再次把我们带回了 P4313R1。在撰写本文时,约束这些运算符的概念只是把类型约束为用 `[[=std::bitmask_type]]` 标注过的某种枚举类型。因此,它会在由 `bool` 支撑的枚举类型上允许令人困惑的行为,以及在没有固定底层类型的普通枚举上存在潜在的 UB。
如果作者们不想把上面那个花括号初始化列表的技巧标准化,他们可以把它约束在 `std::is_scoped_enum` 上,作为一种保守的做法,防止用户轻易接触到 UB,因为所有非作用域枚举本来就可以使用内建的位运算符(尽管返回的是 `int`)。他们也可以把底层类型约束为不能是 `bool`,以减少困惑;特别是因为,如果来自系统头文件,在用户代码中对 `bool` 进行取反时通常会发出的诊断信息会被默认抑制。
我确实打算联系 P4313 的作者,看看他们是否愿意在他们的论文中加入这些约束。
## 附带话题:浮点数怎么办?
你可能会好奇标准如何定义浮点数到这些由 `bool` 支撑的 `enum` 的转换。也许不出所料——[[expr.static.cast]](https://eel.is/c++draft/expr.static.cast#8) 要求这种行为等价于先把浮点值转换为枚举的底层类型,然后再把它转换为枚举类型;并把用户指向 [[conv.fpint]](https://eel.is/c++draft/conv.fpint#note-1),那里有一条显式注释把读者引向我们老朋友 [conv.bool]。
按照标准,这应该意味着除了精确的 `0.0` 或 `-0.0` 之外,任何浮点值都会转换为 `boolean::TRUE`,否则我们就会回到 `boolean::FALSE`。
那让我们从小处开始:
```cpp
enum class boolean : bool
{
FALSE,
TRUE,
};
static_assert(static_cast(0.0) == boolean::FALSE);
static_assert(static_cast(0.5) == boolean::TRUE);
static_assert(static_cast(2.5) == boolean::TRUE);
```
[Godbolt 在这里](https://godbolt.org/z/1aK8Kfadv)。
Clang 和 gcc 都拒绝了这段代码。错误信息是 `(boolean)2.5e+0` 不是常量表达式;以及 `static_cast(0.5) == boolean::TRUE` 是错的,它等于 `boolean::FALSE`。
MSVC 接受了上面的代码。但让我们进一步深入,检查那里实际存储了什么。我们写一个函数来检查这些转换产生的位模式,然后尝试一些值:
```cpp
void show(double d)
{
const boolean e = static_cast(d);
unsigned char byte {};
std::memcpy(&byte, &e, 1);
std::println("static_cast({:7.1f}) stored byte {:3} required {}",
d, byte, (d != 0.0) ? 1 : 0);
}
int main()
{
show(0.0);
show(0.5);
show(1.0);
show(2.5);
show(3.0);
show(256.0);
show(-2.5);
}
```
[Godbolt 在这里](https://godbolt.org/z/Phd
相似文章
将布尔标志压缩至11位
本文讨论了一种将布尔标志压缩至11位的方法,重点在于高效的数据编码技术。
写给 Rust 程序员的 C 语言
一篇由 Rust 程序员撰写的博文,记录了其自学 C 语言过程中遇到的各种奇特行为,包括通过 <stdbool.h> 实现布尔类型、以 null 结尾的字符串与 Rust 中长度前缀的 &str 之间的对比,以及相关的内存权衡。对于从 Rust 转向 C 的开发者来说,它是一份实用的配套指南。
编译为无的掩码:HotSpot的JIT如何学会推理位
本文解释HotSpot的C2 JIT编译器如何使用“已知位”抽象来跟踪整数中哪些位确定是0或1,从而实现消除冗余按位与操作等优化。
C语言中在C++中仍然无法工作的构造——以及一些已发生变化的构造
一篇更新经典调查的博文,关于C语言中在C++中无法工作的构造,涵盖了C++20和C23标准中影响兼容性的变化。
@charliermarsh: ty 现在可以检测始终为真或始终为假的条件。经典示例:在 if 语句中忘记调用函数。
ty 新增了检测代码中始终为真或始终为假条件的功能,有助于防止常见错误,例如在 if 语句中忘记调用函数。