我想进入更多的模板元编程。我知道 SFINAE 代表“替代失败不是错误”。但是有人可以告诉我 SFINAE 的好用处吗？
问问题
55891 次
10 回答
97
我喜欢SFINAE用来检查布尔条件。
template<int I> void div(char(*)[I % 2 == 0] = 0) {
/* this is taken when I is even */
}
template<int I> void div(char(*)[I % 2 == 1] = 0) {
/* this is taken when I is odd */
}
它可能非常有用。例如，我用它来检查使用运算符逗号收集的初始化列表是否不超过固定大小
template<int N>
struct Vector {
template<int M>
Vector(MyInitList<M> const& i, char(*)[M <= N] = 0) { /* ... */ }
}
该列表仅在 M 小于 N 时才被接受，这意味着初始化器列表没有太多元素。
语法char(*)[C]意味着：指向元素类型为 char 和 size 的数组的指针C。如果C为假（此处为 0），则我们得到无效类型char(*)[0]，指向零大小数组的指针：SFINAE 使模板将被忽略。
用 表示boost::enable_if，看起来像这样
template<int N>
struct Vector {
template<int M>
Vector(MyInitList<M> const& i,
typename enable_if_c<(M <= N)>::type* = 0) { /* ... */ }
}
在实践中，我经常发现检查条件的能力是一种有用的能力。
于 2009-06-12T23:40:28.010 回答
79
这是一个例子（来自这里）：
template<typename T>
class IsClassT {
private:
typedef char One;
typedef struct { char a[2]; } Two;
template<typename C> static One test(int C::*);
// Will be chosen if T is anything except a class.
template<typename C> static Two test(...);
public:
enum { Yes = sizeof(IsClassT<T>::test<T>(0)) == 1 };
enum { No = !Yes };
};
当IsClassT<int>::Yes被求值时，0 不能转换为，int int::*因为 int 不是一个类，所以它不能有成员指针。如果 SFINAE 不存在，那么您会收到编译器错误，例如“0 无法转换为非类类型 int 的成员指针”。相反，它只使用...返回 Two 的形式，因此计算结果为 false，int 不是类类型。
于 2009-06-11T18:54:41.733 回答
16
在 C++11 中，SFINAE 测试变得更加漂亮。以下是一些常见用途的示例：
根据特征选择函数重载
template<typename T>
std::enable_if_t<std::is_integral<T>::value> f(T t){
//integral version
}
template<typename T>
std::enable_if_t<std::is_floating_point<T>::value> f(T t){
//floating point version
}
使用所谓的类型接收习语，您可以对类型进行非常任意的测试，例如检查它是否具有成员以及该成员是否属于某种类型
//this goes in some header so you can use it everywhere
template<typename T>
struct TypeSink{
using Type = void;
};
template<typename T>
using TypeSinkT = typename TypeSink<T>::Type;
//use case
template<typename T, typename=void>
struct HasBarOfTypeInt : std::false_type{};
template<typename T>
struct HasBarOfTypeInt<T, TypeSinkT<decltype(std::declval<T&>().*(&T::bar))>> :
std::is_same<typename std::decay<decltype(std::declval<T&>().*(&T::bar))>::type,int>{};
struct S{
int bar;
};
struct K{
};
template<typename T, typename = TypeSinkT<decltype(&T::bar)>>
void print(T){
std::cout << "has bar" << std::endl;
}
void print(...){
std::cout << "no bar" << std::endl;
}
int main(){
print(S{});
print(K{});
std::cout << "bar is int: " << HasBarOfTypeInt<S>::value << std::endl;
}
这是一个活生生的例子： http: //ideone.com/dHhyHE 我最近还在我的博客中写了一个关于 SFINAE 和标签调度的完整部分（无耻的插件但相关）http://metaporky.blogspot.de/2014/08/第 7 部分-静态调度-function.html
请注意，从 C++14 开始，有一个 std::void_t 与此处的 TypeSink 基本相同。
于 2014-08-11T11:46:29.693 回答
10
Boost 的enable_if库为使用 SFINAE 提供了一个非常干净的界面。我最喜欢的使用示例之一是在Boost.Iterator库中。SFINAE 用于启用迭代器类型转换。
于 2009-06-11T19:39:28.520 回答
4
C++17 可能会提供一种通用的方法来查询特性。有关详细信息，请参阅N4502，但作为独立示例，请考虑以下内容。
这部分是常量部分，放在一个表头中。
// See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4502.pdf.
template <typename...>
using void_t = void;
// Primary template handles all types not supporting the operation.
template <typename, template <typename> class, typename = void_t<>>
struct detect : std::false_type {};
// Specialization recognizes/validates only types supporting the archetype.
template <typename T, template <typename> class Op>
struct detect<T, Op, void_t<Op<T>>> : std::true_type {};
以下示例取自N4502，显示了用法：
// Archetypal expression for assignment operation.
template <typename T>
using assign_t = decltype(std::declval<T&>() = std::declval<T const &>())
// Trait corresponding to that archetype.
template <typename T>
using is_assignable = detect<T, assign_t>;
与其他实现相比，这个实现相当简单：一组减少的工具 (void_t和detect) 就足够了。此外，据报道（参见N4502）它比以前的方法更有效（编译时间和编译器内存消耗）。
这是一个实时示例，其中包括 GCC pre 5.1 的可移植性调整。
于 2015-06-16T16:49:12.400 回答
3
这是另一个（后期）SFINAE示例，基于Greg Rogers的回答：
template<typename T>
class IsClassT {
template<typename C> static bool test(int C::*) {return true;}
template<typename C> static bool test(...) {return false;}
public:
static bool value;
};
template<typename T>
bool IsClassT<T>::value=IsClassT<T>::test<T>(0);
这样，您可以检查value's 的值以查看是否T是类：
int main(void) {
std::cout << IsClassT<std::string>::value << std::endl; // true
std::cout << IsClassT<int>::value << std::endl; // false
return 0;
}
于 2015-02-28T15:42:47.330 回答
3
这是 SFINAE 的一篇好文章：C++ 的 SFINAE 概念介绍：类成员的编译时自省。
总结如下：
/*
The compiler will try this overload since it's less generic than the variadic.
T will be replace by int which gives us void f(const int& t, int::iterator* b = nullptr);
int doesn't have an iterator sub-type, but the compiler doesn't throw a bunch of errors.
It simply tries the next overload.
*/
template <typename T> void f(const T& t, typename T::iterator* it = nullptr) { }
// The sink-hole.
void f(...) { }
f(1); // Calls void f(...) { }
template<bool B, class T = void> // Default template version.
struct enable_if {}; // This struct doesn't define "type" and the substitution will fail if you try to access it.
template<class T> // A specialisation used if the expression is true.
struct enable_if<true, T> { typedef T type; }; // This struct do have a "type" and won't fail on access.
template <class T> typename enable_if<hasSerialize<T>::value, std::string>::type serialize(const T& obj)
{
return obj.serialize();
}
template <class T> typename enable_if<!hasSerialize<T>::value, std::string>::type serialize(const T& obj)
{
return to_string(obj);
}
declval是一个实用程序，可为您提供对无法轻松构造的类型对象的“虚假引用”。declval对于我们的 SFINAE 结构非常方便。
struct Default {
int foo() const {return 1;}
};
struct NonDefault {
NonDefault(const NonDefault&) {}
int foo() const {return 1;}
};
int main()
{
decltype(Default().foo()) n1 = 1; // int n1
// decltype(NonDefault().foo()) n2 = n1; // error: no default constructor
decltype(std::declval<NonDefault>().foo()) n2 = n1; // int n2
std::cout << "n2 = " << n2 << '\n';
}
于 2015-12-25T07:13:09.237 回答
3
以下代码使用 SFINAE 让编译器根据类型是否具有特定方法来选择重载：
#include <iostream>
template<typename T>
void do_something(const T& value, decltype(value.get_int()) = 0) {
std::cout << "Int: " << value.get_int() << std::endl;
}
template<typename T>
void do_something(const T& value, decltype(value.get_float()) = 0) {
std::cout << "Float: " << value.get_float() << std::endl;
}
struct FloatItem {
float get_float() const {
return 1.0f;
}
};
struct IntItem {
int get_int() const {
return -1;
}
};
struct UniversalItem : public IntItem, public FloatItem {};
int main() {
do_something(FloatItem{});
do_something(IntItem{});
// the following fails because template substitution
// leads to ambiguity
// do_something(UniversalItem{});
return 0;
}
输出：
浮点数：1 诠释：-1
于 2020-07-18T07:10:25.167 回答
1
在我看来，其他答案提供的示例比需要的更复杂。
这是cppreference中稍微容易理解的示例：
#include <iostream>
// this overload is always in the set of overloads
// ellipsis parameter has the lowest ranking for overload resolution
void test(...)
{
std::cout << "Catch-all overload called\n";
}
// this overload is added to the set of overloads if
// C is a reference-to-class type and F is a pointer to member function of C
template <class C, class F>
auto test(C c, F f) -> decltype((void)(c.*f)(), void())
{
std::cout << "Reference overload called\n";
}
// this overload is added to the set of overloads if
// C is a pointer-to-class type and F is a pointer to member function of 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
如您所见，在第三次测试调用中，替换失败且没有错误。
于 2021-07-08T13:58:56.323 回答
0
在这里，我使用模板函数重载（不是直接 SFINAE）来确定指针是函数还是成员类指针：（是否可以修复打印为 1 或 true 的 iostream cout/cerr 成员函数指针？）
#include<iostream>
template<typename Return, typename... Args>
constexpr bool is_function_pointer(Return(*pointer)(Args...)) {
return true;
}
template<typename Return, typename ClassType, typename... Args>
constexpr bool is_function_pointer(Return(ClassType::*pointer)(Args...)) {
return true;
}
template<typename... Args>
constexpr bool is_function_pointer(Args...) {
return false;
}
struct test_debugger { void var() {} };
void fun_void_void(){};
void fun_void_double(double d){};
double fun_double_double(double d){return d;}
int main(void) {
int* var;
std::cout << std::boolalpha;
std::cout << "0. " << is_function_pointer(var) << std::endl;
std::cout << "1. " << is_function_pointer(fun_void_void) << std::endl;
std::cout << "2. " << is_function_pointer(fun_void_double) << std::endl;
std::cout << "3. " << is_function_pointer(fun_double_double) << std::endl;
std::cout << "4. " << is_function_pointer(&test_debugger::var) << std::endl;
return 0;
}
印刷
0. false
1. true
2. true
3. true
4. true
正如代码一样，它可以（取决于编译器的“好”意愿）生成对函数的运行时调用，该函数将返回真或假。如果您想强制is_function_pointer(var)在编译类型时评估（在运行时不执行函数调用），您可以使用constexpr变量技巧：
constexpr bool ispointer = is_function_pointer(var);
std::cout << "ispointer " << ispointer << std::endl;
根据 C++ 标准，所有constexpr变量都保证在编译时被评估（Computing length of a C string at compile time. Is this really a constexpr?）。
于 2020-01-31T01:59:01.830 回答