在使用 SFINAE 编写模板特化时，您经常会因为一个不存在的小成员或函数而需要编写一个全新的特化。我想将此选择打包成一个小声明，如 orElse<T a,T b> .

小例子:

template<typename T> int get(T& v){
    return orElse<v.get(),0>();
}

这可能吗？

最佳答案

orElse<v.get(),0>()的意图很清楚，但如果这样的事情可能存在， 它必须是以下之一:

召唤阵容

orElse(v,&V::get,0)
orElse<V,&V::get>(v,0)
orElse<V,&V::get,0>(v)

哪里v类型为 V ，以及由此实例化的函数模板 分别是:

函数模板阵容

template<typename T>
int orElse(T & obj, int(T::pmf*)(), int deflt);

template<typename T, int(T::*)()>
int orElse(T & obj, int deflt);

template<typename T, int(T::*)(), int Default>
int orElse(T & obj);

正如您所理解的，没有这样的东西可以达到您想要的效果。

对于任何不明白的人， 原因很简单:Invocation Lineup 中没有函数调用 如果没有像 V::get 这样的成员，将编译.没有回头路 那个，以及调用的函数可能是一个实例的事实 Function Template Lineup 中的函数模板没有任何区别。 如果V::get不存在，那么任何提到它的代码都不会编译。

但是，你似乎有一个实际的目标，不需要接近 以这种绝望的方式。看起来好像，对于一个给定的名字 foo和给定类型 R , 你希望能够只编写一个函数模板:

template<typename T, typename ...Args>
R foo(T && obj, Args &&... args);

这将返回 R(T::foo) 的值, 呼吁 obj带参数 args... , 如果存在这样的成员函数，否则返回一些默认值 R .

如果正确，可以按照下图实现:

#include <utility>
#include <type_traits>

namespace detail {

template<typename T>

T default_ctor()
{
    return T();
}

// SFINAE `R(T::get)` exists
template<typename T, typename R, R(Default)(), typename ...Args>
auto get_or_default(
    T && obj,
    Args &&... args) ->
    std::enable_if_t<
        std::is_same<R,decltype(obj.get(std::forward<Args>(args)...))
    >::value,R>
{
    return obj.get(std::forward<Args>(args)...);
}

// SFINAE `R(T::get)` does not exist
template<typename T, typename R, R(Default)(), typename ...Args>
R get_or_default(...)
{
    return Default();
}

} //namespace detail


// This is your universal `int get(T,Args...)`
template<typename T, typename ...Args>
int get(T && obj, Args &&... args)
{
    return detail::get_or_default<T&,int,detail::default_ctor>
        (obj,std::forward<Args>(args)...);
}

// C++14, trivially adaptable for C++11

可以尝试:

#include <iostream>

using namespace std;

struct A
{
    A(){};
    int get() {
        return 1;
    }
    int get(int i) const  {
        return i + i;
    }
};

struct B
{
    double get() {
        return 2.2;
    }
    double get(double d) {
        return d * d;
    }
};

struct C{};

int main()
{
    A const aconst;
    A a;
    B b;
    C c;
    cout << get(aconst) << endl;    // expect 0
    cout << get(a) << endl;         // expect 1 
    cout << get(b) << endl;         // expect 0
    cout << get(c) << endl;         // expect 0
    cout << get(a,1) << endl;       // expect 2
    cout << get(b,2,2) << endl;     // expect 0
    cout << get(c,3) << endl;       // expect 0
    cout << get(A(),2) << endl;     // expect 4
    cout << get(B(),2,2) << endl;   // expect 0
    cout << get(C(),3) << endl;     // expect 0
    return 0;
}

在复杂的返回类型中有“复合 SFINAE”在起作用:

std::enable_if_t<
        std::is_same<R,decltype(obj.get(std::forward<Args>(args)...))
    >::value,R>

如果T::get则不存在 decltype(obj.get(std::forward<Args>(args)...) 不编译。但是如果它确实编译了，并且返回类型为 T::get是 R以外的东西, 然后是 std::enable_if_t类型说明符不 编译。仅当成员函数存在且具有所需的返回类型时 R 可以R(T::get) 存在 case 被实例化。否则 包罗万象 R(T::get)选择不存在个案。

注意 get(aconst)返回 0 而不是 1。这是应该的， 因为非常量重载 A::get()不能在 const 上调用 A .

您可以对任何其他 R foo(V & v,Args...) 使用相同的模式和 存在或不存在R(V::foo)(Args...) . 如果R不是默认构造的，或者如果你想要默认的 R那 在 R(V::foo) 时返回不存在不同于 R() , 然后定义一个函数 detail::fallback (或其他)返回 所需的默认值 R并指定它而不是 detail::default_ctor

如果您可以进一步对模式进行模板参数化，那该有多好 容纳 T 的任何可能的成员函数任何可能的返回 输入 R .但是你需要的额外模板参数会 是R(T::*)(typename...) ，它的实例化值必须是 &V::get (或其他)，然后模式将 迫使你陷入提及其存在有疑问的事物的致命陷阱。

关于C++:检查表达式是否编译的模板，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/28858344/