C++检测习惯用语失败与继承

Question

下面的代码编译失败。 由于某种原因，从HasFoo继承会导致IsWrapper失败。 它与friend函数有关foo()因为从其他类继承似乎工作正常。 我不明白为什么从HasFoo继承会导致检测习惯用法失败。

将WithFoo检测为Wrapper的正确方法是什么？

https://godbolt.org/z/VPyarN

#include <type_traits>
#include <iostream>
template<typename TagType, typename ValueType>
struct Wrapper {
  ValueType V;
};
// Define some useful metafunctions.
template<typename Tag, typename T>
T BaseTypeImpl(const Wrapper<Tag, T> &);
template<typename T>
using BaseType = decltype(BaseTypeImpl(std::declval<T>()));
template<typename Tag, typename T>
Tag TagTypeImpl(const Wrapper<Tag, T> &);
template<typename T>
using TagType = decltype(TagTypeImpl(std::declval<T>()));
// Define VoidT.  Not needed with C++17.
template<typename... Args>
using VoidT = void;
// Define IsDetected.
template<template <typename...> class Trait, class Enabler, typename... Args>
struct IsDetectedImpl
  : std::false_type {};
template<template <typename...> class Trait, typename... Args>
struct IsDetectedImpl<Trait, VoidT<Trait<Args...>>, Args...>
  : std::true_type {};
template<template<typename...> class Trait, typename... Args>
using IsDetected = typename IsDetectedImpl<Trait, void, Args...>::type;
// Define IsWrapper true if the type derives from Wrapper.
template<typename T>
using IsWrapperImpl =
  std::is_base_of<Wrapper<TagType<T>, BaseType<T>>, T>;
template<typename T>
using IsWrapper = IsDetected<IsWrapperImpl, T>;
// A mixin.
template<typename T>
struct HasFoo {
  template<typename V,
           typename std::enable_if<IsWrapper<T>::value &&
                                   IsWrapper<V>::value>::type * = nullptr>
  friend void foo(const T &This, const V &Other) {
    std::cout << typeid(This).name() << " and " << typeid(Other).name()
              << " are wrappersn";
  }
};
template<typename Tag>
struct WithFoo : public Wrapper<WithFoo<Tag>, int>,
                 public HasFoo<WithFoo<Tag>> {};
int main(void) {
  struct Tag {};
  WithFoo<Tag> WrapperFooV;
  // Fails.  Why?
  static_assert(IsWrapper<decltype(WrapperFooV)>::value,
                "Not a wrapper");
  return 0;
}

Answer 1

我不明白为什么从HasFoo继承会导致检测习惯用法失败。

我也不完全清楚，但肯定有一个问题是您在HasFoo<T>体内使用IsWrapper<T>，当您从WithFoo<Tag>继承HasFoo<WithFoo<Tag>>时，当您与IsWrapper一起检查时，WithFoo<Tag>不完整。

一个可能的解决方案(我不知道您是否可以接受(是在HasFoo之外定义(和 SFINAE 启用/禁用(foo()。

我的意思是。。。尝试重写HasFoo如下所示

template <typename T>
struct HasFoo {
  template <typename V>
  friend void foo(const T &This, const V &Other);
};

并在外部定义foo()

template <typename T, typename V>
std::enable_if_t<IsWrapper<T>::value && IsWrapper<V>::value>
      foo(const T &This, const V &Other) {
  std::cout << typeid(This).name() << " and " << typeid(Other).name()
            << " are wrappersn";
}

将 WithFoo 检测为包装器的正确方法是什么？

抱歉，您的代码对我来说太复杂了。

我提出以下(我希望更简单(替代方案

#include <type_traits>
#include <iostream>
template<typename TagType, typename ValueType>
struct Wrapper {
  ValueType V;
};
template <typename T1, typename T2>
constexpr std::true_type IW_helper1 (Wrapper<T1, T2> const &);
template <typename T>
constexpr auto IW_helper2 (T t, int) -> decltype( IW_helper1(t) );
template <typename T>
constexpr std::false_type IW_helper2 (T, long);
template <typename T>
using IsWrapper = decltype(IW_helper2(std::declval<T>(), 0));
template <typename T>
struct HasFoo {
  template <typename V>
  friend void foo(const T &This, const V &Other);
};
template <typename T, typename V>
std::enable_if_t<IsWrapper<T>::value && IsWrapper<V>::value>
      foo(const T &This, const V &Other) {
  std::cout << typeid(This).name() << " and " << typeid(Other).name()
            << " are wrappersn";
}
template<typename Tag>
struct WithFoo : public Wrapper<WithFoo<Tag>, int>,
                 public HasFoo<WithFoo<Tag>> {};
int main () {
  struct Tag {};
  WithFoo<Tag> WrapperFooV;
  static_assert(IsWrapper<decltype(WrapperFooV)>::value,
                "Not a wrapper");
}