C++ Expression SFINAE：C++17 表达式中的 SFINAE 技巧

好的，各位观众，各位老铁，欢迎来到今天的“C++表达式SFINAE：C++17表达式中的SFINAE技巧”讲座。我是你们的老朋友，代码界的段子手。今天咱们聊点硬核的，但保证让大家听得懂，学得会，还能乐呵一下。

开场白：SFINAE，你个磨人的小妖精

首先，我们来聊聊SFINAE。这玩意儿，中文名叫“替换失败不是错误”，英文名叫“Substitution Failure Is Not An Error”。听起来是不是很高大上？其实说白了，就是编译器在编译模板的时候，如果发现某个模板实例化的时候出错了，不是直接报错，而是默默地把这个实例化方案给扔了，然后尝试其他的方案。

这就像你找对象，相亲的时候发现对方不符合你的条件，你不是直接把对方骂一顿，而是礼貌地说声“不合适”，然后默默地离开，继续寻找下一个目标。SFINAE就是这么个温柔（也可能有点渣）的机制。

SFINAE的经典应用：类型检查

SFINAE最经典的应用就是类型检查。比如，你想知道一个类型有没有某个成员函数，或者能不能进行某种运算。以前，我们可能需要用一堆模板元编程的技巧来实现，代码写得跟天书一样。但有了C++17的表达式SFINAE，一切都变得简单多了。

C++17表达式SFINAE：主角登场

C++17引入了一个新特性，允许我们在decltype表达式中使用SFINAE。这就像给SFINAE装上了涡轮增压，让它跑得更快，更灵活。

语法糖：requires 关键字

为了让代码更易读，C++20引入了requires关键字，配合concepts使用。虽然我们今天主要讲C++17，但是requires关键字可以让我们的代码更简洁，更容易理解。所以，我们也会稍微提及一下。

Show me the code!

光说不练假把式，咱们直接上代码。

例1：检查类型是否有某个成员函数

假设我们要检查一个类型T是否有foo()成员函数。

#include <iostream>
#include <type_traits>

template <typename T>
using has_foo_t = std::void_t<decltype(std::declval<T>().foo())>;

template <typename T>
constexpr bool has_foo = std::is_void_v<has_foo_t<T>>;

struct A {
    void foo() {}
};

struct B {};

int main() {
    std::cout << "A has foo: " << has_foo<A> << std::endl; // 输出：A has foo: 1
    std::cout << "B has foo: " << has_foo<B> << std::endl; // 输出：B has foo: 0
    return 0;
}

代码解释：

std::declval<T>(): 这玩意儿可以凭空捏造一个类型T的对象，但是它不会真正构造对象，只是用来做类型推导。你可以把它想象成一个魔法棒，挥一下就能得到一个T类型的“影子”。
decltype(std::declval<T>().foo()): 这部分就是表达式SFINAE的核心。它尝试获取T类型对象的foo()成员函数的返回类型。如果T类型没有foo()成员函数，那么这个表达式就会失败。
std::void_t<>: 这是一个小技巧。std::void_t<>总是返回void类型，但是它有一个特殊的性质：如果模板参数推导失败，它也会失败。所以，我们可以用它来检测decltype表达式是否成功。
std::is_void_v<>: 判断一个类型是否是void。如果has_foo_t<T>是void，那么has_foo<T>就是true，否则就是false。

这个例子虽然简单，但是它展示了表达式SFINAE的基本用法。

例2：检查类型是否支持某种运算

假设我们要检查一个类型T是否支持加法运算。

#include <iostream>
#include <type_traits>

template <typename T>
using has_plus_t = std::void_t<decltype(std::declval<T>() + std::declval<T>())>;

template <typename T>
constexpr bool has_plus = std::is_void_v<has_plus_t<T>>;

struct C {
    C operator+(const C&) const { return C{}; }
};

struct D {};

int main() {
    std::cout << "C has plus: " << has_plus<C> << std::endl; // 输出：C has plus: 1
    std::cout << "D has plus: " << has_plus<D> << std::endl; // 输出：D has plus: 0
    return 0;
}

这个例子和例1类似，只是把foo()成员函数换成了加法运算符。

例3：使用requires关键字（C++20）

如果使用C++20，我们可以用requires关键字来简化代码。

#include <iostream>
#include <type_traits>

template <typename T>
concept HasFoo = requires(T t) {
    t.foo();
};

struct A {
    void foo() {}
};

struct B {};

int main() {
    std::cout << "A has foo: " << HasFoo<A> << std::endl; // 输出：A has foo: 1
    std::cout << "B has foo: " << HasFoo<B> << std::endl; // 输出：A has foo: 0
    return 0;
}

代码解释：

concept HasFoo = requires(T t) { t.foo(); };: 这定义了一个名为HasFoo的概念。它表示类型T必须满足t.foo()表达式是有效的。
requires(T t) { ... }: 这部分是requires子句。它指定了类型T必须满足的条件。
t.foo();: 这部分是要求。它表示类型T的对象t必须能够调用foo()成员函数。

