C++ 表达式求值顺序与 SFINAE 陷阱：避免编译失败的技巧

好的，各位观众老爷们，大家好！今天咱们来聊聊C++里那些让人头疼，却又不得不面对的坑——表达式求值顺序和 SFINAE。这两兄弟，一个稍不留神就会让你程序的行为变得诡异莫测，另一个则会在编译期给你来个措手不及的“编译失败惊喜”。

咱们争取用最通俗易懂的语言，加上大量的代码例子，把这两个概念给掰开了、揉碎了，让大家以后遇到类似的问题，不再抓耳挠腮，而是能够淡定地抽根烟，优雅地解决。

第一部分：表达式求值顺序——薛定谔的运算结果

C++标准并没有规定大部分运算符的操作数求值顺序。这意味着，对于像 a() + b() 这样的表达式，你无法保证 a() 一定会在 b() 之前执行。 这听起来好像没什么大不了的，但如果 a() 和 b() 都对同一个全局变量进行了修改，那结果就完全不一样了！

1.1 顺序点和未定义行为

首先，我们需要了解“顺序点”这个概念。顺序点是指程序执行序列中的一个点，在该点之前的所有副作用都必须已经应用，并且在该点之后的所有副作用都还没有发生。 C++标准定义了一些顺序点，比如：

• 分号 ;
• 函数调用结束
• 逻辑运算符 && 和 || 的第一个操作数求值之后
• 条件运算符 ?: 的第一个操作数求值之后
• 逗号运算符 ,

如果两个操作数修改了同一个对象，并且它们之间没有顺序点，那么就会产生未定义行为 (Undefined Behavior, UB)。 UB可不是闹着玩的，它意味着你的程序可能崩溃，也可能输出错误的结果，甚至可能看起来一切正常，但实际上已经埋下了隐患。

1.2 例子：自增自减的陷阱

来看一个经典的例子：

#include <iostream>

int main() {
  int i = 0;
  int result = i++ + i++; // 未定义行为！
  std::cout << "result: " << result << ", i: " << i << std::endl;
  return 0;
}

这段代码的问题在于，i++ + i++ 中，i++ 出现了两次，并且它们之间没有顺序点。 编译器可以自由选择先执行哪个 i++，导致 result 和 i 的值在不同的编译器甚至不同的编译选项下都可能不同。 这就是未定义行为的可怕之处。

正确的做法是避免在同一个表达式中对同一个变量进行多次修改，或者显式地使用顺序点来控制求值顺序：

#include <iostream>

int main() {
  int i = 0;
  int temp1 = i++;
  int temp2 = i++;
  int result = temp1 + temp2;
  std::cout << "result: " << result << ", i: " << i << std::endl;
  return 0;
}

这样，我们就明确了 i 的自增顺序，避免了未定义行为。

1.3 函数参数求值顺序

函数参数的求值顺序也是未定义的。 这意味着，对于 func(a(), b())，你无法保证 a() 一定会在 b() 之前执行。

#include <iostream>

int global_var = 0;

int increment() {
  return ++global_var;
}

void func(int a, int b) {
  std::cout << "a: " << a << ", b: " << b << std::endl;
}

int main() {
  func(increment(), increment()); // 参数求值顺序未定义
  return 0;
}

在不同的编译器下，a 和 b 的值可能会互换。 为了避免这种不确定性，最好将函数参数的求值结果存储到临时变量中：

#include <iostream>

int global_var = 0;

int increment() {
  return ++global_var;
}

void func(int a, int b) {
  std::cout << "a: " << a << ", b: " << b << std::endl;
}

int main() {
  int a = increment();
  int b = increment();
  func(a, b);
  return 0;
}

1.4 总结：表达式求值顺序的黄金法则

• 避免在同一个表达式中对同一个变量进行多次修改。
• 不要依赖函数参数的求值顺序。
• 显式地使用顺序点来控制求值顺序，例如使用临时变量。
• 开启编译器的警告选项，例如 -Wall -Wextra -Wpedantic，可以帮助你发现潜在的未定义行为。

