C++ 表达式 SFINAE (Expression SFINAE) 深度：基于表达式有效性的模板选择

哈喽，各位好！今天咱们要聊聊 C++ 里一个挺酷炫的技巧，叫做“表达式 SFINAE”。这玩意儿听起来好像很高深，但其实没那么可怕，它就是利用表达式的有效性来做模板的选择。简单来说，就是让编译器在编译的时候根据某个表达式能不能通过编译来决定到底用哪个模板函数或者类。

SFINAE 是个啥？

首先，咱们得搞清楚 SFINAE 是个啥玩意儿。SFINAE 全称是 "Substitution Failure Is Not An Error"，翻译过来就是“替换失败不是错误”。这可是 C++ 模板元编程的核心概念之一。

这句话的意思是说，当编译器在尝试用某些类型去替换模板参数，导致某个表达式编译失败时，编译器并不会直接报错，而是会悄悄地把这个模板从候选列表中移除。然后，编译器会尝试用其他的模板，直到找到一个合适的，或者候选列表为空，这时才会报错。

表达式 SFINAE：让表达式说话

表达式 SFINAE 就是利用了 SFINAE 的这个特性，让一个表达式的有效性来决定模板的选择。具体来说，我们会在模板的声明中使用一些技巧，让编译器在特定的情况下，因为某个表达式编译不过而把这个模板排除掉。

怎么玩转表达式 SFINAE？

最常用的方法就是利用 decltype 和 std::void_t。

• decltype：探测表达式类型

  decltype 可以返回一个表达式的类型。如果这个表达式不能编译，那么 decltype 就会导致 SFINAE 发生。

• std::void_t：制造 SFINAE 的利器

  std::void_t 是 C++17 引入的一个模板，它的作用是把任意类型列表变成 void。如果类型列表中的任何一个类型无效，那么 std::void_t 就会导致 SFINAE 发生。

  template<typename...>
  using void_t = void; // C++17 之前的实现

实战演练：判断类型是否有某个成员函数

咱们来举个例子，看看怎么用表达式 SFINAE 来判断一个类型是否有某个成员函数。假设我们要判断一个类型 T 是否有 foo() 这个成员函数。

#include <iostream>
#include <type_traits>

template <typename T, typename = void>
struct has_foo : std::false_type {};

template <typename T>
struct has_foo<T, std::void_t<decltype(std::declval<T>().foo())>> : std::true_type {};

struct WithFoo {
    void foo() {}
};

struct WithoutFoo {};

int main() {
    std::cout << "WithFoo has foo(): " << has_foo<WithFoo>::value << std::endl;
    std::cout << "WithoutFoo has foo(): " << has_foo<WithoutFoo>::value << std::endl;
    return 0;
}

这段代码看起来有点绕，咱们来一步一步分析：

1. has_foo 的声明

   我们定义了一个模板类 has_foo，它有两个模板参数：T 和一个默认类型为 void 的参数。这个模板类默认继承自 std::false_type，也就是说，默认情况下，我们认为类型 T 没有 foo() 成员函数。

2. has_foo 的特化

   我们对 has_foo 进行了特化，当类型 T 有 foo() 成员函数时，这个特化版本会被选中。

   • std::void_t<decltype(std::declval<T>().foo())>：这句是关键。std::declval<T>() 会生成一个类型 T 的右值引用，然后我们尝试调用它的 foo() 成员函数。如果 T 没有 foo() 成员函数，那么 decltype(std::declval<T>().foo()) 就会导致编译失败，SFINAE 就会生效，这个特化版本就会被排除掉。
   • 如果 T 有 foo() 成员函数，那么 decltype(std::declval<T>().foo()) 就会返回 foo() 函数的返回类型，std::void_t 就会把这个类型变成 void，特化版本就可以正常编译，并且会被选中。

3. WithFoo 和 WithoutFoo

   我们定义了两个结构体：WithFoo 有 foo() 成员函数，WithoutFoo 没有。

4. main 函数

   在 main 函数中，我们分别用 WithFoo 和 WithoutFoo 来实例化 has_foo，然后打印 has_foo::value 的值。可以看到，WithFoo 的结果是 true，WithoutFoo 的结果是 false。

更上一层楼：判断类型是否有某个成员变量

除了判断成员函数，我们还可以用类似的技巧来判断类型是否有某个成员变量。

#include <iostream>
#include <type_traits>

template <typename T, typename = void>
struct has_member_x : std::false_type {};

template <typename T>
struct has_member_x<T, std::void_t<decltype(std::declval<T>().x)>> : std::true_type {};

struct WithX {
    int x;
};

struct WithoutX {};

int main() {
    std::cout << "WithX has member x: " << has_member_x<WithX>::value << std::endl;
    std::cout << "WithoutX has member x: " << has_member_x<WithoutX>::value << std::endl;
    return 0;
}

这段代码和判断成员函数的那段代码非常相似，只是把 foo() 换成了 x。

表达式 SFINAE 的高级用法

表达式 SFINAE 的用处可不止判断成员函数和成员变量这么简单，它还可以用来做很多更高级的事情，比如：

• 根据类型特征选择不同的实现

  我们可以根据类型是否满足某些条件来选择不同的实现。例如，我们可以根据类型是否是整数类型来选择不同的算法。

• 实现静态多态

  我们可以用表达式 SFINAE 来实现静态多态，也就是在编译时根据类型来选择不同的函数。

• 实现编译时断言

  我们可以用表达式 SFINAE 来实现编译时断言，也就是在编译时检查类型是否满足某些条件，如果不满足，就产生一个编译错误。

代码示例：根据类型特征选择不同的实现

#include <iostream>
#include <type_traits>

template <typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
process(T value) {
    std::cout << "Processing an integer: " << value << std::endl;
    return value * 2;
}

template <typename T>
typename std::enable_if<!std::is_integral<T>::value, T>::type
process(T value) {
    std::cout << "Processing a non-integer: " << value << std::endl;
    return value;
}

int main() {
    int i = 10;
    double d = 3.14;

    std::cout << "Result of processing integer: " << process(i) << std::endl;
    std::cout << "Result of processing double: " << process(d) << std::endl;

    return 0;
}

这段代码使用了 std::enable_if 来根据类型是否是整数类型来选择不同的 process 函数。

• std::enable_if：这是一个条件编译工具，它的作用是，当第一个模板参数为 true 时，它会提供一个类型，否则会导致 SFINAE。

• std::is_integral<T>::value：这是一个类型特征，它可以判断类型 T 是否是整数类型。

• typename std::enable_if<std::is_integral<T>::value, T>::type：这句是关键。如果 T 是整数类型，那么 std::enable_if 就会提供类型 T，否则会导致 SFINAE，这个函数就会被排除掉。

表达式 SFINAE 的注意事项

在使用表达式 SFINAE 时，需要注意以下几点：

• 可读性

  表达式 SFINAE 的代码通常比较复杂，可读性较差。因此，在使用表达式 SFINAE 时，要尽量保持代码的简洁和清晰，并且要添加适当的注释。

• 编译时间

  表达式 SFINAE 会增加编译时间，因为编译器需要尝试用不同的类型去替换模板参数，并且要检查表达式的有效性。因此，在使用表达式 SFINAE 时，要尽量避免过度使用，并且要优化代码，减少编译时间。

• 错误信息

  当表达式 SFINAE 导致编译错误时，错误信息通常比较难懂。因此，在使用表达式 SFINAE 时，要仔细检查代码，并且要学会分析错误信息。

表格总结：表达式 SFINAE 的常用技巧

技巧	描述	示例
decltype	返回表达式的类型，如果表达式不能编译，则导致 SFINAE。	c++ template <typename T, typename = void> struct has_foo : std::false_type {}; template <typename T> struct has_foo<T, std::void_t<decltype(std::declval<T>().foo())>> : std::true_type {};
std::void_t	将任意类型列表转换为 void，如果类型列表中有无效类型，则导致 SFINAE。	同上
std::enable_if	根据条件选择是否提供类型，如果条件为 false，则导致 SFINAE。	c++ template <typename T> typename std::enable_if<std::is_integral<T>::value, T>::type process(T value) { std::cout << "Processing an integer: " << value << std::endl; return value * 2; } template <typename T> typename std::enable_if<!std::is_integral<T>::value, T>::type process(T value) { std::cout << "Processing a non-integer: " << value << std::endl; return value; }
std::is_same, std::is_integral 等	类型特征，用于判断类型是否满足某些条件。	参见 std::enable_if 的示例
std::declval	生成一个类型的右值引用，用于在 decltype 中调用成员函数或访问成员变量。	参见 has_foo 和 has_member_x 的示例

总结

表达式 SFINAE 是 C++ 模板元编程中一个非常强大的工具，它可以让我们在编译时根据表达式的有效性来选择不同的模板实现。虽然表达式 SFINAE 的代码通常比较复杂，但是只要掌握了它的基本原理和常用技巧，就可以用它来解决很多复杂的问题。

总而言之，表达式 SFINAE 就像一个聪明的侦探，它能够根据类型提供的线索（表达式是否有效）来判断应该选择哪个模板，从而让我们的代码更加灵活和高效。希望今天的讲解能够帮助大家更好地理解和使用表达式 SFINAE。

今天的分享就到这里，感谢大家的聆听！希望对大家有所帮助。