为什么我应该避免在函数签名中使用std :: enable_if

Scott Meyers发布了他的下一本书EC ++ 11的内容和状态。他写道，书中的一项可能是“避免std::enable_if使用函数签名”。

std::enable_if 可用作函数参数，返回类型或类模板或函数模板参数，以有条件地从重载解析中删除函数或类。

在此问题中，显示了所有三种解决方案。

作为功​​能参数：

template<typename T>
struct Check1
{
   template<typename U = T>
   U read(typename std::enable_if<
          std::is_same<U, int>::value >::type* = 0) { return 42; }

   template<typename U = T>
   U read(typename std::enable_if<
          std::is_same<U, double>::value >::type* = 0) { return 3.14; }   
};

作为模板参数：

template<typename T>
struct Check2
{
   template<typename U = T, typename std::enable_if<
            std::is_same<U, int>::value, int>::type = 0>
   U read() { return 42; }

   template<typename U = T, typename std::enable_if<
            std::is_same<U, double>::value, int>::type = 0>
   U read() { return 3.14; }   
};

作为返回类型：

template<typename T>
struct Check3
{
   template<typename U = T>
   typename std::enable_if<std::is_same<U, int>::value, U>::type read() {
      return 42;
   }

   template<typename U = T>
   typename std::enable_if<std::is_same<U, double>::value, U>::type read() {
      return 3.14;
   }   
};

• 应该首选哪种解决方案，为什么我应该避免其他解决方案？
• 在哪些情况下，“避免std::enable_if使用函数签名”与返回类型的使用有关（这不是正常函数签名的一部分，而是模板专业化的一部分）？
• 成员函数模板和非成员函数模板有什么区别吗？

将hack放到模板参数中。

该enable_if模板参数方法比别人至少有两个好处：

• 可读性：enable_if用法和return / argument类型不会合并到一个混乱的typename歧义块和嵌套的类型访问中；即使可以使用别名模板减轻歧义词和嵌套类型的混乱情况，但仍会将两个无关的东西合并在一起。enable_if的使用与模板参数有关，与返回类型无关。将它们包含在模板参数中意味着它们更接近要紧的内容。

• 通用性：构造函数没有返回类型，并且某些运算符不能具有额外的参数，因此，其他两个选项都不能在任何地方应用。将enable_if放在模板参数中无处不在，因为无论如何您只能在模板上使用SFINAE。

对我而言，可读性是此选择的主要推动因素。

std::enable_if在模板自变量推导过程中，它依赖于“ 替换失败不是错误 ”（又称SFINAE）原理。这是一种非常脆弱的语言功能，您需要非常小心才能正确使用。

1. 如果内的条件enable_if包含嵌套的模板或类型定义（提示：查找::标记），则这些嵌套的模板或类型的解析度通常是非推论上下文。在这种非推论上下文中的任何替换失败都是错误。
2. 多个enable_if重载中的各种条件不能有任何重叠，因为重载解决方案将是不确定的。尽管您会收到良好的编译器警告，但作为作者您需要检查一下自己。
3. enable_if在重载解析期间操纵可行的函数集，这可能具有令人惊讶的交互作用，具体取决于从其他范围（例如，通过ADL）引入的其他函数的存在。这使其不是很坚固。

简而言之，当它起作用时，它会起作用，但是当它不起作用时，则很难调试。一个很好的替代方法是使用标记分派，即委托给实现函数（通常在detail名称空间或帮助器类中），该实现函数基于您在中使用的相同的编译时条件来接收伪参数enable_if。

template<typename T>
T fun(T arg) 
{ 
    return detail::fun(arg, typename some_template_trait<T>::type() ); 
}

namespace detail {
    template<typename T>
    fun(T arg, std::false_type /* dummy */) { }

    template<typename T>
    fun(T arg, std::true_type /* dummy */) {}
}

标记分派不会操纵重载集，但可以通过编译时表达式（例如，在类型特征中）提供适当的参数，从而帮助您准确选择所需的函数。以我的经验，这更容易调试和正确使用。如果您是一位对复杂类型特征有抱负的库作者，则可能需要enable_if某种方式，但是对于大多数常规使用编译时条件，不建议这样做。

应该首选哪种解决方案，为什么我应该避免其他解决方案？

• 模板参数

  • 在构造函数中可用。
  • 在用户定义的转换运算符中可用。
  • 它需要C ++ 11或更高版本。
  • 它是IMO，更具可读性。

  • 它可能很容易被错误地使用，并产生带有重载的错误：

    template<typename T, typename = std::enable_if_t<std::is_same<T, int>::value>>
    void f() {/*...*/}
    
    template<typename T, typename = std::enable_if_t<std::is_same<T, float>::value>>
    void f() {/*...*/} // Redefinition: both are just template<typename, typename> f()

  注意typename = std::enable_if_t<cond>而不是正确std::enable_if_t<cond, int>::type = 0

• 返回类型：

  • 不能在构造函数中使用。（无返回类型）
  • 它不能在用户定义的转换运算符中使用。（不可推论）
  • 可以使用C ++ 11之前的版本。
  • 其次是更具可读性的IMO。

• 最后，在函数参数中：

  • 可以使用C ++ 11之前的版本。
  • 在构造函数中可用。
  • 它不能在用户定义的转换运算符中使用。（无参数）
  • 它不能与固定数目的参数一元/二进制运算符的方法（可以使用+，-，*，...）
  • 可以安全地在继承中使用（请参见下文）。
  • 更改函数签名（基本上，最后一个参数是多余的void* = nullptr）（因此函数指针会有所不同，依此类推）

成员函数模板和非成员函数模板有什么区别吗？

继承和之间有细微的差别using：

根据 using-declarator（强调我的）：

namespace.udecl

通过对using-declarator中的名称执行合格的名称查找（[basic.lookup.qual]，[class.member.lookup]），可以找到using-declarator引入的声明集，但不包括按说明隐藏的函数下面。

...

当using-declarator将基类中的声明带入派生类时，派生类中的成员函数和成员函数模板将覆盖和/或隐藏具有相同名称，parameter-type-list，cv-的成员函数和成员函数模板。限定和ref限定符（如果有）在基类中（而不是冲突）。此类隐藏或覆盖的声明将从using-declarator引入的声明集中排除。

因此，对于模板参数和返回类型，在以下情况下方法都是隐藏的：

struct Base
{
    template <std::size_t I, std::enable_if_t<I == 0>* = nullptr>
    void f() {}

    template <std::size_t I>
    std::enable_if_t<I == 0> g() {}
};

struct S : Base
{
    using Base::f; // Useless, f<0> is still hidden
    using Base::g; // Useless, g<0> is still hidden

    template <std::size_t I, std::enable_if_t<I == 1>* = nullptr>
    void f() {}

    template <std::size_t I>
    std::enable_if_t<I == 1> g() {}
};

演示（gcc错误地找到基本函数）。

鉴于有论点，类似的情况适用：

struct Base
{
    template <std::size_t I>
    void h(std::enable_if_t<I == 0>* = nullptr) {}
};

struct S : Base
{
    using Base::h; // Base::h<0> is visible

    template <std::size_t I>
    void h(std::enable_if_t<I == 1>* = nullptr) {}
};

演示版