检查是否存在嵌套类型的别名并有条件设置类型别名

Question

我不知道如何根据这样的输入参数中的类型别名有条件地设置类型的别名。

struct a { using type = int; }

template <typename T> struct wrapper {
    using inner_t = ???how???; // if T::type exists, use T::type, else T
};

static_assert(std::is_same<wrapper<int>::inner_t, int>, "expected int");
static_assert(std::is_same<wrapper<a>::inner_t, int>, "expected inner type: int");

一个天真的尝试就像std ::条件＆lt; std :: is_class＆lt; t＆gt; t :: type，type，t＆gt;如果存在type> type type type 别名是先决条件，但远非安全，还没有检查is_alias_present＆lt; t，type＆gt;之类的检查。除此之外，t :: Type可能并不存在导致编译器错误的所有类型。

Apearthy std :: fastiment :: superiment :: is_detected 不幸的是，但不幸的是，不幸的是目前。

不确定是否像boost :: mp11或boost :: hana这样的好方法是完成此操作的好方法。

Answer 1

借助

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

template<class T>
  requires requires { typename T::type; }
struct innter<T> {
  using type = T::type;
};

template <typename T> 
struct wrapper {
  using innter_t = innter<T>::type; // if T::type exists, use T::type, else T
};

C ++ 17中的C ++ 20概念，您可以使用void_t来检测t :: Type

#include <type_traits>

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

template<class T>
struct innter<T, std::void_t<typename T::type>> {
  using type = typename T::type;
};

template <typename T> 
struct wrapper {
  using innter_t = typename innter<T>::type; // if T::type exists, use T::type, else T
};

demo

Answer 2

一种选择是像这样的作品中编写类型特征

template <typename T, typename = void >
struct type_member
{
    using type = T;
};
 
template <typename T >
struct type_member<T, std::void_t<typename T::type>>
{
    using type = typename T::type;
};

template <typename T >
using type_member_t = type_member<T>;

，然后在包装器中使用它来使用

template <typename T>
struct wrapper
{
    using type = type_member_t<T>::type;
};

int main()
{
    static_assert(std::is_same_v<typename wrapper<int>::type, int>, "expected int");
    static_assert(std::is_same_v<typename wrapper<a>::type, int>, "expected inner type: int");
}

Sfinae，而如果typename t :: Type在std :: void_t＆lt; typeName t :: type＆gt;然后丢弃了type_member的专业化，我们回到了非类型成员专业化。

Answer 3

有两件事，要检测存在的特征和懒惰的评估。

在C ++ 20中，可以使用需要轻松完成这些特征

template <typename T>
concept has_type = requires { typename T::type; }

然后懒惰评估：

template <typename T> struct wrapper {
    using inner_t = std::conditional_t<has_type<T>, T, std::type_identity<T> >::type;
};