如何传输模板？ [英] How to transmit a template?

问题描述

我想要一个具有2个模板参数的基本模板类。特别地，第二个参数是模板参数。 派生派生自 Base 与CRTP。现在我想生成 Derived 的基类，如 Base< Derived，Derived :: second_tmpl> ，但生成基类与 Derived 的真正基类不同。如何传送范本？

  #include< type_traits> 
 
 template< typename T，template< typename> class U> 
 struct Base 
 {
使用type = Base< T，U> ;; 
使用devired_type = T; 
 template< typename V> 
 using second_tmpl = U< V> 
 using second_type = second_tmpl< type> ;; 
}; 
 
 template< typename T> 
 struct Template 
 {
 using type = Template< T> ;; 
}; 
 
 struct Derived 
：public Base< Derived，Template> 
 {
}; 
 
 // true 
 static_assert（
 std :: is_same< 
 Derived :: second_type，
 Template< Base< Derived，Template>> ; :: value，
false）; 
 // false 
 static_assert（
 std :: is_base_of< 
 Base< Derived，Derived :: second_tmpl> ;, 
 Derived 
> :: value ，
false）; 
 
 template< typename T> 
使用Template2 = Template< T> ;; 
 // false 
 static_assert（
 std :: is_same< 
 Base< Derived，Template>，
 Base< Derived，Template2> 
> ：value，
false）; 
  

使用与原始模板相同的模板，而不是原始模板。判断为假;

解决方案

这些是tempalte模板参数的限制。

模板模板参数是C ++中的二等公民 ：（

第二个assert应该真正读取

  static_assert（std :: is_base_of< Base< Derived ，template>，Derived> :: value，false）; 
  

p>

为了解决第三个问题（你不能打开一个打开的模板的事实），使它成为一个元功能：例如在以下程序中使用 TemplateGen ：

Live on Coliru

  #include< type_traits> 
 
 template< typename T，typename UGen> 
 struct Base {
 using type = Base& UGen ::模板类型< T> > ;; 
使用devired_type = T; 
 
 template< typename V> using second_tmpl = typename UGen :: template type< T> ; 
 using second_type = second_tmpl< type> ;; 
}; 
 
 template< typename T> 
 struct Template {
 using type = Template< T> ;; 
}; 
 
 struct TemplateGen {
 template< typename T> using type = Template< T> ;; 
}; 
 
 struct派生：public Base< Derived，TemplateGen> {
}; 
 
 // true 
 static_assert（std :: is_same< Derived :: second_type，Template< Derived>> :: value，false）; 
 // false 
 static_assert（std :: is_base_of< Base< Derived，TemplateGen> ;, Derived> :: value，false）; 
 
使用Template2 = TemplateGen; 
 
 // false 
 static_assert（std :: is_same< Base< Derived，TemplateGen> Base< Derived，Template2>> :: value，false）; 
 
 int main（）{} 
  

i want a Base template class with 2 template parameters. Specially, second parameter is a template parameter. Derived is derived from Base with CRTP. Now i want to generate the base class of Derived like Base<Derived,Derived::second_tmpl>, but the generating base class isn't same as the real base class of Derived. How do i transmit a template?

#include <type_traits>

template<typename T, template<typename>class U>
struct Base
{
    using type = Base<T,U>;
    using devired_type = T;
    template<typename V>
    using second_tmpl = U<V>;
    using second_type = second_tmpl<type>;
};

template<typename T>
struct Template
{
    using type = Template<T>;
};

struct Derived
    :public Base<Derived,Template>
{
};

//true
static_assert(
        std::is_same<
            Derived::second_type,
            Template<Base<Derived,Template>>>::value,
        "false");
//false
static_assert(
        std::is_base_of<
            Base<Derived,Derived::second_tmpl>,
            Derived
        >::value,
        "false");

template<typename T>
using Template2 = Template<T>;
//false
static_assert(
        std::is_same<
            Base<Derived,Template>,
            Base<Derived,Template2>
        >::value,
        "false");

Use a template which is the same as the original template instead of the original template. The judgement is false;

解决方案

These are the limitations of tempalte template arguments.

Template template arguments are second-class citizens in C++ :(

The second assert should really read

static_assert(std::is_base_of<Base<Derived, Template>, Derived>::value, "false");

which would work.

To combat the problem with the third (the fact that you "can't typedef an open template"), make it a meta-function: e.g. with TemplateGen in the below program:

Live On Coliru

#include <type_traits>

template <typename T, typename UGen>
struct Base {
    using type = Base<T, typename UGen::template type<T> >;
    using devired_type = T;

    template <typename V> using second_tmpl = typename UGen::template type<T> ;
    using second_type = second_tmpl<type>;
};

template <typename T>
struct Template {
    using type = Template<T>;
};

struct TemplateGen {
    template <typename T> using type = Template<T>;
};

struct Derived : public Base<Derived, TemplateGen> {
};

// true
static_assert(std::is_same<Derived::second_type, Template<Derived> >::value, "false");
// false
static_assert(std::is_base_of<Base<Derived, TemplateGen>, Derived>::value, "false");

using Template2 = TemplateGen;

// false
static_assert(std::is_same<Base<Derived, TemplateGen>, Base<Derived, Template2>>::value, "false");

int main(){}

这篇关于如何传输模板？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！