C++每日一问(3):C++中SFINAE是什么意思

在很多讨论C++的帖子中经常看到SFINAE这个关键字,它究竟代表什么含义呢

什么是SFINAE

SFINAE的全称是：Substitution Failure Is Not An Error 即：替换失败不是错误，是一项和模板相关的极为关键的特性。当模板参数替换引发语法错误时，借助 SFINAE 机制，编译器能够忽略此类错误，而非直接抛出编译错误。

SFINAE的作用

这一特性使得开发者能够在编译期依据类型的具体特性，灵活选择不同的模板实例化方式，进而达成编译期的类型检查以及函数重载决议。例如，通过 SFINAE，我们可以在编译阶段判断某个类型是否支持特定的操作，像是加法、减法或者某个成员函数的调用，从而依据判断结果选择最为适配的函数实现，极大地增强了代码的灵活性与可维护性。

使用方法

再介绍使用方法之前，我们得先熟悉其他几个模板元编程的相关概念

std::enable_if

std::enable_if是 C++ 标准库所提供的一种类型特质（type trait），主要用于在编译期依据特定条件来启用或禁用模板。例如：

#include <type_traits>

// 当T为整数类型时实例化此模板函数√√√
template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
void foo(T t) {
    // 在此处理整数类型相关逻辑
}

// 当T为非整数类型时实例化此模板函数
template <typename T, typename = std::enable_if_t<!std::is_integral_v<T>>>
void foo(T t) {
    // 在此处理非整数类型相关逻辑
}

std::decltype

std::decltype是 C++ 的一个关键字，用于获取一个表达式的类型。它的语法是std::decltype(expression)，其中expression是任意合法的 C++ 表达式。例如：

int num = 10;
std::decltype(num) anotherNum; // anotherNum的类型为int

std::declval

std::declval是 C++ 标准库中的一个函数模板，定义在头文件中。它的作用是在不实际构造对象的情况下，生成一个用于表达式的右值引用。 其语法为

std::declval<T>()

其中T是要生成右值引用的类型。由于std::declval用于生成一个未求值的表达式，所以它只能用于decltype内部或者其他不会真正计算表达式值的上下文。例如：

class MyClass {
public:
    void memberFunction();
};
// 仅通过std::declval获取memberFunction的调用表达式类型，不会实际调用memberFunction
std::decltype(std::declval<MyClass>().memberFunction()) result; 

在成员函数存在性检测中，std::declval能帮助我们在不创建对象实例的情况下，模拟成员函数的调用，配合std::decltype来判断类型是否具有某个成员函数。

在模板元编程中，std::decltype非常有用，它能让我们在编译期获取某个表达式的类型，而无需实际执行该表达式。比如在检测类型是否有某个成员函数时，就需要通过std::decltype来获取成员函数调用表达式的类型，以此判断该成员函数是否存在。

简单点理解就是它可以帮助我们在不真正调用函数的情况下获取一个函数的右值（不仅仅是函数，其他对象也可以使用），结合std::decltype我们就可以方便的获取到一个复杂类型的定义，在上面的例子中，result被定义为MyClass类的成员函数memberFunction变量。

std::false_type和std::true_type

std::true_type 和 std::false_type 是 std::integral_constant 的特化版本。std::integral_constant 是一个模板类，用于表示一个编译时常量。 它的定义如下：

namespace std {
    template <class T, T v>
    struct integral_constant {
        static constexpr T value = v;
        using value_type = T;
        using type = integral_constant<T, v>;
        constexpr operator value_type() const noexcept { return value; }
        constexpr value_type operator()() const noexcept { return value; }
    };

    typedef integral_constant<bool, true> true_type;
    typedef integral_constant<bool, false> false_type;
}

• std::true_type 是 std::integral_constant<bool, true> 的类型别名。
• std::false_type 是 std::integral_constant<bool, false> 的类型别名。

这玩意有啥用呢？假设我们想判断一个类型是否是整数类型，可以这么写：

#include <iostream>
#include <type_traits>

template <typename T>
struct is_integer : std::false_type {};

template <>
struct is_integer<int> : std::true_type {};

template <>
struct is_integer<long> : std::true_type {};

template <>
struct is_integer<short> : std::true_type {};

template <>
struct is_integer<unsigned int> : std::true_type {};

template <>
struct is_integer<unsigned long> : std::true_type {};

template <>
struct is_integer<unsigned short> : std::true_type {};

int main() {
    std::cout << std::boolalpha;
    std::cout << "int is integer: " << is_integer<int>::value << '\n';       // true
    std::cout << "double is integer: " << is_integer<double>::value << '\n'; // false
}

