Boost C++ Libraries

namespace boost {
    template <class Cond, class T = void> struct enable_if;
    template <class Cond, class T = void> struct disable_if;
    template <class Cond, class T> struct lazy_enable_if;
    template <class Cond, class T> struct lazy_disable_if;

    template <bool B, class T = void> struct enable_if_c;
    template <bool B, class T = void> struct disable_if_c;
    template <bool B, class T> struct lazy_enable_if_c;
    template <bool B, class T> struct lazy_disable_if_c;
}

C++ 中模板函数重载的合理操作依赖于 SFINAE（替换失败不是错误）原则 [3]：如果在函数模板的实例化期间形成无效的参数或返回类型，则该实例化将从重载解析集中删除，而不是导致编译错误。以下示例摘自 [1]，演示了为什么这很重要

int negate(int i) { return -i; }

template <class F>
typename F::result_type negate(const F& f) { return -f(); }

假设编译器遇到调用 negate(1)。第一个定义显然是更好的匹配，但编译器仍然必须考虑（并实例化原型）两个定义才能找出这一点。将后一个定义与 F 作为 int 实例化将导致

int::result_type negate(const int&);

其中返回类型无效。如果这是一个错误，则添加一个不相关的函数模板（从未调用过）可能会破坏原本有效的代码。由于 SFINAE 原则，上面的示例不是错误的。negate 的后一个定义只是从重载解析集中删除。

enable_if 模板是用于受控创建 SFINAE 条件的工具。

在支持 C++0x 函数模板参数默认参数的编译器中，您可以通过添加额外的模板参数来启用和禁用函数模板。这种方法适用于所有您将使用 enable_if 的返回类型形式或函数参数形式的情况，包括运算符、构造函数、可变参数函数模板，甚至重载的转换操作。

例如

#include <boost/type_traits/is_arithmetic.hpp>
#include <boost/type_traits/is_pointer.hpp>
#include <boost/utility/enable_if.hpp>

class test
{
public:
    // A constructor that works for any argument list of size 10
    template< class... T,
        typename boost::enable_if_c< sizeof...( T ) == 10,
            int >::type = 0>
    test( T&&... );

    // A conversion operation that can convert to any arithmetic type
    template< class T,
        typename boost::enable_if< boost::is_arithmetic< T >,
            int >::type = 0>
    operator T() const;

    // A conversion operation that can convert to any pointer type
    template< class T,
        typename boost::enable_if< boost::is_pointer< T >,
            int >::type = 0>
    operator T() const;
};

int main()
{
    // Works
    test test_( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 );

    // Fails as expected
    test fail_construction( 1, 2, 3, 4, 5 );

    // Works by calling the conversion operator enabled for arithmetic types
    int arithmetic_object = test_;

    // Works by calling the conversion operator enabled for pointer types
    int* pointer_object = test_;

    // Fails as expected
    struct {} fail_conversion = test_;
}

可以使用 enable_if 启用或禁用类模板特化。需要为启用器表达式添加一个额外的模板参数。此参数具有默认值 void。例如

template <class T, class Enable = void>
class A { ... };

template <class T>
class A<T, typename enable_if<is_integral<T> >::type> { ... };

template <class T>
class A<T, typename enable_if<is_float<T> >::type> { ... };

使用任何整型类型实例化 A 匹配第一个特化，而任何浮点类型匹配第二个特化。所有其他类型都匹配主模板。条件可以是任何依赖于类的模板参数的编译时布尔表达式。请注意，再次，不需要 enable_if 的第二个参数；默认值 (void) 是正确的值。

enable_if_has_type 模板在此场景中可用，但它不是使用类型 traits 来启用或禁用特化，而是使用 SFINAE 上下文来检查其参数内部是否存在依赖类型。例如，以下结构从 T 中提取依赖的 value_type，当且仅当 T::value_type 存在时。

template <class T, class Enable = void>
class value_type_from
{
  typedef T type;
};

template <class T>
class value_type_from<T, typename enable_if_has_type<typename T::value_type>::type>
{
  typedef typename T::value_type type;
};

一旦编译器检查了启用条件并将函数包含到重载解析集中，就会使用正常的 C++ 重载解析规则来选择最佳匹配函数。特别是，启用条件之间没有顺序。启用条件不是互斥的函数模板可能导致歧义。例如

template <class T>
typename enable_if<boost::is_integral<T>, void>::type
foo(T t) {}

template <class T>
typename enable_if<boost::is_arithmetic<T>, void>::type
foo(T t) {}

所有整型类型也是算术类型。因此，例如，对于调用 foo(1)，两个条件都为真，因此两个函数都在重载解析集中。它们都是同样好的匹配项，因此是模棱两可的。当然，只要其他参数消除函数的歧义，就可以同时满足多个启用条件。

以上讨论也适用于在类模板部分特化中使用 enable_if。

在某些情况下，有必要避免实例化函数签名的部分，除非启用条件为真。例如

template <class T, class U> class mult_traits;

template <class T, class U>
typename enable_if<is_multipliable<T, U>,
    typename mult_traits<T, U>::type>::type
operator*(const T& t, const U& u) { ... }

假设类模板 mult_traits 是一个 traits 类，用于定义乘法运算符的结果类型。is_multipliable traits 类指定为哪些类型启用运算符。每当 is_multipliable<A, B>::value 对于某些类型 A 和 B 为 true 时，则定义 mult_traits<A, B>::type。

现在，尝试使用操作数类型 C 和 D 调用 operator* 的（某些其他重载），对于这些类型，is_multipliable<C, D>::value 为 false 并且未定义 mult_traits<C, D>::type 在某些编译器上是错误。SFINAE 原则不适用，因为无效类型作为另一个模板的参数出现。lazy_enable_if 和 lazy_disable_if 模板（及其 _c 版本）可以在这种情况下使用

template<class T, class U>
typename lazy_enable_if<is_multipliable<T, U>,
    mult_traits<T, U> >::type
operator*(const T& t, const U& u) { ... }

lazy_enable_if 的第二个参数必须是类类型，当第一个参数（条件）为真时，该类类型定义一个名为 type 的嵌套类型。

	注意
	引用 traits 类中的一个成员类型或静态常量会导致实例化该特化的所有成员（类型和静态常量）。因此，如果您的 traits 类有时可能包含无效类型，则应使用两个不同的模板来描述条件和类型映射。在上面的示例中，is_multipliable<T, U>::value 定义了何时 mult_traits<T, U>::type 有效。

如果唯一的区分因素是启用器中的不同条件（即使函数永远不可能是模棱两可的），则某些编译器会将函数标记为模棱两可。例如，某些编译器（例如 GCC 3.2）将以下两个函数诊断为模棱两可

template <class T>
typename enable_if<boost::is_arithmetic<T>, T>::type
foo(T t);

template <class T>
typename disable_if<boost::is_arithmetic<T>, T>::type
foo(T t);

可以应用两种变通方案