第二部分：SFINAE——编译期的优雅失败

SFINAE (Substitution Failure Is Not An Error) 是 C++ 模板编程中一个非常重要的概念。 简单来说，它指的是在模板参数推导或模板函数重载决议过程中，如果某个模板的特化或者某个重载函数由于类型不匹配等原因导致编译失败，编译器并不会立即报错，而是会继续尝试其他的模板特化或者重载函数。 如果所有的模板特化或重载函数都失败了，编译器才会报错。

2.1 SFINAE 的基本原理

SFINAE 的核心在于“延迟报错”。 编译器在编译期进行模板参数推导和重载决议时，会尝试不同的模板特化和重载函数。 如果某个特化或重载函数因为类型不匹配等原因导致编译错误，编译器会认为这个特化或重载函数不适用，然后继续尝试其他的选项。

2.2 例子：检查类型是否具有某个成员函数

SFINAE 最常见的应用场景之一是检查一个类型是否具有某个特定的成员函数。 例如，我们想编写一个模板函数，如果一个类型具有 size() 成员函数，就调用它，否则就返回一个默认值。

#include <iostream>
#include <vector>
#include <list>

template <typename T>
auto get_size(T& obj) -> decltype(obj.size(), size_t{}) {
  return obj.size();
}

template <typename T>
size_t get_size(...) {
  return 0;
}

int main() {
  std::vector<int> vec = {1, 2, 3};
  std::list<int> lst = {4, 5, 6};
  int num = 7;

  std::cout << "vector size: " << get_size(vec) << std::endl;
  std::cout << "list size: " << get_size(lst) << std::endl;
  std::cout << "int size: " << get_size(num) << std::endl;

  return 0;
}

在这个例子中，我们定义了两个 get_size 函数模板。 第一个模板使用 decltype 来检查类型 T 是否具有 size() 成员函数。 如果 T 具有 size() 成员函数，decltype(obj.size(), size_t{}) 的结果就是 size_t，函数返回 obj.size()。 如果 T 没有 size() 成员函数，decltype(obj.size(), size_t{}) 就会导致编译错误，但由于 SFINAE 的存在，编译器不会立即报错，而是会继续尝试第二个 get_size 函数模板，它是一个可变参数模板，可以匹配任何类型的参数，并返回 0。

2.3 std::enable_if：SFINAE 的瑞士军刀

std::enable_if 是 C++11 引入的一个模板类，它可以用来更方便地控制 SFINAE 的行为。 std::enable_if<condition, T> 的作用是：如果 condition 为真，则 std::enable_if<condition, T>::type 存在，类型为 T；如果 condition 为假，则 std::enable_if<condition, T>::type 不存在，导致编译错误，触发 SFINAE。

我们可以使用 std::enable_if 来重写上面的例子：

#include <iostream>
#include <vector>
#include <list>
#include <type_traits>

template <typename T>
typename std::enable_if<
    std::is_member_function_pointer<decltype(&T::size)>::value,
    size_t>::type
get_size(T& obj) {
  return obj.size();
}

template <typename T>
size_t get_size(T& obj) {
  return 0;
}

int main() {
  std::vector<int> vec = {1, 2, 3};
  std::list<int> lst = {4, 5, 6};
  int num = 7;

  std::cout << "vector size: " << get_size(vec) << std::endl;
  std::cout << "list size: " << get_size(lst) << std::endl;
  std::cout << "int size: " << get_size(num) << std::endl;

  return 0;
}

在这个例子中，我们使用 std::is_member_function_pointer 来检查类型 T 是否具有 size() 成员函数。 如果 T 具有 size() 成员函数，std::is_member_function_pointer<decltype(&T::size)>::value 的值为 true，std::enable_if 的 type 成员存在，类型为 size_t，函数可以正常编译。 如果 T 没有 size() 成员函数，std::is_member_function_pointer<decltype(&T::size)>::value 的值为 false，std::enable_if 的 type 成员不存在，导致编译错误，触发 SFINAE，编译器会选择第二个 get_size 函数。

