类模板中的 typedef 的 SFINAE 失败是指另一个类模板中的 typedef

你问题的第一部分是为什么它失败了。答案是，在编译时级别，&&没有短路属性。这一行：

bool HasWrapper=IsWrapper<T>::value && IsWrapper<typename T::WrappedType>::value>

失败，因为第一个条件是false，但编译器尝试实例化第二部分，但T int，因此T::WrappedType不起作用。

为了回答你关于如何让它更容易的问题的第二部分，我认为以下内容应该让你很高兴：

#include <iostream>
#include <type_traits>
// Wrapper #######################################
template<class T>
struct Wrapper {};
// All you need is a way to unwrap the T, right?
template<class T>
struct Unwrap { using type = T; };
template<class T>
struct Unwrap<Wrapper<T> > : Unwrap<T> {};
// Test function #######################################
void f(int) {
  std::cout<<"int"<<std::endl;
}
// Split unwrapping and checking it with enable_if<>:
template<class T,class U=typename Unwrap<T>::type>
auto f(T) -> 
  typename std::enable_if<
    std::is_same<int,U>::value
  >::type
{
  std::cout<<"Wrapper<...<int>...>"<<std::endl;
  f(U());
}    
int main() {
  f(Wrapper<int>());  
  return 0; 
}

现场示例

您遇到的问题是由于 SFINAE 仅在模板实例化的"即时上下文"（标准使用的术语，但定义不佳）中发生。WrapperTraits<int>的实例化是在auto f<int>() -> ...实例化的直接上下文中，并且它成功了。不幸的是，WrapperTraits<int>有一个格式不正确的成员RootType。该成员的实例化不在直接上下文中，因此 SFINAE 不适用。

要使此 SFINAE 按预期工作，您需要安排WrapperTraits<int>没有名为 RootType 的类型，而不是具有这样的成员，而是具有格式不正确的定义。这就是为什么更正后的版本按预期工作的原因，尽管您可以通过重新排序来节省一些重复：

template<class T, class Enable=void>
struct WrapperTraits {};
template<class T>
struct WrapperTraits<T,typename std::enable_if<IsWrapper<T>::value>::type> {
  typedef typename GetRootType<T>::RootType RootType;
};

我可能会将整个特征系统编码为 （DEMO）：

// Plain-vanilla implementation of void_t
template<class...> struct voider { using type = void; };
template<class...Ts>
using void_t = typename voider<Ts...>::type;
// WrapperTraits #######################################
// Wrapper types specialize WrappedType to expose the type they wrap;
// a type T is a wrapper type iff the type WrappedType<T>::type exists.
template<class> struct WrappedType {};
// GetRootType unwraps any and all layers of wrappers.
template<class T, class = void>
struct GetRootType {
  using type = T; // The root type of a non-WrappedType is that type itself.
};
// The root type of a WrappedType is the root type of the type that it wraps.
template<class T>
struct GetRootType<T, void_t<typename WrappedType<T>::type>> :
  GetRootType<typename WrappedType<T>::type> {};
// non-WrappedTypes have no wrapper traits.
template<class T, class = void>
struct WrapperTraits {};
// WrappedTypes have two associated types:
// * WrappedType, the type that is wrapped
// * RootType, the fully-unwrapped type inside a stack of wrappers.
template<class T>
struct WrapperTraits<T, void_t<typename WrappedType<T>::type>> {
  using WrappedType = typename ::WrappedType<T>::type;
  using RootType = typename GetRootType<T>::type;
};
// Convenience aliases for accessing WrapperTraits
template<class T>
using WrapperWrappedType = typename WrapperTraits<T>::WrappedType;
template<class T>
using WrapperRootType = typename WrapperTraits<T>::RootType;

// Some wrappers #######################################
// Wrapper<T> is a WrappedType
template<class> struct Wrapper {};
template<class T>
struct WrappedType<Wrapper<T>> {
  using type = T;
};
// A single-element array is a WrappedType
template<class T>
struct WrappedType<T[1]> {
  using type = T;
};
// A single-element tuple is a WrappedType
template<class T>
struct WrappedType<std::tuple<T>> {
  using type = T;
};

虽然那里有很多机械，而且它可能比你需要的更重。例如，可以取消WrapperTraits模板，而直接使用WrappedType和GetRootType。我无法想象您经常需要传递WrapperTraits实例化。