Comment déclarer/définir une classe avec des paramètres de modèle de modèle sans l'aide d'un paramètre de modèle supplémentaire

Question

Tenir compte de l'utilisation suivante des paramètres du modèle de modèle ...

#include <iostream> 

template <typename X> 
class A 
{ 
    X _t; 
public: 
    A(X t) 
     :_t(t) 
    { 
    } 
    X GetValue() 
    { 
     return _t; 
    } 
}; 

template <typename T, template <typename T> class C > 
class B 
{ 
    C<T> _c; 
public: 
    B(T t) 
     :_c(t) 
    { 
    } 
    T GetValue() 
    { 
     return _c.GetValue(); 
    } 
}; 

using namespace std; 

int main() 
{ 
    B<int, A> b(10); 
    cout<<b.GetValue(); 
    return 0; 
} 

est-il un moyen par lequel le T des paramètres du modèle peut être enlevé? Par exemple, y a-t-il un moyen de faire le travail suivant?

//Does not compile 
template <template <typename T> class C > 
class B 
{ 
    C _c; 
public: 
    B(T t) 
     :_c(t) 
    { 
    } 
    T GetValue() 
    { 
     return _c.GetValue(); 
    } 
}; 

int main() 
{ 
    B< A<int> > b(10); 
    cout<<b.GetValue(); 
    return 0; 
} 

Answer 1

Je suppose que vous êtes après X, ainsi que A, dans votre code.

Le schéma habituel est d'avoir

template<typename C> 
struct B 
{ 
    C c; 
}; 

puis, les classes à l'intérieur admissibles pour la substitution:

template<typename X> 
class A 
{ 
    typedef X type_name; 
    X t; 
}; 

Ensuite, vous pouvez accéder au paramètre de modèle à l'aide C::type_name.

Answer 2

Quel est le problème:

template <typename C > 
struct B 
{ 
    C c; 
}; 

int main() 
{ 
    B< A<int> > b; 
    return 0; 
} 

Answer 3

Ce n'est pas possible. Notez qu'il s'agit d'un malentendu courant: A<int> n'est plus un modèle de classe! Donc, il ne conviendrait pas à un paramètre modèle-modèle, mais devrait être acceptée en utilisant un type paramètre:

template<typename C> 
struct B { 
    C c; 
}; 

B< A<int> > b; 

Votre façon d'utiliser un paramètre séparé est bien.

Si vous voulez accepter A<int> mais que vous souhaitez re-lier à un autre paramètre, vous pouvez utiliser ce modèle, également utilisé par la norme-allocateurs:

template<typename T> 
struct A { 
    template<typename U> 
    struct rebind { 
     typedef A<U> type; 
    }; 
}; 

template<typename C> 
struct B { 
    typename C::template rebind<float>::type c; 
}; 

B< A<int> > b; 

Maintenant, B< A<int> >::c est de type A<float>. Le typename avant C:: indique au compilateur que le ::type à la fin est un type et non un membre statique non-type. Le template après C:: indique au compilateur que le rebind<float> est un instanciation de modèle, et non une comparaison.

Answer 4

Vous pouvez imbriquer des paramètres. C'est-à-dire que la valeur d'un paramètre peut elle-même être paramétrée.

template <typename X> 
struct A 
{ 
    X t; 
}; 

template <typename C> 
struct B 
{ 
    C c; 
}; 

int main() 
{ 
    B< A<int> > b; 
    return 0; 
} 

Dans cet exemple, la déclaration de b dans main() crée une spécialisation de A en utilisant int comme paramètre, il crée une spécialisation de B en utilisant A<int> comme paramètre. Ainsi, dans la spécialisation de B, C est A<int>.