使用requires关键字，代码更加简洁易懂。

高级技巧：重载决议

SFINAE的一个非常重要的应用是在重载决议中。我们可以利用SFINAE来选择最合适的重载函数。

例4：根据类型选择不同的重载函数

假设我们有两个函数，一个接受int类型的参数，另一个接受任意类型的参数。我们希望在参数是int类型时调用第一个函数，否则调用第二个函数。

#include <iostream>
#include <type_traits>

void print(int i) {
    std::cout << "print(int): " << i << std::endl;
}

template <typename T, typename = std::enable_if_t<!std::is_same_v<T, int>>>
void print(T t) {
    std::cout << "print(T): " << t << std::endl;
}

int main() {
    print(10);  // 输出：print(int): 10
    print(3.14); // 输出：print(T): 3.14
    return 0;
}

代码解释：

std::enable_if_t<condition, type>: 这是一个条件模板。如果condition为true，那么std::enable_if_t就返回type类型，否则编译失败。
!std::is_same_v<T, int>: 判断类型T是否不是int类型。
typename = std::enable_if_t<!std::is_same_v<T, int>>: 这部分是SFINAE的关键。如果T是int类型，那么!std::is_same_v<T, int>就是false，std::enable_if_t就会编译失败，导致这个重载函数被排除。

在这个例子中，当参数是int类型时，编译器会优先选择第一个print()函数，因为第二个print()函数被SFINAE排除了。当参数不是int类型时，第一个print()函数不适用，编译器会选择第二个print()函数。

例5：更复杂的重载决议

#include <iostream>
#include <type_traits>

template <typename T>
using has_value_t = std::void_t<decltype(std::declval<T>().value)>;

template <typename T>
constexpr bool has_value = std::is_void_v<has_value_t<T>>;

template <typename T, typename = std::enable_if_t<has_value<T>>>
void process(T t) {
    std::cout << "process(T with value): " << t.value << std::endl;
}

template <typename T, typename = std::enable_if_t<!has_value<T>>>
void process(T t) {
    std::cout << "process(T without value)" << std::endl;
}

struct E {
    int value;
};

struct F {};

int main() {
    E e{42};
    F f{};

    process(e); // 输出：process(T with value): 42
    process(f); // 输出：process(T without value)

    return 0;
}

这个例子结合了类型检查和重载决议，更加灵活。

SFINAE的注意事项

不要滥用SFINAE：SFINAE虽然强大，但是过度使用会导致代码难以理解和维护。
SFINAE只在模板实例化时生效：如果你的代码不是模板，那么SFINAE就没用了。
小心二义性：如果多个重载函数都满足条件，编译器可能会报错。

SFINAE的优点

编译时检查：SFINAE可以在编译时检查类型，避免运行时错误。
代码复用：SFINAE可以让我们编写更通用的代码，提高代码复用率。
性能优化：SFINAE可以让我们根据不同的类型选择不同的实现，提高程序性能。

SFINAE的缺点

代码复杂：SFINAE的代码通常比较复杂，难以理解和维护。
编译时间长：SFINAE会导致编译时间变长。
错误信息不友好：SFINAE的错误信息通常比较晦涩难懂。

总结：SFINAE，用得好是神，用不好是坑

SFINAE是一个强大的工具，但是需要谨慎使用。只有在真正需要的时候才使用SFINAE，并且要确保代码清晰易懂。

表格总结

特性	描述	优点	缺点
SFINAE	替换失败不是错误。编译器在编译模板时，如果实例化失败，不会直接报错，而是尝试其他的实例化方案。	编译时类型检查，代码复用，性能优化。	代码复杂，编译时间长，错误信息不友好，滥用会导致代码难以理解和维护。
`decltype`	获取表达式的类型。	可以获取任意表达式的类型，包括成员函数、运算符等。	只能获取类型，不能执行表达式。
`std::declval`	凭空捏造一个类型`T`的对象，用于类型推导。	可以获取任意类型的对象，即使该类型没有默认构造函数。	不会真正构造对象，只是用来做类型推导。
`std::void_t`	总是返回`void`类型，但是如果模板参数推导失败，它也会失败。	可以用来检测`decltype`表达式是否成功。	只能返回`void`类型。
`std::enable_if`	条件模板。如果条件为`true`，那么返回指定类型，否则编译失败。	可以根据条件选择不同的重载函数。	代码复杂，容易出错。
`requires`	C++20引入的关键字，用于定义概念。	代码简洁易懂，可以提高代码的可读性。	只能在C++20中使用。

结束语：代码之路，永无止境

今天的讲座就到这里。希望大家通过今天的学习，能够对C++表达式SFINAE有一个更深入的了解。记住，代码之路，永无止境。只有不断学习，不断实践，才能成为真正的编程高手。

感谢大家的观看，下次再见！

发表回复 取消回复

发表回复取消回复