2.4 std::void_t：简化 SFINAE 的利器

std::void_t 是 C++17 引入的一个模板别名，它可以用来简化 SFINAE 的代码。 std::void_t<T1, T2, ...> 的作用是：如果 T1, T2, ... 都是有效的类型，则 std::void_t<T1, T2, ...> 的类型为 void；否则，导致编译错误，触发 SFINAE。

我们可以使用 std::void_t 来进一步简化上面的例子：

#include <iostream>
#include <vector>
#include <list>
#include <type_traits>

template <typename T, typename = std::void_t<decltype(std::declval<T>().size())>>
size_t get_size(T& obj) {
  return obj.size();
}

template <typename T>
size_t get_size(T& obj) {
  return 0;
}

int main() {
  std::vector<int> vec = {1, 2, 3};
  std::list<int> lst = {4, 5, 6};
  int num = 7;

  std::cout << "vector size: " << get_size(vec) << std::endl;
  std::cout << "list size: " << get_size(lst) << std::endl;
  std::cout << "int size: " << get_size(num) << std::endl;

  return 0;
}

在这个例子中，我们使用 std::void_t<decltype(std::declval<T>().size())> 来检查类型 T 是否具有 size() 成员函数。 std::declval<T>() 可以构造一个类型为 T 的对象（但实际上不会调用构造函数）。 如果 T 具有 size() 成员函数，decltype(std::declval<T>().size()) 的结果是一个有效的类型，std::void_t 的结果就是 void，函数可以正常编译。 如果 T 没有 size() 成员函数，decltype(std::declval<T>().size()) 就会导致编译错误，触发 SFINAE，编译器会选择第二个 get_size 函数。

2.5 SFINAE 的应用场景

除了检查类型是否具有某个成员函数之外，SFINAE 还可以应用于很多其他的场景，例如：

• 重载函数模板： 根据不同的类型选择不同的函数实现。
• 静态断言： 在编译期检查某些条件是否满足。
• 类型萃取： 获取类型的某些属性，例如是否是指针类型、是否是整数类型等。
• 元编程： 在编译期生成代码。

2.6 SFINAE 的注意事项

• SFINAE 只发生在模板参数推导和重载决议过程中。 如果在模板函数内部发生编译错误，SFINAE 不会生效，编译器会直接报错。
• SFINAE 依赖于编译器的实现。 不同的编译器可能对 SFINAE 的支持程度不同。
• SFINAE 的代码可能会比较复杂，需要仔细设计。

2.7 总结：SFINAE 的精髓

• SFINAE 是一种编译期技术，用于在模板编程中处理类型不匹配等错误。
• SFINAE 的核心是“延迟报错”，编译器会尝试其他的模板特化或重载函数，直到找到一个合适的或者所有选项都失败。
• std::enable_if 和 std::void_t 是 SFINAE 的常用工具，可以用来更方便地控制 SFINAE 的行为。
• SFINAE 可以应用于很多场景，例如检查类型是否具有某个成员函数、重载函数模板、静态断言、类型萃取和元编程。

第三部分：实战演练——避免编译失败的技巧

现在，让我们通过一些实际的例子，来巩固一下我们今天所学的知识。

3.1 例子：根据类型选择不同的算法

假设我们想编写一个函数，根据不同的类型选择不同的算法进行排序。 对于支持随机访问迭代器的类型（例如 std::vector），我们使用 std::sort 算法；对于不支持随机访问迭代器的类型（例如 std::list），我们使用 std::list::sort 成员函数。

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <type_traits>

template <typename T>
typename std::enable_if<
    std::is_same<
        typename std::iterator_traits<typename T::iterator>::iterator_category,
        std::random_access_iterator_tag>::value,
    void>::type
