Definition d'une classe dérivée d'un template

Bonjour,
Ma question est toute simple et donc sera la réponse j'espère.
Je voudrais savoir la syntaxe de définition d'une classe dérivée d'une classe parente ayant un template.
Par exemple, voici comment la classe de base est définie

Code:

---

1 2 3 4 5 6

template<class T> class MaClasse: public ClasseDeBase, public T {   }

---

La question est de savoir comment définir une classe dérivée.

voici deux exemple, je crois que c'est comme ca la syntaxe de mémoire ;)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

template<int a> class mere{ ... }   class fille : public mere<16> { ...}       template <class T> class mere{ ... }     class fille: public mere<int> { ... }

---

Euh j'ai pas tout comprit, j'espère que ma reponse t'aidera.
Voici un exemple:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

class Mere { };   template <class T> class Fille : public T { };   int main() { Fille<Mere> obj;   return EXIT_SUCCESS; }

---

A moins qu'il ne s'agisse comme le dit loicounet de :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template <class T> class Mere { // ... }   template <class T> class Fille : public Mere<T> { // ... }

---

Je pense que sa question est plutot "Peut-on faire hériter une classes d'un template ?"

Personnelement, je n'ai pas essayé et je ne peux pas la ou je suis...

Ceci dit, ca doit poser pas mal de problème...

Sinon, la solution proposé par Alp et Loicounet doit bien te faire le résultat que tu veux (en déviant un peu) non ?

Apo`

Citation:

---

Je pense que sa question est plutot "Peut-on faire hériter une classes d'un template ?"

---

Oui, je l'ai déjà fait donc c'est possible.

Ca ne pose aucun problème.

Soit Mere<T> une classe template.

On peut en hériter de 2 façons :
- soit on fixe le type T : class Fille : public Mere<int>
- soit la classe fille sera elle-même template : template <typename T> class Fille : public Mere<T>

Et ça ne pose aucun problème. Il ne faut pas voir du mal dans les templates, bien au contraire ;)

Hmmm, visiblement j'ai autant mal formulé que franc82

Il veut pas faire (enfin je pense....) :

Code:

---

1 2 3

template <typename T> class Fille : public Mere<T>

---

Il veut faire (enfin je pense toujours...) :

Code:

---

1 2 3

template <class Mere> class Fille : public Mere

---

Ch'ui curieux de savoir si c'est possible :aie:

Ceci dit, la solution :

Code:

---

1 2	class Fille : public Mere<T>

---

Fonctionne a merveille et revient au meme je pense (enfin, de l'utilité que j'en voie...)

Apo`

Ah. J'avais mal compris.
Faire :

Code:

---

1 2	template <class Mere> class Fille : public Mere

---

est tout à fait possible.

Ok,

Merci pour ma curiosité :)

Ceci dit, ca doit poser pas mal de problème quand meme... Notemment niveau des attributs hérités tout betement... Enfin, dans le cadre d'héritage d'une classe complexe, l'utilisation qu'on en fait doit pas mal restreindre le template...

Enfin bon, c'est pas le problème de franc82, c'est un autre débat :)

Apo`

Je ne vois pas le soucis.

C'est simple, si tu fais Fille<A>, ça va hériter de A publiquement, et voilà.

Après, ce qui est intéressant, c'est de contraindre la classe de bases sur certains choses.

Par exemple :

Code:

---

1 2 3 4 5 6 7 8 9

template <class T> class Fille : public T { public: Fille(const A& a) { T::init(a); } };

---

Ici par exemple on oblige à ce que T possède une méthode init qui colle avec l'appel dans le constructeur de Fille<T>.

Si on passe une classe T qui n'a pas de méthode init par exemple, cela génèrera une erreur à la compilation tout simplement.

Oui, justement c'est exactement ce a quoi je pensais.

L'utilisation de la class template dans la classe dériver va forcer la définition de certaines méthodes ou meme attributs dans la class T. Ce qui peut etre une bonne chose !!! Mais je pense que c'est à utiliser modérément, sinon autant faire une classe de base qui est déja contrainte et en hérite.

Comme dans :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

template <typename T> class Mere { // bla bla void init(); }   template <typename T2> class Fille : public Mere<T2> { // bla bla void foo() {Mere::init();} }

---

Mais la c'est ma vue conceptuelle des choses ^^ Niveau encapsulation et définition je trouve ca plus propre... Apres ca marche très bien aussi de l'autre manière !!!

Apo`

Hmm je ne vois toujours pas le problème.

Si tu contrains, c'est que tu as des raisons.

C'est à dire qu'on peut passer n'importe quel type pour peu qu'il définisse telles ou telles fonctions, etc.

Ca laisse de la souplesse. Pourtant, si on se rate, ce n'est pas grave car le compilo va nous dire que l'on passe un type qui ne satisfait pas les contraintes.

On utilise parfois ce genre de choses pour faire une classe Singleton, par exemple.

M'enfin avec les concepts de C++0x ça sera plus simple à gérer sans avoir un héritage au milieu.

Ah oui, oui, je suis entierement d'accord. :mouarf:

C'est juste un problème conceptuel la, aucunement technique.
Le fait de "trop" restreindre une class par héritage, je le vois mieux restreind au niveau supérieur (une class en plus qui définie une base)

Mais ca revient au meme ^^ (surtout si c'est pour réstreindre une seule méthode, auquel cas, faire une classe de base pour ca ne vaut pas la peine !)

Apo`

Je trouve ça beaucoup trop lourd d'insérer une classe entre les deux... Qu'apporterait selon toi une classe qui vérifierait un cran avant que le type satisfait les contraintes ?

Au niveau technique : absolument rien !!!

Au niveau conceptuel : Si la classe doit avoir beaucoup de restrictions, la clarté de lisibilité et de compréhension de l'arbre de classes.

Apo`