Modifica dei parametri del modello di modello in C++

Question

Vorrei progettare una classe che crea tipi interni che sono varianti di tipi passati come parametri del modello. Qualcosa come il seguente esempio, non funzionale:

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

Da Base è un tipo completamente specificato, Base<RefinedType> refinedStorage; mancheranno di compilazione. Semplicemente usando un parametro template template non funzionerà, poiché il tipo raffinato deve essere basato sul parametro del template annidato e sul suo tipo base.

Come è possibile implementare questo modello di creazione di tipi in base ai tipi completamente specificati e di base di un parametro di modello?

MODIFICA: mi piacerebbe che fosse un composito a profondità arbitraria, con più tipi di iniettori che eseguono una cascata di trasformazioni. Quindi, passare sia il parametro template template che il parametro base diventa piuttosto ingombrante (in particolare quando si tratta di trattare il caso base del composito), e una soluzione ideale userebbe la sintassi più diretta.

Answer 1

sono stato in grado di raggiungere questo obiettivo in modo esplicito 'ri-dichiarando' il modello generale al suo interno:

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

È possibile fornire un rebinder esterna:

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

È potrebbe introdurre un modello 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; 

con cui la vostra Injector diventa:

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

Answer 4

Non v'è alcuna necessità di un modello di rilegatura, che l'eccesso di complica la situazione. È sufficiente un modello di modello di modello:

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

Dovrai utilizzare una specializzazione di modello per ottenere un tipo concreto da un modello di modello.

Questo è usato in questo modo:

using injector_int = Injector<Base<int>>; 

int main(){ 
    injector_int i; 
} 

here's a live example