Discussion :

[Baubeau Cédric]

Bonsoir,

Soit une classe définie ainsi:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
template <class T> class X
{
...
public:
x();
~X();
T fonction(T);
...
}

A t'-on le droit de créer une classe Y dérivée de X<int> directement ainsi:

Code :

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

1
2
3
4
5
6
7
8
9
 
class Y: public X<int>
{...
public:
Y();
~Y();
int autreFonction(int);
...
}

En fait, j'ai vu dans le livre "Le Langage C++" de Bjarne Stroustrup qu'on peut utiliser la dérivation et les modèles ensembles, mais je n'ai pas trouvé d'exemples de ce type.
Si cet exemple n'est pas possible (mais il l'est certainement ...), alors comment dériver une classe d'un modèle de classe ?
Merci pour vos lumières.

[koala01]

Salut,

Oui, tu peux parfaitement faire hériter une classe d'une spécialisation de classe template.

Il faut, cependant, prendre en compte le fait qu'une classe MaClass<char> est, de facto, différente d'une class MaClass<int>.

Cela signifie que, si tu te trouve dans une situation dans laquelle tu aurais deux classes dérivant chacune d'une spécialisation particulière d'une classe template, c'est à dire proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
template <typename T>
class MyTemplate
{
    /* contenu de la classe */
}; 
class MaClassChar : public MyTemplate<char>
{
    /* contenu de la classe */
};
class MaClassInt : public MyTemplate<int>
{
    /* contenu de la classe */
};

il n'existe aucun lien de parentée entre la classe MaClassChar et la classe MaClassInt.

Cela impliquera, entre autres, le fait qu'il te sera impossible -- sauf si MyTemplate venait à dériver, elle-même d'une classe non template -- de créer une collection d'objet contenant simultanément des instances de MaClasseChar et de MaClassInt (ou de leur classes mères / ancêtres).

Par contre, ce type d'héritage associé à l'idiome CRTP (Curriously Recuriing Template Pattern) permet, justement, d'assurer un héritage d'interface sans forcément impliquer une relation de parentée quelconque.

Ainsi, tu pourrais tout à fait envisager une interface propre à un singleton proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
template <class T>
class TSingleton
{
    public:
        static T & instance()
        {
            static T inst;
        }
    protected:
       TSingleton(){} // protégé pour éviter la tentation d'en avoir une
                      // instance différente
       ~TSingleton(){} // idem
};

dont pourraient profiter plusieurs classes singleton sans qu'il n'y ait la moindre relation (hormis l'interface similaire) entre elles sous une forme proche de

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
16
17
18
19
20
21
22
23
 
class MonSingleton :public TSingleton<MonSingleton> // CRTP inside
{
     /* pour permettre à la classe mère d'accéder au constructeur */
    friend class TSingleton<MonSingleton>
    public:
        void foo();
        void bar();
    private:
        MonSingleton(){}
        ~MonSingleton(){}                                        
};
class AutreSingleon:public TSingleton<AutreSingleon>// CRTP inside
{
     /* pour permettre à la classe mère d'accéder au constructeur */
    friend class TSingleton<AutreSingleon>
    public:
        void foo();
        void bar();
    private:
        AutreSingleon(){}
        ~AutreSingleon(){}                                        
};

[Baubeau Cédric]

Merci pour ces infos.
Il faudra que j'éclaircisse cette notion de CRTP. C'est effectivement curieux ...

[koala01]

Merci pour ces infos.
Il faudra que j'éclaircisse cette notion de CRTP. C'est effectivement curieux ...

D'où le nom

Allez, pour t'aider à creuser:
il y a une entrée de la FAQ qui en parle et, si tu comprend l'anglais, tu peux faire un tour du coté de more C++ idioms

Le tout se base sur le fait que le code exécutable des classes et des fonctions template et créé lors de la compilation, pour chaque type particulier pour lequel la classe / fonction est utilisée (cela s'apparente à du polymorphisme statique (par opposition au polymorphisme "dynamique" habituellement mis en oeuvre )