Question

从previous question开始的延续。我所拥有的是一系列功能，形成一个像这样的sfinae依赖链（让＆＃34; A - ＆gt; B＆＃34;符号意味着A的存在取决于B的存在）：

S::f_base -> S::f -> ns::f_ -> f -> T::f

其中T是模板参数。它实现为this：

#include <utility>

struct S;

template <typename T>
auto f(S& s, T const& t) -> decltype(t.f(s), void())
{
    t.f(s);
}

namespace ns
{
    template <typename T>
    auto f_(S& s, T const& t) -> decltype(f(s, t), void())
    {
        f(s, t);
    }
} 

struct S
{
    template <typename T>
    auto f(T const& t) -> decltype(ns::f_(std::declval<S&>(), t), void())
    {
        ns::f_(*this, t);
    }

    template <typename T>
    auto f_base(T const* t_ptr) -> decltype(f(*t_ptr), void())
    {
        f(*t_ptr);
    }
};

struct pass
{
   void f(S&) const
   {
   }
};

struct fail
{

};

int main()
{
    S s;
    s.f(pass()); // compiles
    //s.f(fail()); // doesn't compile
    return 0;
}

按预期工作。当我尝试将S::f和S::f_base的定义移到类体外时，例如so，就会出现问题：

#include <utility>

struct S;

template <typename T>
auto f(S& s, T const& t) -> decltype(t.f(s), void())
{
    t.f(s);
}

namespace ns
{
    template <typename T>
    auto f_(S& s, T const& t) -> decltype(f(s, t), void())
    {
        f(s, t);
    }
} 

struct S
{
    template <typename T>
    auto f(T const& t) -> decltype(ns::f_(std::declval<S&>(), t), void());

    template <typename T>
    auto f_base(T const* t_ptr) -> decltype(f(*t_ptr), void());
};

template <typename T>
auto S::f(T const& t) -> decltype(ns::f_(std::declval<S&>(), t), void())
{
    ns::f_(*this, t);
}

template <typename T>
auto S::f_base(T const* t_ptr) -> decltype(f(*t_ptr), void()) // <---- HERE ---
{
    f(*t_ptr);
}

int main()
{

    return 0;
}

在箭头GCC 4.7.1标记的行上表达了它的不满：

错误：原型为＆＃39; decltype（（（（S *）0） - ＆gt; S :: f（（* t_ptr）），void（）））S :: f_base（const T *）＆＃39;与课堂上的任何内容都不匹配＆＃39; S＆＃39;
错误：候选者是：模板decltype（（（（（S *）this） - ＆gt; S :: f（（* t_ptr）），void（）））S :: f_base（const T *）

我尝试在f中明确指定我使用f_base std::declval<S&>().使用S::f_base -> -> ns::f_ -> f -> T::f S::f ->（在声明和定义中），但错误仍然存在。

我知道我可以像这样修改依赖图：

S::f_base

使ns::f_依赖于S::f以及{{1}}，但是有没有办法用第一个依赖图执行此操作？

Answer 1

GCC 4.X不是元编程的最佳选择

我设法使其在4.7.3（live）中进行编译：

#include <utility>

struct S;

template <typename T>
auto f(S& s, T const& t) -> decltype(t.f(s), void())
{
    t.f(s);
}

namespace ns
{
    template <typename T>
    auto f_(S& s, T const& t) -> decltype(f(s, t), void())
    {
        f(s, t);
    }
} 

// some std::void_t like but GCC4.x compatible
template<class T>
struct void_t
{
   using type = typename std::enable_if<std::is_same<T,T>::value >::type;
};

struct S
{
    template <typename T>
    auto f(T const& t) -> decltype(ns::f_(std::declval<S&>(), t), void());

    template <typename T>
    auto f_base(T const* t_ptr) ->  typename void_t< decltype (::f(*std::declval<T const*>()))>::type ;
};


template <typename T>
auto S::f(T const& t) -> decltype(ns::f_(std::declval<S&>(), t), void())
{
    ns::f_(*this, t);
}

// ::f is needed, fail if just 'f'
template <typename T>
auto S::f_base(T const* t_ptr) ->  typename void_t< decltype (::f(*std::declval<T const*>()))>::type
{
    f(*t_ptr);
}
int main()
{

    return 0;
}

注意：

在GCC4.X中，我看到了一些奇怪的东西，例如：

template<class T>
struct void_t
{
   using type = void;
};

即使void_t<decltype(expr)>::type无效，GCC仍将void替换为expr的地方。这就是为什么我使用void_t的这种实现方式。

在类体外定义的成员函数上的sfinae

1 个答案: