解释一下 C++ SFINAE 到非 C++程序员

Question

C++ 中的 SFINAE 是什么？

您能用不懂 C++ 的程序员可以理解的语言解释一下吗？另外，SFINAE 对应于 Python 这样的语言中的什么概念？

Answer 1

警告：这是一个非常的解释，但希望它不仅真正解释了 SFINAE 的作用，而且还给出了您何时以及为何使用它的一些想法。

好的，为了解释这一点，我们可能需要稍微备份和解释一下模板。众所周知，Python 使用通常所说的鸭子类型——例如，当你调用一个函数时，你可以将一个对象 X 传递给该函数，只要 X 提供该函数使用的所有操作。

在 C++ 中，普通（非模板）函数要求您指定参数的类型。如果您定义了如下函数：

int plus1(int x) { return x + 1; }

您只能将该函数应用于int。事实上，它使用 x 的方式可以同样适用于其他类型，例如 long 或 float没有什么区别——它只适用于 int 。

为了获得更接近 Python 的鸭子类型，您可以创建一个模板：

template <class T>
T plus1(T x) { return x + 1; }

现在我们的 plus1 更像是在 Python 中——特别是，我们可以同样好地调用它到一个对象x 为定义了 x + 1 的任何类型。

现在，例如，考虑我们想要将一些对象写入流。不幸的是，其中一些对象是使用 stream << 写入流的。 object，但其他人使用 object.write(stream); 代替。我们希望能够处理其中任何一个，而无需用户指定哪一个。现在，模板专业化允许我们编写专门的模板，因此如果它是使用 object.write(stream) 语法的一个类型，我们可以这样做

template <class T>
std::ostream &write_object(T object, std::ostream &os) {
    return os << object;
}

template <>
std::ostream &write_object(special_object object, std::ostream &os) { 
    return object.write(os);
}

：对于一种类型来说很好，如果我们非常想要，我们可以为所有不支持stream <<的类型添加更多专门化。 object ——但是一旦（例如）用户添加了不支持 stream << 的新类型object，事情再次崩溃。

我们想要的是一种对任何支持 stream << 的对象使用第一个专门化的方法。 object;，但第二个用于其他任何东西（尽管我们有时可能想为使用 x.print(stream); 的对象添加第三个）。

我们可以使用 SFINAE 来做出决定。为此，我们通常依赖 C++ 的其他一些奇怪的细节。一种是使用 sizeof 运算符。 sizeof 确定类型或表达式的大小，但它完全在编译时通过查看所涉及的类型来确定，而不评估表达式本身。例如，如果我有类似的内容：

int func() { return -1; }

我可以使用 sizeof(func())。在本例中，func() 返回一个 int，因此 sizeof(func()) 相当于 sizeof(int)< /代码>。

经常使用的第二个有趣的事实是数组的大小必须为正数，不为零。

现在，将它们放在一起，我们可以做这样的事情：

// stolen, more or less intact from: 
//     http://stackoverflow.com/questions/2127693/sfinae-sizeof-detect-if-expression-compiles
template<class T> T& ref();
template<class T> T  val();

template<class T>
struct has_inserter
{
    template<class U> 
    static char test(char(*)[sizeof(ref<std::ostream>() << val<U>())]);

    template<class U> 
    static long test(...);

    enum { value = 1 == sizeof test<T>(0) };
    typedef boost::integral_constant<bool, value> type;
};

这里我们有两个 test 重载。其中第二个采用可变参数列表（...），这意味着它可以匹配任何类型 - 但这也是编译器在选择重载时做出的最后选择，因此它会仅如果第一个不匹配。 test 的另一个重载有点有趣：它定义了一个带有一个参数的函数：一个指向返回 char 的函数的指针数组，其中数组的大小（本质上）是sizeof(stream << object)。如果流<< object 不是有效的表达式，sizeof 将产生 0，这意味着我们创建了一个大小为零的数组，这是不允许的。这就是 SFINAE 本身发挥作用的地方。尝试用不支持 operator<< 的类型替换 U 将会失败，因为它会生成大小为零的数组。但是，这不是一个错误 - 它只是意味着该函数已从重载集中消除。因此，在这种情况下，只能使用另一个函数。

然后，它会在下面的 enum 表达式中使用——它查看所选的 test 重载的返回值，并检查它是否等于 1（如果是，则表示选择了返回 char 的函数，否则，选择了返回 long 的函数）。

结果是，如果 some_ostream << has_inserter::value 将为 1。 object; 会编译，如果不能编译则 0 。然后，我们可以使用该值来控制模板专门化，以选择正确的方式来写出特定类型的值。

Answer 2

