C++ 的 SFINAE（Substitution Failure Is Not An Error） 机制和类型萃取（type traits）

flyfish

Substitution Failure Is Not An Error 翻译为中文是“替换失败不是错误”。它是 C++ 模板编程中的一个重要概念，指在模板实例化过程中，如果某些模板参数的替换导致编译失败，编译器不会报错，而是会尝试其他可行的模板特化或重载。
从简单的开始介绍

模板编程

模板编程是一种在C++中创建泛型代码的方式。模板允许编写与类型无关的函数和类，可以在编译时通过不同的类型实例化。

template<typename T>
T add(T a, T b) {return a + b;
}int main() {int x = add(3, 4);        // 实例化为 add<int>double y = add(2.5, 3.5); // 实例化为 add<double>return 0;
}

模板实例化

模板实例化是将模板参数替换为具体类型的过程。实例化可以是隐式的（由编译器在使用模板时自动完成）或显式的（程序员手动指定）。

template<typename T>
T multiply(T a, T b) {return a * b;
}// 显式实例化
template int multiply(int, int);int main() {int x = multiply(3, 4); // 使用显式实例化return 0;
}

模板特化

模板特化允许为特定类型提供不同于通用模板的实现。特化有两种形式：部分特化（Partial Specialization）和完全特化（Full Specialization）。

完全特化

完全特化是指为模板的特定类型提供一个完整的实现，覆盖掉通用模板的实现。这意味着特化的模板只适用于特定的类型。

示例
假设我们有一个通用的模板类 MyClass，并且我们想为 int 类型提供一个特化的实现：

#include <iostream>template<typename T>
class MyClass {
public:void print() {std::cout << "Generic template\n";}
};// 完全特化
template<>
class MyClass<int> {
public:void print() {std::cout << "Specialized for int\n";}
};int main() {MyClass<double> obj1;obj1.print(); // 输出: Generic templateMyClass<int> obj2;obj2.print(); // 输出: Specialized for intreturn 0;
}

部分特化

部分特化是指为模板的某些类型参数提供一个特化的实现，而不是全部。这在类模板中尤为常见，因为函数模板不支持部分特化。

示例
假设我们有一个模板类 MyClass，并且我们想为特定类型参数组合提供一个特化的实现：
MyClass<double, char> 使用通用模板实现。
MyClass<int, char> 使用部分特化，当第一个类型参数是 int 时的实现。
MyClass<char, double> 使用部分特化，当第二个类型参数是 double 时的

#include <iostream>// 通用模板
template<typename T, typename U>
class MyClass {
public:void print() {std::cout << "Generic template\n";}
};// 部分特化，当第一个类型参数是 int 时
template<typename U>
class MyClass<int, U> {
public:void print() {std::cout << "Specialized for int and U\n";}
};// 部分特化，当第二个类型参数是 double 时
template<typename T>
class MyClass<T, double> {
public:void print() {std::cout << "Specialized for T and double\n";}
};int main() {MyClass<double, char> obj1;obj1.print(); // 输出: Generic templateMyClass<int, char> obj2;obj2.print(); // 输出: Specialized for int and UMyClass<char, double> obj3;obj3.print(); // 输出: Specialized for T and doublereturn 0;
}

完全特化意味着为模板的所有参数都提供了具体的类型，从而创建了一个针对这些具体类型的模板实例。这通常是在所有模板参数都是已知类型时使用。

部分特化则是在模板的一些参数是已知类型，而其他参数仍然保持泛型的情况下，提供一个特化的版本。这允许为某些参数的特定组合提供专门的实现，而其他参数保持泛型。例如有一个模板类，可以为其中一个参数是 int 的组合重写部分功能，而其他参数可以是任意类型

回到要说的SFINAE 机制

SFINAE 机制

在 C++ 中，模板允许编写通用代码，但有时模板的某些实例化并不适用于所有类型。SFINAE 机制允许编译器在模板参数替换失败时，不报错，而是继续寻找其他匹配的模板特化或重载。

编译器尝试其他模板特化或重载
当模板替换失败时，编译器会尝试：

其他重载函数：如果一个函数模板的实例化失败，编译器会尝试查找并使用其他可能匹配的重载函数。
其他模板特化：如果一个模板特化的实例化失败，编译器会尝试查找并使用其他匹配的模板特化。

SFINAE（Substitution Failure Is Not An Error）

SFINAE 是 C++ 模板机制的一部分，它表示在模板实例化过程中，如果替换模板参数失败，不会导致编译错误，而是让编译器尝试其他模板特化或重载。这通常用于实现条件模板和类型萃取。

下面这个例子中，hasFoo 函数模板在 T 具有成员函数 foo 时启用，否则尝试重载函数。通过 decltype 和 std::true_type 或 std::false_type 来判断类型是否具有 foo 成员函数。

#include <iostream>
#include <type_traits>// 条件函数模板：当 T 具有成员函数 foo 时启用
template<typename T>
auto hasFoo(T t) -> decltype(t.foo(), std::true_type{}) {return std::true_type{};
}// 条件函数模板：当 T 没有成员函数 foo 时启用
std::false_type hasFoo(...) {return std::false_type{};
}class A {
public:void foo() { std::cout << "A::foo()" << std::endl; }
};class B {};int main() {std::cout << std::boolalpha;std::cout << "A has foo: " << decltype(hasFoo(A{}))::value << std::endl;std::cout << "B has foo: " << decltype(hasFoo(B{}))::value << std::endl;return 0;
}

类型萃取（type traits）

萃读作cui，四声。
类型萃取是一组模板类和模板函数，用于在编译时获取类型信息或进行类型操作。类型萃取用于查询和操作类型的属性。C++ 标准库提供了许多类型萃取工具，例如 std::is_void、std::is_integral、std::is_pointer 等。标准库中的 std::is_integral 就是一个常见的类型萃取。
“萃取”一词来源于“萃”字，有收集、提炼之意。在类型萃取的上下文中，“萃取”可以理解为“抽取”或“提取”，即从类型中抽取其固有的特性或属性。类似于化学上的萃取——从混合物中提取出特定成分。

#include <iostream>
#include <type_traits>template<typename T>
void checkType() {if (std::is_integral<T>::value) {std::cout << "Type is integral." << std::endl;} else {std::cout << "Type is not integral." << std::endl;}if (std::is_pointer<T>::value) {std::cout << "Type is pointer." << std::endl;} else {std::cout << "Type is not pointer." << std::endl;}
}int main() {checkType<int>();      // 输出：Type is integral.//       Type is not pointer.checkType<int*>();     // 输出：Type is not integral.//       Type is pointer.checkType<double>();   // 输出：Type is not integral.//       Type is not pointer.return 0;
}

结合 SFINAE 和类型萃取来实现条件编译和类型操作

#include <iostream>
#include <type_traits>// 条件模板函数：仅在 T 是整型时启用
template<typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
void printType(T value) {std::cout << "Integral type: " << value << std::endl;
}// 条件模板函数：仅在 T 是浮点型时启用
template<typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
void printType(T value) {std::cout << "Floating-point type: " << value << std::endl;
}int main() {printType(42);         // 输出：Integral type: 42printType(3.14);       // 输出：Floating-point type: 3.14// printType("hello"); // 编译错误：没有匹配的函数模板return 0;
}