Zmiana parametrów szablonu szablonu w C++

Question

Chciałbym zaprojektować klasę, która tworzy typy wewnętrzne, które są wariantami typów przekazywanych jako parametry szablonu. Coś jak następujący, niefunkcjonalnych przykład:

template <typename T> 
class BaseClass 
{ 
public: 
    typedef T InternalType; 
    std::vector<InternalType> storage; 
}; 

template <typename Base> 
class Injector 
{ 
public: 
    typedef std::pair<typename Base::InternalType, typename Base::InternalType> RefinedType; 
    Base<RefinedType> refinedStorage; 
}; 

typedef Injector<BaseClass<int> > InjectedInt; // Should store vector<pair<int, int> > 

Od Base jest w pełni określony typ, Base<RefinedType> refinedStorage; nie uda się skompilować. Po prostu użycie parametru szablonu szablonu nie będzie działać, ponieważ zaawansowany typ musi być oparty na parametrze zagnieżdżonego szablonu, jak również na jego typie podstawowym.

W jaki sposób mogę zaimplementować ten wzorzec tworzenia typów na podstawie w pełni określonych i podstawowych typów parametru szablonu?

EDYCJA: Chciałbym, aby był to układ złożony z dowolnych głębokości, z wieloma typami wtryskiwaczy wykonującymi kaskadę transformacji. Zatem przekazanie zarówno parametru szablonu szablonu, jak i podstawowego parametru staje się dość nieporęczne (szczególnie gdy chodzi o radzenie sobie z podstawowym przypadkiem kompozytu), a idealne rozwiązanie korzystałoby z bardziej bezpośredniej składni.

Answer 1

udało mi się to osiągnąć poprzez wyraźne 'ponownie deklarując' ogólny szablon wewnątrz siebie:

template <typename T> 
class BaseClass 
{ 
public: 
    typedef T InternalType; 
    std::vector<InternalType> storage; 

    template<class T2> 
    using Recur = BaseClass<T2>; 
}; 

template <typename Base> 
class Injector 
{ 
public: 
    typedef std::pair<typename Base::InternalType, typename Base::InternalType> RefinedType; 
    typename Base::template Recur<RefinedType> refinedStorage; 
}; 

typedef Injector<BaseClass<int> > InjectedInt; // Should store vector<pair<int, int> > 

Answer 2

można zapewnić rebinder zewnętrzne:

template <class Bound, class U> 
struct rebinder; 

template <template <class> class Binder, class B, class U> 
struct rebinder<Binder<B>, U> 
{ 
    typedef Binder<U> type; 
}; 

// Usage: 

template <typename Base> 
class Injector 
{ 
public: 
    typedef std::pair<typename Base::InternalType, typename Base::InternalType> RefinedType; 
    typename rebinder<Base, RefinedType>::type refinedStorage; 
}; 

[Live example]

Answer 3

Ty może wprowadzić szablon rebind:

template <typename From, typename To> 
struct rebind_1st; 

template <template <typename... > class Cls, typename A0, typename... Args, typename To> 
struct rebind_1st<Cls<A0, Args...>, To> { 
    using type = Cls<To, Args...>; 
}; 

template <typename From, typename To> 
using rebind_1st_t = typename rebind_1st<From, To>::type; 

z jaką Injector staje:

template <typename Base> 
class Injector 
{ 
public: 
    typedef std::pair<typename Base::InternalType, 
         typename Base::InternalType> RefinedType; 
    rebind_1st_t<Base, RefinedType> refinedStorage; 
}; 

Answer 4

Nie ma potrzeby ponownego wiązania do szablonu, który nadmiernie komplikuje sytuację. Po prostu wybierz szablon szablonu:

template<typename> 
struct Injector; 

template<typename T, template<typename> class Base> 
struct Injector<Base<T>>{ 
    using refined_type = std::pair<typename Base::InternalType, typename Base::InternalType>; 
    Base<refined_type> refined_storage; 
}; 

Będziesz musiał użyć specjalizacji szablonu, aby uzyskać konkretny typ z szablonu szablonu.

Służy tak:

using injector_int = Injector<Base<int>>; 

int main(){ 
    injector_int i; 
} 

here's a live example