Intro

在编程中我们会听到或者看到一个概念:“未定义行为(Undefined Behavior, 简称 UB)”. 什么是所谓的未定义行为, 会产生什么后果, 如何能避免? 本文将系统地探讨未定义行为的含义, 后果及规避方法

如何正确认识 UB

对"未定义行为"的字面理解就是: 这个行为没有被具体说明. 举个例子, 如果读到了 std::vector<T> 的末尾会发生什么?

可能得结果有:

• 读取操作可能返回完全有效的 T
• 或者可能返回非 T 的值
• 程序可能在运行时崩溃
• 读取操作可能会被编译器优化掉(删除掉)

因为根据 C++ 标准:

reading past the end of std::vector is undefined behavior

读取超过 std::vector 末尾的内容是未定义的行为

因为没有做具体说明, 所以编译器可以做很多选择. 然而这些选择不一定是编写代码的程序员所期望的.

有多少未定义行为?

举个例子, 用 26 个英语字母作组合可以产生非常多单词. 排除掉字典里面定义的单词, 其他的单词可以被认为是"未定义的", 可想而知这些未定义的情况非常多的.
同样的, C++语言中的 UB 的具体 case 也会非常多, 不可枚举.

对 UB 的误解

一些常见的误解如下:

• 良好的测试将捕获 UB: 尽管测试可以帮助发现部分问题, 但由于测试覆盖率不足或测试环境与实际运行环境的差异, UB 可能在测试中未被触发. 例如, 某些 UB 仅在特定输入或硬件平台上显现, 因此良好的测试并不能保证捕获所有 UB.
• 更好的编译器会将 UB 报告为错误: 编译器主要在静态分析范围内工作, 能检测的未定义行为是有限的. 许多 UB 需要在运行时动态触发, 例如特定输入条件或程序状态下才会显现, 这超出了编译器的检测能力.
• 经验丰富的开发人员永远不会遇到糟糕的 UB
• 调试 UB 只需要一点练习

后续的例子中我们将会消除这些迷思.

C++ 标准定义的几种行为

C++标准中定义了如下几种行为:

1. 定义的行为 (defined behavior)

具有明确或精确含义的代码, 比如:

• int sum = 17 + 8;
• printf("Welcome to CppCon 2021");
• auto [first, second] = getPair();

2. 实现定义的行为 (implementation defined behavior)

代码可以有多重含义, 但编译器必须选定一种并始终保持该选择.
请看下面的代码:

if ( sizeof(int) < sizeof(long) ) { }

C++ 标准中规定了int最小要有 16bit, long最小要有 32bit. 具体 bit 位数会因为编译器/操作系统而有所不同, 常见的编译器 GCC, Clang, MSVC 指定了 sizeof(int) == 4, sizeof(long)

3. 未指定的行为 (unspecified behavior)

代码可能有多种含义, 编译器可以随机选择一个.
比如比较字符串字面量:

#include <iostream>

void fun(const char* key) {
  if (key == "name") {
    std::cout << "get name\n";
  } else {
    std::cout << "something else\n";
  }
}
int main() {
  std::string name = "name";
  fun("name");        // output: get name
  fun(name.c_str());  // output: something else
  return 0;
}

比较字面量在实际中被实现为比较指针. 而程序员预期的应该是字符串比较.

4. 未定义行为 (undefined behavior)

毫无意义的代码, 比如:

• 两次调用对象的析构函数
• 按负值进行位移位
• 当值太大时将双精度数转换为浮点数

阅读下面的代码思考一下这两个问题:

1. 下面的代码能通过编译吗?
2. 是否有 UB, 有的话指出具体行数.

#include <iostream>

int main() {
  int* p = nullptr;  // line 1
  *p = 42;           // line 2
  int b;             // line 3
  p = &b;            // line 4
  std::cout << *p;   // line 5
  std::cout << b;    // line 6
}

揭晓答案

1. 能通过编译
2. 有下面这些 UB
   • ( line 2 ) 解析空指针是 UB
   • ( line 5 和 line 6) 访问一个未初始化的变量 UB

C++ 中如何定义 UB

1. 所谓 UB 就是尝试去执行那种没有被 C++标准明确说明其行为的代码.
2. 只有当源代码没有 UB 时, 程序会按源代码所写的执行
3. 如果你的代码有 UB, 那么 C++ 标准将对其执行结果不做任何保证
4. 编写没有 UB 的代码是程序员的责任

UB 不是错误

• UB 和错误(Error)之间没有重叠
• 被定义为错误的东西不是 UB
• UB 不是你的代码可以测试的东西

常见 C++ UB 的部分列表

• 访问 std::vector 末尾以外的元素
• 解引用空指针
• 使用未初始化的变量
• 从构造函数或析构函数调用纯虚函数
• 在对象被销毁后使用它(释放后使用)
• 将指针转换为不兼容的类型, 然后使用
• 无副作用的无限循环
• 修改字符串文字或任何其他 const 对象
• 无法从值返回函数返回值
• 任何竞争条件
• 整数除以零
• 有符号整数溢出

软件设计理念

