SFINAE

来自cppreference.com
< cpp‎ | language

“替换失败不是错误” (Substitution Failure Is Not An Error)


在函数模板的重载决议中应用此规则:为模板形参替换推导类型失败时,从重载集抛弃特化,而非导致编译失败。

此特性被用于模板元编程。

目录

[编辑] 说明

函数模板形参被替换(为实参所替代)二次:

  • 显式指定的模板形参于模板实参推导前替换
  • 推导的实参和从默认项获得的实参于模板实参推导后替换

替换发生于

  • 所有用于函数类型中的类型(包含返回类型和所有参数的类型)
  • 所有用于模板形参声明中的所有类型
  • 所有用于函数类型中的表达式
  • 所有用于模板形参声明中的表达式
(C++11 起)
(C++20 起)

替换失败是任何若用替换的实参写入,则上述类型或表达式将为病式(有要求的诊断)的情形。

唯有函数类型或其模板形参类型或其 explicit 指定符 (C++20 起)立即语境中的类型与表达式中的失败是 SFINAE 错误。若被替换类型/表达式的求值导致副效应,例如实例化某模板特化、生成某隐式定义的成员函数等,则这些副效应中的错误被当做硬错误。不认为 lambda 表达式是立即语境的一部分。 (C++20 起)

替换以词序进行,并在遇到失败时终止。

template <typename A>
struct B { typedef typename A::type type; };
 
template <
  class T,
  class   = typename T::type,      // 若 T 无成员 type 则为 SFINAE 失败
  class U = typename B<T>::type    // 若 T 无成员 type 则为硬错误
                                   // ( C++14 起保证不出现)
> void foo (int);
(C++14 起)

[编辑] 类型 SFINAE

下列类型错误是 SFINAE 错误:

  • 试图实例化含有多个不同长度包的包展开
(C++11 起)
  • 试图创建 void 的数组、引用的数组、函数的数组、抽象类类型的数组、负大小的数组或零大小的数组。
template <int I> void div(char(*)[I % 2 == 0] = 0) {
    // 此重载于 I 是偶数时得到选择
}
template <int I> void div(char(*)[I % 2 == 1] = 0) {
    // 此重载于 I 是奇数时得到选择
}
  • 试图在作用域解析运算符 :: 左侧使用非类或非枚举的类型
template <class T> int f(typename T::B*);
template <class T> int f(T);
int i = f<int>(0); // 使用第二重载
  • 试图使用类型的成员,其中
  • 类型不含指定成员
  • 在要求类型处,指定成员不是类型
  • 在要求模板处,指定成员不是模板
  • 在要求非类型处,指定成员不是非类型
template <int I> struct X { };
template <template <class T> class> struct Z { };
template <class T> void f(typename T::Y*){}
template <class T> void g(X<T::N>*){}
template <class T> void h(Z<T::template TT>*){}
struct A {};
struct B { int Y; };
struct C { typedef int N; };
struct D { typedef int TT; };
struct B1 { typedef int Y; };
struct C1 { static const int N = 0; };
struct D1 { 
    template <typename T>
    struct TT
    {    
    }; 
};
int main() {
    // 在下列各个情况推导失败:
    f<A>(0); // 不含成员 Y
    f<B>(0); // B 的 Y 成员不是类型
    g<C>(0); // C 的 N 成员不是非类型
    h<D>(0); // D 的 TT 成员不是模板
 
    // 在下列各个情况推导成功:
    f<B1>(0); 
    g<C1>(0); 
    h<D1>(0);
}
// 未完成:需要演示重载决议,而不只是失败
  • 试图创建指向引用的指针
  • 试图创建到 void 的引用
  • 试图创建指向 T 成员的指针,其中 T 不是类类型
template<typename T>
class is_class {
    typedef char yes[1];
    typedef char no [2];
    template<typename C> static yes& test(int C::*); // 若 C 是类类型则得到选择
    template<typename C> static no&  test(...);      // 否则选择它
  public:
    static bool const value = sizeof(test<T>(0)) == sizeof(yes);
};
  • 试图将非法类型给予非类型模板参数
template <class T, T> struct S {};
template <class T> int f(S<T, T()>*);
struct X {};
int i0 = f<X>(0);
// 未完成:需要演示重载决议,而非仅是失败
  • 试图进行非法转换
  • 于模板实参表达式
  • 于使用函数声明的表达式
template <class T, T*> int f(int);
int i2 = f<int,1>(0); // 不能转换 1 为 int*
// 未完成:需要演示重载决议,而非仅是失败
  • 试图创建拥有形参类型 void 的函数
  • 试图创建返回数组类型或函数类型的函数
  • 试图创建 cv 限定的函数类型
(C++11 前)
  • 试图创建参数类型或返回类型为抽象类的函数类型。
(C++11 起)

[编辑] 表达式 SFINAE

下列表达式错误是 SFINAE 错误

  • 用于模板形参类型的病式表达式
  • 用于函数类型的病式表达式
struct X {};
struct Y { Y(X){} }; // X 可转换为 Y
 
template <class T>
auto f(T t1, T t2) -> decltype(t1 + t2); // 重载 #1
 
X f(Y, Y);  // 重载 #2
 
X x1, x2;
X x3 = f(x1, x2);  // 推导在 #1 上失败(表达式 x1+x2 为病式)
                   // 仅 #2 在重载集,并得到调用
(C++11 起)

C++11 前,唯有用于类型(例如数组边界)中的常量表达式才被要求当做 SFINAE (而非硬错误)。

(C++11 前)

[编辑] 库支持

标准库组件 std::enable_if 允许创建替换失败,以基于编译时条件启用或禁用特定重载。

标准库组件 std::void_t 是另一简化 SFINAE 应用的工具元函数。

另外,许多类型特性用 SFINAE 实现。

[编辑] 替用品

在可应用处,标签派发static_assert ,及若为可用的概念 ,通常较 SFINAE 的直接使用更受偏好。

[编辑] 示例

在返回类型上使用表达式 SFINAE 的常见手法,其中表达式使用逗号运算符,其左子表达式受到检验(转型到 void 以确保不选择返回类型上的用户定义逗号),而右子表达式拥有期望函数返回的类型。

#include <iostream>
 
// 此重载始终在重载集中
// 省略号参数拥有重载决议的最低等级
void test(...)
{
    std::cout << "Catch-all overload called\n";
}
 
// 添加此重载到重载集,
// 若 C 是到类的引用类型且 F 是指向 C 的成员函数的指针
template <class C, class F>
auto test(C c, F f) -> decltype((void)(c.*f)(), void())
{
    std::cout << "Reference overload called\n";
}
 
// 添加此重载到重载集,
// 若 C 是指向类的指针类型且 F 是指向 C 的成员函数的指针
template <class C, class F>
auto test(C c, F f) -> decltype((void)((c->*f)()), void())
{
    std::cout << "Pointer overload called\n";
}
 
struct X { void f() {} };
 
int main(){
  X x;
  test( x, &X::f);
  test(&x, &X::f);
  test(42, 1337);
}

输出:

Reference overload called
Pointer overload called
Catch-all overload called