如果您有一些重载的模板函数，则在执行模板替换时，某些可能使用的候选函数可能无法编译，因为被替换的内容可能没有正确的行为。这不被视为编程错误，失败的模板只是从可用于该特定参数的集合中删除。

我不知道 Python 是否有类似的功能，也不太明白为什么非 C++ 程序员应该关心这个功能。但如果您想了解有关模板的更多信息，最好的书籍是 C++ 模板：完整指南 。

Answer 3

SFINAE 是 C++ 编译器在重载解析期间过滤掉某些模板化函数重载的原则 (1)

当编译器解析特定函数调用时，它会考虑一组可用的函数和函数模板声明来查找确定将使用哪一个。基本上，有两种机制可以做到这一点。一种可以被描述为句法。给定声明：

template <class T> void f(T);                 //1
template <class T> void f(T*);                //2
template <class T> void f(std::complex<T>);   //3

解析 f((int)1) 将删除版本 2 和 3，因为 int 不等于 complex 或T* 表示某些 T。同样，f(std::complex(1)) 将删除第二个变体，f((int*)&x) 将删除第三个变体。编译器通过尝试从函数参数推导模板参数来实现此目的。如果推导失败（如 T* 针对 int），则重载将被丢弃。

我们想要这个的原因很明显 - 我们可能想要对不同类型做稍微不同的事情（例如，复数的绝对值由 x*conj(x) 计算并产生实数，不是复数，这与浮点数的计算不同）。

如果您之前做过一些声明式编程，则此机制类似于（Haskell）：

f Complex x y = ...
f _           = ...

C++ 进一步采取的方式是，即使推导类型正确，推导也可能失败，但回代到其他类型会产生一些“无意义”的结果（稍后会详细介绍）。例如：

template <class T> void f(T t, int(*)[sizeof(T)-sizeof(int)] = 0);

在推导 f('c') 时（我们使用单个参数调用，因为第二个参数是隐式的）：

1. 编译器将 T 与 char 进行匹配 生成的 T 为 char，
2. 编译器将声明中的所有 T 替换为 char s。这会产生 void f(char t, int(*)[sizeof(char)-sizeof(int)] = 0)。
3. 第二个参数的类型是指向数组int [sizeof(char)-sizeof(int)]的指针。该阵列的大小可以是例如。 -3（取决于您的平台）。
4. 长度为 <= 0 的数组无效，因此编译器会丢弃该重载。 替换失败不是错误，编译器不会拒绝该程序。

最后，如果仍然存在多个函数重载，编译器将使用转换序列比较和模板的部分排序来选择“最佳”的一个。

还有更多这样的“无意义”结果，它们在标准（C++03）的列表中枚举。在 C++0x 中，SFINAE 的范围扩展到几乎所有类型错误。

我不会详细列出 SFINAE 错误，但最常见的一些错误是：

• 选择没有该错误的类型的嵌套类型。例如。 typename T::type 表示 T = int 或 T = A，其中 A 是没有嵌套类型的类称为类型。
• 创建非正大小的数组类型。有关示例，请参阅此litb的答案
• 创建一个指向非类型的成员指针班级。例如。 int C::* for C = int

这种机制与我所知道的其他编程语言中的任何机制都不相似。如果你要在 Haskell 中做类似的事情，你会使用更强大的防护，但在 C++ 中是不可能的。

---

1：或在谈论类模板时部分模板专业化

Answer 4

Python根本不会帮助你。但您确实说您已经基本熟悉模板了。

最基本的 SFINAE 构造是使用 enable_if。唯一棘手的部分是 class enable_if 并没有封装 SFINAE，它只是公开它。

template< bool enable >
class enable_if { }; // enable_if contains nothing…

template<>
class enable_if< true > { // … unless argument is true…
public:
    typedef void type; // … in which case there is a dummy definition
};

template< bool b > // if "b" is true,
typename enable_if< b >::type function() {} //the dummy exists: success

template< bool b >
typename enable_if< ! b >::type function() {} // dummy does not exist: failure
    /* But Substitution Failure Is Not An Error!
     So, first definition is used and second, although redundant and
     nonsensical, is quietly ignored. */

int main() {
    function< true >();
}

在 SFINAE 中，有一些结构设置错误条件（此处为 class enable_if）和许多并行的、否则会发生冲突的定义。除了一个定义之外，所有定义都会出现一些错误，编译器会选择并使用该定义，而不会抱怨其他定义。

什么样的错误是可以接受的，这是一个最近才标准化的主要细节，但您似乎并没有问这个问题。

Answer 5

Python 中没有任何东西与 SFINAE 非常相似。 Python 没有模板，当然也没有像解析模板特化时那样的基于参数的函数解析。 Python 中的函数查找纯粹是通过名称来完成的。