• 既然编译器可以做任何事情, 你不妨想象它会做一些坏事
• 如果你的代码适用于所有当前的编译器, 那么你所做的任何事情都可能成为标准的一部分
• 让人们以自己的方式尝试, 直到代码在测试期间崩溃
• 对于那些关心速度的人来说, UB 应该只作为一种可选功能存在
• 最终委员会将完成他们的工作并摆脱 UB
• 程序员应该提供在他们的代码库中使用 UB 的合理理由

编译器选项对 UB 的影响

当关闭编译器优化时

• 几乎不会对您的代码进行任何特殊处理
• 尽可能将您的代码翻译得接近字面意思
• 未定义的行为可能会按照您的预期执行, 因此您的代码似乎按预期运行

通常会启用优化

• 可以删除无法访问的代码
• 编译器无需诊断未定义的行为
• 代码可以"内联", 然后进行优化
• 当程序具有未定义的行为时可能会产生意外结果

如何消除 UB

1. 借助工具

   • Address Sanitizer
   • Memory Sanitizer
   • Undefined Behavior Sanitizer
   • Thread Sanitizer

2. 代码审查, 制定专门检查 UB 的政策

3. 注意编译器警告

4. 使用多个编译器构建代码

5. 测试极端情况

6. 将 UB 视为严重错误

UB 举例

带符号的整型溢出

• 有符号整数运算: 如果结果超出可表示值的范围, 则会发生"有符号整数溢出", 这是未定义的行为
• 无符号整数运算: 根据标准, 此操作永远不会溢出, 并且是定义的行为

#include <iostream>

template <typename T>
T cubic(T len) {
  return len * len * len;
}

int main() {
  std::cout << "cubic signed: " << cubic(3000) << std::endl;     // UB
  std::cout << "cubic unsigned: " << cubic(3000u) << std::endl;  // OK
  return 0;
}

缺失 return 语句

一些编译器会发出警告, 一些清理程序会在运行时检测到. 程序执行过程中的常见结果

• 可能导致崩溃
• 每次都可能返回 true
• 可能会继续执行可执行文件中的"下一个函数"

#include <iostream>

bool baz() { return true; }
bool foo(int a, int b) { a == b; }
bool bar() { return false; }

int main() {
  int a = 1;
  int b = 2;
  std::cout << "a == b: " << foo(a, b) << std::endl;
  std::cout << bar() << baz() << std::endl;
  return 0;
}

迭代器在使用时被破坏

容器上的某些操作会使迭代器无效, std::vector::insert() 使所有迭代器无效.

• 基于范围的 for 循环中的迭代器被隐藏
• 当前迭代器在 insert 之后被破坏

#include <iostream>
#include <vector>

int main() {
  std::vector<int> vec = {1, 2, 3, 5, 6};
  for (auto &item : vec) {
    if (item == 3) {
      vec.insert(vec.begin(), 4);
    }
    std::cout << item << std::endl;
  }
  return 0;
}

修改const reference类型值

关键字 const_cast 删除对象的"常量性", 如果传递的参数最初被声明为 const, 则修改输入是未定义的行为

#include <iostream>
#include <string>

const std::string global = "Hello";

void fun(const std::string &input) {
  std::string &v = const_cast<std::string &>(input);
  v = "fun";
}

int main() {
  const std::string local = "World";
  fun(local);
  std::cout << local << std::endl;

  fun(global);
  std::cout << global << std::endl;
  return 0;
}

在std命名空间中增加代码

偏特化 std 命名空间中存在的类型特征是 UB. 编写自己的类型特征是完全可以接受的, 它们可以
位于除 std:: 之外的任何命名空间中.

#include <iostream>
#include <type_traits>

namespace std {
template <>
struct is_pointer<int> : public std::true_type  // defines a type trait as true
{};
}  // namespace std

int main() {
  bool var2 = std::is_pointer<int>::value;
  std::cout << std::boolalpha << std::is_pointer<int>::value << std::endl;
  return 0;
}

求值顺序

#include <iostream>

int main() {
  int a = 5;
  a = ++a + 2;  // C++03, undefined behavior
  a == 8;       // C++11 and newer, defined
  std::cout << "a: " << a << std::endl;

  int b = 3;
  b = b++ + 2;  // C++03 and C++11, undefined behavior
  b == 5;       // C++17 and newer, defined
  std::cout << "b: " << b << std::endl;
}

语法歧义

这个函数有未定义的行为吗?

#include <iostream>

template <typename T1, typename T2>
void fun(T1 &x, T2 &y) {
  x << y;
}

int main() {
  int a = 1;
  int b = 1000;
  fun(a, b);              // UB: 左移操作的移动位数超过了类型的宽度
  fun(std::cout, "cat");  // OK
}

我们看到这个例子中是否有 UB 取决于入参, 以及入参的具体值.

C++ 为了更明确模板的行为, 推出了新特性"Concept"概念, 用来约束模板参数. 方便开发者避免此类问题.

总结

• UB 不能被视为错误
• 处理 UB 并非是一个间歇性工作, 需要一直坚持
• UB 不是一个简单的话题
• 项目可以选择关闭 C++ 特性(如异常), 但你不能关闭 UB
• 处理 UB 是每个开发人员的责任, 选择 C++ 就等于接受了它

视频链接

• Back To Basics: Undefined Behavior - Ansel Sermersheim & Barbara Geller - CppCon 2021

源码链接

源码链接