Question

在MSVC2017中，这样可以正常工作，两个static_assert都没有按预期触发：

template <typename T>
struct do_have_size {
    template <typename = decltype(std::declval<T>().size())>
    static std::true_type check(T);
    static std::false_type check(...);
    using type = decltype(check(std::declval<T>()));
};

int main() {
    using TR = typename do_have_size<std::vector<int>>::type;
    using FL = typename do_have_size<int>::type;

    static_assert(std::is_same<TR, std::true_type>::value, "TRUE");
    static_assert(std::is_same<FL, std::false_type>::value, "FALSE");
}

但是，如果我在g ++ 7.1或clang 4.0中编译，我会遇到以下编译器错误：

In instantiation of 'struct do_have_size<int>':
20:39:   required from here
9:24: error: request for member 'size' in 'declval<do_have_size<int>::TP>()', which is of non-class type 'int'

根据我对SFINAE的理解，true_type返回函数的替换应该对int参数失败，并且应该选择下一个函数，就像在MSVC中一样。为什么clang和g ++根本没有编译它？

我只使用-std=c++17开关进行编译，可能需要更多内容？

Answer 1

SFINAE在这里不起作用，因为该类已经在T = int中使用do_have_size<int>::type进行了实例化。 SFINAE仅适用于模板函数候选列表，在您的情况下，您将在实例化中遇到硬错误

do_have_size<int>::type

成员函数

template <typename = decltype(std::declval<int>().size())>
static std::true_type check(T);

对于int来说肯定是不合理的。

static std::false_type check(...);

永远不会被考虑。所以gcc就在这里拒绝你的代码而MSVC2017不应该接受代码。

相关：std::enable_if : parameter vs template parameter和SFINAE working in return type but not as template parameter

一个解决方案是使用void_t的魔力（因为C ++ 17，但您可以在C ++ 11/14中定义自己的），它可以映射任何类型列表到void并启用疯狂的简单SFINAE技术，如此

#include <utility>
#include <vector>

template<typename...>
using void_t = void; // that's how void_t is defined in C++17

template <typename T, typename = void>
struct has_size : std::false_type {};

template <typename T>
struct has_size<T, void_t<decltype(std::declval<T>().size())>>
    : std::true_type {};

int main() {
    using TR = typename has_size<std::vector<int>>::type;
    using FL = typename has_size<int>::type;

    static_assert(std::is_same<TR, std::true_type>::value, "TRUE");
    static_assert(std::is_same<FL, std::false_type>::value, "FALSE");
}

Live on Wandbox

Here是Walter Brown的Cppcon视频，详细解释了void_t技术，我强烈推荐它！

Answer 2

这与默认模板参数是否是功能模板签名的一部分完全无关。

真正的问题是T是一个类模板参数，当你实例化类模板的定义时，实现可以立即将它替换为你的默认模板参数decltype(std::declval<T>().size())模板参数推导，如果size不存在则会导致硬错误。

修复很简单;只需使它依赖于函数模板的参数。

template <typename U, typename = decltype(std::declval<U>().size())>
static std::true_type check(U);

（您的实现还有其他问题，例如它需要一个可移动构造的非抽象T并且不要求size()是可循环的，但它们不是＆＃ 39;你看到错误的原因。）

Answer 3

@vsoftco回答＆＃34; gcc拒绝你的代码是正确的＃34;。我同意。

为了解决问题，我说这样做：

namespace details {
  template<template<class...>class Z, class, class...Ts>
  struct can_apply:std::false_type{};
  template<class...>struct voider{using type=void;};
  template<class...Ts>using void_t = typename voider<Ts...>::type;

  template<template<class...>class Z, class...Ts>
  struct can_apply<Z, void_t<Z<Ts...>>, Ts...>:std::true_type{};
}
template<template<class...>class Z, class...Ts>
using can_apply=details::can_apply<Z,void,Ts...>;

这是一个can_apply库，使这种SFINAE变得简单。

现在编写其中一个特征就像：

template<class T>
using dot_size_r = decltype( std::declval<T>().size() );

template<class T>
using has_dot_size = can_apply< dot_size_r, T >;

测试代码：

int main() {
  static_assert( has_dot_size<std::vector<int>>{}, "TRUE" );
  static_assert( !has_dot_size<int>{}, "FALSE" );
}

直播示例。

在C ++ 17中，你可以移动到更少的declval填充表达式。

#define RETURNS(...) \
  noexcept(noexcept(__VA_ARGS__)) \
  -> decltype(__VA_ARGS__) \
  { return __VA_ARGS__; }

template<class F>
constexpr auto can_invoke(F&&) {
  return [](auto&&...args) {
    return std::is_invocable< F(decltype(args)...) >{};
  };
}

can_invoke接受一个函数f并返回一个＆＃34; invokation tester＆＃34;。 invokation测试器接受参数，如果这些参数有效传递给true_type，则返回f，否则返回false_type。

RETURNS可以轻松地使单个语句lambda SFINAE友好。在C ++ 17中，如果可能的话，lambda的操作是constexpr（这就是我们在这里需要C ++ 17的原因）。

然后，这给了我们：

template<class T>
constexpr auto can_dot_size(T&& t) {
  return can_invoke([](auto&& x) RETURNS(x.size()))(t);
}

现在，我们经常这样做，因为我们想要尽可能调用.size()，否则返回0.

template<class T, class A, class...Bs>
decltype(auto) call_first_valid(T&& t, A&& a, Bs&&...bs) {
  if constexpr( can_invoke(std::forward<A>(a))(std::forward<T>(t)) ) {
    return std::forward<A>(a)(std::forward<T>(t));
  else
    return call_first_valid(std::forward<T>(t), std::forward<Bs>(bs)...);
}

现在我们可以

template<class T>
std::size_t size_at_least( T&& t ) {
  return call_first_valid( std::forward<T>(t),
    [](auto&& t) RETURNS(t.size()),
    [](auto&&)->std::size_t { return 0; }
  );
}

碰巧，@ Barry在C ++ 20中提出了一个功能，用[](auto&& f) RETURNS(f.size())替换[](auto&& f)=>f.size()（以及更多）。

Answer 4

我根据参数或返回类型使用std::enable_if来SFINAE远离模板版本的检查。我使用的条件是std::is_fundamental来排除int，float和其他非类类型来实例化模板。我使用-std=c++1z标志来铿锵和gcc。我希望-std=c++14也应该有用。

#include <type_traits>
#include <utility>
#include <vector>

template <typename T>
struct do_have_size {
    static std::false_type check(...);

    template <typename U = T, typename = decltype(std::declval<U>().size())>
    static std::true_type check(std::enable_if_t<!std::is_fundamental<U>::value, U>);

    // OR
    //template <typename U = T, typename = decltype(std::declval<U>().size())>
    //static auto check(U)
    //    -> std::enable_if_t<!std::is_fundamental<U>::value, std::true_type>;

    using type = decltype(check(std::declval<T>()));
};

int main() {
    using TR = typename do_have_size<std::vector<int>>::type;
    using FL = typename do_have_size<int>::type;

    static_assert(std::is_same<TR, std::true_type>::value, "TRUE");    
    static_assert(std::is_same<FL, std::false_type>::value, "FALSE");
}

为什么这个SFINAE片段不能用于g ++，而是在MSVC中工作？

4 个答案: