如何将模板模板与模板实例进行比较？

Question

首先给大家介绍一个部分解决方案：

template <template <class...> class,
        typename ...>
struct is_tbase_of:
  std::false_type
{ };

template <template <class...> class Type,
          typename ...Args>
struct is_tbase_of<Type, Type<Args...>>:
  std::true_type
{ };

在一般情况下，它有效：

is_tbase_of<std::vector, std::is_integral<int>>::value; // false
is_tbase_of<std::vector, std::vector<int>>::value;      // true

但是，它不适用于 «meta-returned» 模板，例如：

template <template <class ...> class T>
struct quote
{
  template <typename ...U>
  using type = T<U...>;
};

using QVec =  quote<std::vector>;
is_tbase_of<QVec::template type, std::vector<int>>::value; // false...

我已经尝试了很多东西，试图获得第二种类型的模板参数（以比较引用类型的特化），但似乎我无法让它们工作。甚至将 is_tbase_of 专门化为 quote（这是一个不太通用但足够的选择）似乎把我带到了模板模式匹配的黑角。

Answer 1

如果针对 quote 专门化 is_tbase_of 就足够了，这应该可行：

template <template <class...> class Type,
          typename ...Args>
struct is_tbase_of<quote<Type>::template type, Type<Args...>>:
  std::true_type
{ };

Answer 2

您可以检查是否可以将 U<Args...> 更改为 T<Args...>，然后检查结果是否保持不变：

#include <type_traits>
#include <vector>

struct is_tbase_of_impl
{
    struct err {};

    template <template <class...> class T, class U>
    static err test(U*);

    template <template <class...> class T, template <class...> class U, class... Args>
    static T<Args...> test(U<Args...>*);
};

template <template <class...> class T, class U>
using is_tbase_of
    = typename std::is_same< decltype(is_tbase_of_impl::test<T>((U*)0)), U >::type;

template <template <class...> class T>
struct quote
{
    template <class... U>
    using type = T<U...>;
};

using QVec = quote<std::vector>;

template <class...> struct S {};

static_assert( !is_tbase_of< std::vector, std::is_integral<int>  >::value, "" );
static_assert(  is_tbase_of< std::vector, std::vector<int>       >::value, "" );
static_assert(  is_tbase_of< QVec::type,  std::vector<int>       >::value, "" );
static_assert( !is_tbase_of< std::vector, S<int, int, int>       >::value, "" );

int main()
{
}

Answer 3

您的原始实现不起作用的原因是，即使 QVec::type<Args...> 与 std:vector<Args...> 的类型相同，QVec::type 也不相同 template as std::vector，所以它不匹配偏特化。

这可以通过一个更简单的例子看出：

template <template <typename...> class> struct test {
  static const bool value = false;
};

template <>
struct test<std::vector> {
  static const bool value = true;
};

test<std::vector>::value; // true
test<QVec::type>::value;  // false

这是一种几乎可行的方法：

template <template <class...> class Type1,
          template <class...> class Type2,
          typename... Args>
struct is_tbase_of<Type1, Type2<Args...>>:
  std::is_same<Type1<Args...>,Type2<Args...>>
{
};

但是，正如@Alex 所指出的，这不处理第二个模板的参数与第一个模板不兼容的情况。这可以使用 enable_if:

来解决

template <template <class...> class, typename, typename=void>
struct is_tbase_of : std::false_type { };

template <template <class...> class Type1,
          template <class...> class Type2,
          typename... Args>
struct is_tbase_of<Type1, Type2<Args...>,
  typename std::enable_if<
    std::is_same<Type1<Args...>,Type2<Args...>>::value
  >::type>
  : std::true_type
{
};

Answer 4

这是解决直接模板结构元编程和SFINAE问题的尝试。

计划是2折。首先，一个特征class，它接受一个模板和一组参数，并回答"is it legal to apply the pack of arguments to the template"。这是一个非常有用的结构：例如，给定一个 SFINAE 友好 result_of_t<F(Args...)>，你可以在一行中写 can_invoke<F(Args...)>。

其次，我们写is_template_instance_of。这里的目标是采用 T<Args...> 类型和 Z<?...> 模板，并查看 Z<Args...> 是否与 T<Args...> 类型相同。我们利用上面的can_apply traits class 来防范非法替换，然后做一个简单的is_same 测试。

该解决方案会产生一些误报和漏报，具体取决于您如何看待它。基本上，如果我们匹配的模板 Z<?...> 是一个不是直接别名的别名模板，它就不会像您预期的那样工作。如果它是直接别名，你会很好。

事不宜迟，下面是实现。

首先，样板类型包：

template<class...>struct types {using type=types;};

在C++1z中有void_t，我在这里重新实现：

template<class...>struct voider{using type=void;};
template<class...Ts>using void_t=typename voider<Ts...>::type;

给定 Z<?...> 和 types<Ts...>，检查 Z<Ts...> 是否有效：

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

现在，SFINAE 保护测试：

template<template<class...>class Z, class T, class=void>
struct is_template_instance_of : std::false_type {};

template<template<class...>class Z, template<class...>class Y, class... Ts>
struct is_template_instance_of<
  Z, Y<Ts...>,
  std::enable_if_t<can_apply< Z, types<Ts...> >{}>
> : std::is_same< Z<Ts...>, Y<Ts...> > {};

live example

如何将模板模板与模板实例进行比较？

How to compare a template template with a template instance?

c++

templates

metaprogramming

c++11

c++14