模板编程中实现 SFINAE（Substitution Failure Is Not An Error）

在C++模板编程中，std::enable_if 是一个常用的工具，它依赖于 SFINAE（Substitution Failure Is Not An Error）原则来控制模板的启用或禁用。理解 std::enable_if 如何工作，可以更清楚地看到为什么 disable_if_same_or_derived 在某些情况下等同于 void 类型。

std::enable_if 的工作原理

std::enable_if 是一个模板，它的作用是根据条件在编译期决定是否启用某个模板。如果条件为 true，它定义一个内部类型 type，通常被设定为 void。如果条件为 false，则没有定义 type，从而导致模板匹配失败。这利用了 SFINAE 原则，即在模板匹配过程中如果替换失败不会导致编译错误，而是简单地从候选模板集中移除。

代码解释

template<typename A, typename B>
using disable_if_same_or_derived = typename std::enable_if<
    !std::is_base_of<A, typename std::remove_reference<B>::type>::value
>::type;

这段代码使用 std::enable_if 和 std::is_base_of 来定义一个条件性的类型别名 disable_if_same_or_derived。

1. std::is_base_of<A, typename std::remove_reference<B>::type>::value：
   • 检查 A 是否是（去掉引用后的）B 的基类，或 A 是否与 B 相同。
2. !std::is_base_of<...>::value：
   • 取反操作，即当 A 不是 B 的基类，并且 A 不等于 B 时，条件为 true。
3. std::enable_if<condition>::type：
   • 当条件为 true 时，std::enable_if 定义 type 成员类型，通常被设定为 void。

为什么等同于 void 类型

在条件为 true 时，即 A 不是 B 的基类并且 A 不等于 B 时：

typename std::enable_if<true>::type

在这种情况下，std::enable_if<true> 会定义一个成员类型 type，默认情况下为 void。因此，disable_if_same_or_derived 在这种情况下等同于 void：

using disable_if_same_or_derived = void;

在条件为 false 时，即 A 是 B 的基类或 A 等于 B 时：

typename std::enable_if<false>::type

在这种情况下，std::enable_if<false> 不会定义 type，因此模板匹配失败，不会实例化。

示例应用

考虑以下函数模板，它使用 disable_if_same_or_derived 来控制模板实例化：

#include <type_traits>
#include <iostream>

template<typename A, typename B>
using disable_if_same_or_derived = typename std::enable_if<!std::is_base_of<A, typename std::remove_reference<B>::type>::value>::type;

class Base {};
class Derived : public Base {};

template<typename T, typename = disable_if_same_or_derived<Base, T>>
void foo(T&&) {
    std::cout << "foo(T&&) called" << std::endl;
}

// Overload to handle Base and its derived types
void foo(Base&) {
    std::cout << "foo(Base&) called" << std::endl;
}

int main() {
    int i = 0;
    Base b;
    Derived d;

    foo(i);    // 调用 foo(T&&)
    foo(b);    // 调用 foo(Base&)
    foo(d);    // 调用 foo(Base&)
}

在这个例子中：

• 当传递的类型不是 Base 或其派生类时，例如 int 类型，disable_if_same_or_derived 等同于 void，函数模板 foo(T&&) 可以被实例化。
• 当传递的类型是 Base 或其派生类时，例如 Base 或 Derived 类型，disable_if_same_or_derived 无法定义类型，导致模板匹配失败，而选择重载函数 foo(Base&)。

这种方式可以用于实现函数重载或模板实例化的条件限制，有效地控制模板的适用范围。