未定义行为
来自 cppreference.com
如果违反了语言的某些规则，则会使整个程序变得毫无意义。
内容 |
[编辑] 解释
C++ 标准精确地定义了 可观察行为 的所有 C++ 程序，这些程序不属于以下类别之一
- 格式不正确 - 程序存在语法错误或可诊断的语义错误。
- 符合标准的 C++ 编译器需要发出诊断信息，即使它定义了语言扩展，将意义赋予此类代码（例如，使用可变长度数组）。
- 标准文本使用 应该、不应该 和 格式不正确 来指示这些要求。
- 如果执行此类程序，则行为未定义。
- 实现定义的行为 - 程序的行为在不同的实现之间有所不同，并且符合标准的实现必须记录每个行为的影响。
- 例如，std::size_t 的类型或一个字节中的位数，或 std::bad_alloc::what 的文本。
- 实现定义的行为的一个子集是 特定于语言环境的行为，它取决于实现提供的 语言环境。
- 未指定的行为 - 程序的行为在不同的实现之间有所不同，并且符合标准的实现不需要记录每个行为的影响。
|
(自 C++26 起) |
- 未定义行为 - 对程序的行为没有限制。
[编辑] UB 和优化
因为正确的 C++ 程序不包含未定义行为，所以当使用启用优化的编译器编译包含 UB 的程序时，可能会产生意外的结果。
例如，
[编辑] 有符号整数溢出
int foo(int x) { return x + 1 > x; // either true or UB due to signed overflow }
可能被编译为 (演示)
foo(int): mov eax, 1 ret
[编辑] 越界访问
int table[4] = {}; bool exists_in_table(int v) { // return true in one of the first 4 iterations or UB due to out-of-bounds access for (int i = 0; i <= 4; i++) if (table[i] == v) return true; return false; }
可能被编译为 (演示)
exists_in_table(int): mov eax, 1 ret
[编辑] 未初始化标量
std::size_t f(int x) { std::size_t a; if (x) // either x nonzero or UB a = 42; return a; }
可能被编译为 (演示)
f(int): mov eax, 42 ret
显示的输出是在较旧版本的 gcc 上观察到的。
运行此代码。
可能的输出
p is true p is false
[编辑] 无效标量
int f() { bool b = true; unsigned char* p = reinterpret_cast<unsigned char*>(&b); *p = 10; // reading from b is now UB return b == 0; }
可能被编译为 (演示)
f(): mov eax, 11 ret
[编辑] 空指针解引用
这些例子演示了从解引用空指针的结果中读取数据。
int foo(int* p) { int x = *p; if (!p) return x; // Either UB above or this branch is never taken else return 0; } int bar() { int* p = nullptr; return *p; // Unconditional UB }
可能被编译为 (演示)
foo(int*): xor eax, eax ret bar(): ret
[编辑] 访问传递给 std::realloc 的指针
选择 clang 来观察显示的输出。
运行此代码。
#include <cstdlib> #include <iostream> int main() { int* p = (int*)std::malloc(sizeof(int)); int* q = (int*)std::realloc(p, sizeof(int)); *p = 1; // UB access to a pointer that was passed to realloc *q = 2; if (p == q) // UB access to a pointer that was passed to realloc std::cout << *p << *q << '\n'; }
可能的输出
12
[编辑] 没有副作用的无限循环
选择 clang 或最新的 gcc 来观察显示的输出。
运行此代码。
#include <iostream> bool fermat() { const int max_value = 1000; // Non-trivial infinite loop with no side effects is UB for (int a = 1, b = 1, c = 1; true; ) { if (((a * a * a) == ((b * b * b) + (c * c * c)))) return true; // disproved :() a++; if (a > max_value) { a = 1; b++; } if (b > max_value) { b = 1; c++; } if (c > max_value) c = 1; } return false; // not disproved } int main() { std::cout << "Fermat's Last Theorem "; fermat() ? std::cout << "has been disproved!\n" : std::cout << "has not been disproved.\n"; }
可能的输出
Fermat's Last Theorem has been disproved!
[编辑] 格式错误，包含诊断信息
请注意，编译器被允许以赋予格式错误的程序意义的方式扩展语言。在这种情况下，C++ 标准唯一的要求是诊断信息（编译器警告），除非程序是“格式错误，无需诊断”。
例如，除非通过 --pedantic-errors 禁用语言扩展，否则 GCC 将编译以下示例 仅带警告，即使它 出现在 C++ 标准 中作为“错误”的示例（另请参见 GCC Bugzilla #55783）。
运行此代码。
#include <iostream> // Example tweak, do not use constant double a{1.0}; // C++23 standard, §9.4.5 List-initialization [dcl.init.list], Example #6: struct S { // no initializer-list constructors S(int, double, double); // #1 S(); // #2 // ... }; S s1 = {1, 2, 3.0}; // OK, invoke #1 S s2{a, 2, 3}; // error: narrowing S s3{}; // OK, invoke #2 // — end example] S::S(int, double, double) {} S::S() {} int main() { std::cout << "All checks have passed.\n"; }
可能的输出
main.cpp:17:6: error: type 'double' cannot be narrowed to 'int' in initializer ⮠
list [-Wc++11-narrowing]
S s2{a, 2, 3}; // error: narrowing
^
main.cpp:17:6: note: insert an explicit cast to silence this issue
S s2{a, 2, 3}; // error: narrowing
^
static_cast<int>( )
1 error generated.[编辑] 参考
| 扩展内容 |
|---|
|
[编辑] 参见
[[assume(expression)]](C++23) |
指定 expression 将始终在给定点处评估为 true (属性说明符) |
[[indeterminate]](C++26) |
指定如果对象未初始化，则它具有不确定的值。 (属性说明符) |
| (C++23) |
标记不可到达的执行点。 (函数) |
| C 文档 for 未定义行为
| |
