Question

我一直致力于生成有关在C ++中包装其他类的类的编译时信息。在我要问的问题的最小例子中，这样一个包装类：

包含一个typedef WrappedType，用于定义包装类的类型;和
重载名为IsWrapper的结构模板，以指示它是一个包装类。

有一个名为WrapperTraits的结构模板，可用于确定包装类型层次结构的（非包装）根类型。例如。如果包装类是名为Wrapper<T>的类模板，则Wrapper<Wrapper<int>>的根类型将为int。

在下面的代码片段中，我实现了一个名为GetRootType<T>的递归结构模板，它定义了typedef RootType，它提供了包装类型T的根类型。 WrapperTraits的给定定义只包含GetRootType定义的根类型，但实际上它会有一些额外的成员。为了测试它，我编写了一个普通的函数f，它带有一个int和一个重载的函数模板f，它接受一个以int为根的任意包装类类型。我使用SFINAE来区分它们，在函数模板的返回类型中使用std::enable_if来检查f的参数的根类型是否为{ {1}}（如果int的参数不是包装器，尝试确定其根类型将失败）。在我提出问题之前，这里是代码片段：

这正确编译（try it here）并产生输出：

#include <iostream>
#include <type_traits>


// Wrapper #######################################

template<class T>
struct Wrapper {typedef T WrappedType;};

template<class T, class Enable=void>
struct IsWrapper: std::false_type {};

template<class T>
struct IsWrapper<Wrapper<T> >: std::true_type {};


// WrapperTraits #######################################

template<
  class T,
  bool HasWrapper=
    IsWrapper<T>::value && IsWrapper<typename T::WrappedType>::value>
struct GetRootType {
  static_assert(IsWrapper<T>::value,"T is not a wrapper type");

  typedef typename T::WrappedType RootType;
};

template<class T>
struct GetRootType<T,true> {
  typedef typename GetRootType<typename T::WrappedType>::RootType RootType;
};

template<class T>
struct WrapperTraits {
  typedef typename GetRootType<T>::RootType RootType;
};


// Test function #######################################

void f(int) {
  std::cout<<"int"<<std::endl;
}

// #define ROOT_TYPE_ACCESSOR WrapperTraits  // <-- Causes compilation error.
#define ROOT_TYPE_ACCESSOR GetRootType    // <-- Compiles without error.

template<class T>
auto f(T) -> 
  typename std::enable_if<
    std::is_same<int,typename ROOT_TYPE_ACCESSOR<T>::RootType>::value
  >::type
{
  typedef typename ROOT_TYPE_ACCESSOR<T>::RootType RootType;

  std::cout<<"Wrapper<...<int>...>"<<std::endl;
  f(RootType());
}


int main() {
  f(Wrapper<int>());  
  return 0; 
}

但是，我使用Wrapper<...<int>...> int来确定对GetRootType的调用中的根类型。如果我使用std::enable_if来确定根类型（您可以通过更改WrapperTraits的定义来执行此操作），GCC会产生以下错误：

ROOT_TYPE_ACCESSOR

我的问题是：关于C ++标准中的参数推导的规则解释了为什么使用test.cpp: In instantiation of ‘struct WrapperTraits<int>’: test.cpp:49:6: required by substitution of ‘template<class T> typename std::enable_if<std::is_same<int, typename WrapperTraits<T>::RootType>::value>::type f(T) [with T = int]’ test.cpp:57:15: required from ‘typename std::enable_if<std::is_same<int, typename WrapperTraits<T>::RootType>::value>::type f(T) [with T = Wrapper<int>; typename std::enable_if<std::is_same<int, typename WrapperTraits<T>::RootType>::value>::type = void]’ test.cpp:62:19: required from here test.cpp:21:39: error: ‘int’ is not a class, struct, or union type bool HasWrapper=IsWrapper<T>::value && IsWrapper<typename T::WrappedType>::value>会导致编译错误但是使用WrapperTraits不会？请注意我想要问的是能够理解为什么发生这种编译错误。我对可以进行哪些更改以使其工作不感兴趣，因为我已经知道将GetRootType的定义更改为此可以修复错误：

WrapperTraits

但是，如果有人能够看到更优雅的写作方式template< class T, class Enable=typename std::enable_if<IsWrapper<T>::value>::type> struct WrapperTraits { typedef typename GetRootType<T>::RootType RootType; }; template<class T> struct WrapperTraits<T,typename std::enable_if<!IsWrapper<T>::value>::type> { };和f，我会非常有兴趣看到它！

Answer 1

问题的第一部分是失败的原因。答案是，在编译时级别，&&没有短路属性。这一行：

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; 
}

Live example

Answer 2

您遇到的问题是由于SFINAE仅发生在＆＃34;直接上下文＆＃34; （标准使用的术语，但没有很好地定义）模板实例化。在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实例化。

SFINAE在类模板中使用typedef失败，引用另一个类模板中的typedef

2 个答案: