Discussion :

[zouip]

Bonjour à tous,

Ma question est simple. Considérez le code suivant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
template <class Type>
class Mere
{
   /* ... */
};
 
class Data
{
   /* ... */      
};
 
class Fille : public Mere<Data>
{
   /* ... */     
};

Le code compile parfaitement mais je n'ai jamais eu l'occasion de rencontrer ce type d'implémentation (ou alors j'ai oublié) et j'aimerais simplement savoir si ce genre de code est portable

Merci d'avance!

[Davidbrcz]

Pourquoi en serait 'il pas portable.
C'est du C++, pas plus pas moins.

[Alp]

Si je ne m'abuse, tous les compilateurs connus supportent ce mécanisme.
Si de plus la classe fille est template :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
template <typename T> class Mere { /* ... */ };
template <typename T> class Fille : public Mere<T>
{ /* ... */ };

on appelle ça le CRTP.

C'est très utilisé, notamment de manière combinée aux classes de politique.

[poukill]

Plutôt

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
template <typename T> class Mere { /* ... */ };
class Fille : public Mere<Fille> { /* ... */ };

en fait le CRTP. Mais je n'ai jamais eu l'occasion de l'utiliser! Trop compliqué pour moi !

[Alp]

Oula, oui, désolé.

[koala01]

Salut,

En fait, le CRTP, bien que complexe, est malgré tout utile quand tu es sur qu'un certain nombre de classes (non template) vont présenter des comportements exactement identiques quels que soient les types de données réellement utilisés, mais que tu n'envisage pas de mettre en oeuvre le polymorphisme.

Un autre avantage est de permettre, par exemple, à des membres statiques, définis dans la classe de base, d'être malgré tout d'être définis pour chaque type existant.

Ainsi, on peut se rappeler que dans le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Base
{
    /*...*/
    protected:
        static UnType membre;
};
class Derive : public Base
{
    /*...*/
};
class Derivee2 : public Base
{
    /*...*/
};

toutes les variables qui sont de type Base, Derivee ou Derivee2 partageront le même membre, alors que, dans le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
template <class T>
class Base
{
    /*...*/
    protected:
        static UnType mbre;
};
class Derive : public Base<Truc>
{
    /*...*/
};
class Derivee2 : public Base<Bidule>
{
    /*...*/
};

(remarque qu'ici, ce n'est pas forcément du CRTP à proprement parler ) Derivee et Derivee2 ne partagent pas *forcement* le meme membre mbre (elles ne le partageront que si le type fourni comme spécialisation de Base est identique )