sort_container(T& container) {
  std::sort(container.begin(), container.end());
  std::cout << "Using std::sort" << std::endl;
}

template <typename T>
typename std::enable_if<
    !std::is_same<
        typename std::iterator_traits<typename T::iterator>::iterator_category,
        std::random_access_iterator_tag>::value,
    void>::type
sort_container(T& container) {
  container.sort();
  std::cout << "Using container.sort()" << std::endl;
}

int main() {
  std::vector<int> vec = {3, 1, 4, 1, 5, 9, 2, 6};
  std::list<int> lst = {3, 1, 4, 1, 5, 9, 2, 6};

  sort_container(vec);
  sort_container(lst);

  for (int x : vec) {
    std::cout << x << " ";
  }
  std::cout << std::endl;

  for (int x : lst) {
    std::cout << x << " ";
  }
  std::cout << std::endl;

  return 0;
}

在这个例子中，我们使用 std::iterator_traits 和 std::is_same 来判断容器的迭代器类型是否是随机访问迭代器。 如果容器的迭代器类型是随机访问迭代器，我们就使用 std::sort 算法；否则，我们就使用 std::list::sort 成员函数。

3.2 例子：实现一个通用的 to_string 函数

假设我们想实现一个通用的 to_string 函数，可以将任何类型转换为字符串。 对于具有 to_string 成员函数的类型，我们直接调用该成员函数；对于其他的类型，我们使用 std::to_string 函数。

#include <iostream>
#include <string>
#include <sstream>
#include <type_traits>

template <typename T>
auto to_string_impl(T& obj, int) -> decltype(obj.to_string()) {
  return obj.to_string();
}

template <typename T>
std::string to_string_impl(T& obj, ...) {
  std::stringstream ss;
  ss << obj;
  return ss.str();
}

template <typename T>
std::string to_string(T& obj) {
  return to_string_impl(obj, 0);
}

class MyClass {
public:
  std::string to_string() const {
    return "MyClass object";
  }
};

int main() {
  int num = 123;
  double pi = 3.14159;
  MyClass obj;

  std::cout << "int to string: " << to_string(num) << std::endl;
  std::cout << "double to string: " << to_string(pi) << std::endl;
  std::cout << "MyClass to string: " << to_string(obj) << std::endl;

  return 0;
}

在这个例子中，我们使用了“逗号运算符”的技巧。第一个 to_string_impl 函数使用 decltype(obj.to_string()) 来检查类型 T 是否具有 to_string 成员函数。 如果 T 具有 to_string 成员函数，decltype(obj.to_string()) 的结果就是 to_string 函数的返回类型，函数可以正常编译。 如果 T 没有 to_string 成员函数，decltype(obj.to_string()) 就会导致编译错误，触发 SFINAE，编译器会选择第二个 to_string_impl 函数。

3.3 总结：避免编译失败的通用技巧

• 使用 std::enable_if 和 std::void_t 来控制模板的启用条件。
• 使用 decltype 和 std::declval 来检查类型是否具有某个成员函数。
• 利用重载决议的优先级，将更具体的模板放在前面，更通用的模板放在后面。
• 仔细阅读编译器的错误信息，可以帮助你找到 SFINAE 的问题所在。

第四部分：最后的总结和注意事项

好了，今天咱们就聊到这里。 表达式求值顺序和 SFINAE 是 C++ 中比较高级和复杂的概念，需要花时间和精力去理解和掌握。 希望通过今天的讲解，大家能够对这两个概念有一个更清晰的认识，并且能够在实际的编程中避免踩坑。

最后，再强调几点注意事项：

• 永远不要假设表达式的求值顺序。
• 开启编译器的警告选项，可以帮助你发现潜在的未定义行为。
• 仔细阅读 C++ 标准，可以帮助你更深入地理解语言的特性。
• 多写代码，多实践，才能真正掌握 SFINAE 的技巧。

感谢大家的观看，祝大家编程愉快，少踩坑！ 咱们下次再见！