在这个例子中，is_integer 模板根据类型是否为整数类型，继承自 std::true_type 或 std::false_type。

还有一个作用就是编译时条件分支。例如，使用 std::enable_if 来根据条件启用或禁用某个函数模板：

#include <iostream>
#include <type_traits>

template <typename T>
typename std::enable_if<std::is_integral<T>::value, void>::type
print_integer(T value) {
    std::cout << "Integer: " << value << '\n';
}

template <typename T>
typename std::enable_if<!std::is_integral<T>::value, void>::type
print_integer(T value) {
    std::cout << "Not an integer: " << value << '\n';
}

int main() {
    print_integer(42);       // Integer: 42
    print_integer(3.14);     // Not an integer: 3.14
}

简单来说就是能用这个东西来控制想让某个函数调用来匹配特定的模板，这个也叫做类模板的偏特化。

编译器在实际处理模板时遇到 SFINAE 的处理流程示例

好了，在铺垫了必备知识以后我们来真正看一下SFINAE的实例， 假设我们有一个函数模板

void print_size(const T& obj)

我们想传入一个参数来打印当前这个参数的长度，但是他必须有一个size()成员函数，那么可以这么写

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

// 辅助模板，用于检测类型T是否有size成员函数
template <typename T, typename = void>
struct has_size_member : std::false_type {};

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

// 主模板函数，当类型T有size成员函数时实例化
template <typename T, typename = std::enable_if_t<has_size_member<T>::value>>
void print_size(const T& obj) {
    std::cout << "The size is: " << obj.size() << std::endl;
}

// 特化模板函数，当类型T没有size成员函数时实例化
template <typename T, typename = std::enable_if_t<!has_size_member<T>::value>>
void print_size(const T& obj) {
    std::cout << "This type does not have a size member function." << std::endl;
}

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    print_size(vec); // 调用有size成员函数的版本

    int num = 10;
    print_size(num); // 调用没有size成员函数的版本

    return 0;
}

主模板定义

首先定义了一个主模板has_size_member，它有两个模板参数，T是要检测的类型，第二个参数是一个默认模板参数typename = void。这个主模板默认继承自std::false_type，表示在没有特化的情况下，假设类型T没有size成员函数。

特化模板定义：

接着定义了一个特化模板，它的模板参数只有T。当T类型满足特定条件时，这个特化模板会被实例化。 条件是

std::void_t<decltype(std::declval<T>().size())>

其中std::declval<T>()生成一个T类型的右值引用，模拟T类型对象的创建，然后调用size成员函数。std::decltype获取这个调用表达式的类型，std::void_t是一个类型别名模板，它接受一个类型参数，当这个参数是有效的类型时，std::void_t的实例化结果就是void类型。

如果T类型有size成员函数，那么decltype(std::declval<T>().size())会得到一个有效的类型，std::void_t实例化成功，此时这个特化模板会被实例化，并且继承自std::true_type，表示T类型有size成员函数。如果T类型没有size成员函数，decltype(std::declval<T>().size())会导致替换失败，根据 SFINAE 机制，这个特化模板不会被实例化，而是使用主模板，即表示T类型没有size成员函数。

编译器的处理流程

• 实例化前的检查：当编译器遇到print_size函数调用时，首先会查看所有的print_size模板函数声明并逐个进行检查确认匹配的模板函数。
• 模板参数替换：对于每个模板函数，编译器尝试将实际参数类型（如std::vector<int>或int）替换到模板参数T中。
• SFINAE 条件检查：在参数替换后，编译器检查std::enable_if_t的条件。对于has_size_member模板，编译器会根据T的实际类型尝试实例化has_size_member模板。如果T的类型有size成员函数，has_size_member<T>::value为true；否则为false。这里通过std::decltype(std::declval<T>().size())来检测T类型是否有size成员函数，std::declval<T>()生成一个T类型的右值引用，以便在不实际构造对象的情况下模拟size函数调用，std::decltype获取这个调用表达式的类型，若类型合法，则说明T有size成员函数。
• 选择合适的模板实例化：如果某个模板函数的std::enable_if_t条件为true，则该模板函数是有效的候选。如果有多个有效候选，编译器会进行重载决议，选择最匹配的函数。如果只有一个有效候选，编译器就会实例化该模板函数。在这个例子中，当传入std::vector<int>时，第一个print_size模板函数有效，因为std::vector<int>有size成员函数；当传入int时，第二个print_size模板函数有效，因为int没有size成员函数。

通过这个例子，可以清晰地看到 SFINAE 机制如何在编译期帮助编译器根据类型特性选择合适的模板实例化，避免了因类型不匹配导致的编译错误