Discussion :

[_56ka]

Salut la foule !

J'ai une question qui me taraude depuis quelques jours.

Ayant besoin de templates pour mon projet, j'ai l'envie incessante de mettre le minimum de code dans les templates pour le mettre plutôt dans une classe mère.
Le code que je mets dans le template est celui nécessitant la classe T du template.

Exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
class LoadObj
{
public:
    const int getID() const { return _id; }
    void setID(const int id) { _id = id; }
 
private:
    int _id;
}

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
 
template<class T>
class TCRMLoadedObject
    : public LoadObj
{
    // crée une instance avec un ID automatique
    static T * const load()
    {
        static int CURRENT_ID = 0;
        CURRENT_ID++;
 
        // On crée une instance et on lui met un ID
        TCRMLoadedObject<T> * tmpLoaObj = new T();
        tmpLoaObj->setID(CURRENT_ID);
 
        return tmpLoaObj;
    }
 
}

Code :

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

1
2
3
4
5
6
7
 
int main()
{
    TCRMLoadedObject<Bonzomme> * toto = TCRMLoadedObject<Bonzomme>::load();
 
    toto->getID(); // vaudra qqchose
}

C'est une bonne idée ou il fôdrait que je mette tout directement dans le template ?..

Parce que le problème est que si ensuite je veux faire du polymorphisme, je ne peux pas utiliser le template, comme dans l'exemple ci-dessous :

Code :

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

1
2
3
4
5
6
 
// ça ne va pas marcher, le compilo va me dire qu'il manque l'argument 1 du template...
void afficher(TCRMLoadedObject * obj)
{
    print( obj->getD() );
}

Comment faire ?

Merci

[therwald]

Effectivement si tu veux faire du polymorphisme, il faut faire ce qu'on appelle type erasure, qui consiste à faire dériver ton template d'une classe de base non template qui définit l'interface commune (sinon comme les différentes instanciations du template sont considérées comme des types distincts tu ne peux pas appeler leurs parties communes non-template)
Pour plus de précisions sur le type erasure:
http://alp.developpez.com/tutoriels/type-erasure/

[_56ka]

Merci therwald ! Je vais lire tout ça

Par contre, as-tu un opinion sur le fait de procéder systématiquement comme mon exemple ? Est-ce meilleur de mettre tout dans le template directement ?

[therwald]

La question à se poser est la répartition des responsabilités entre classe de base et classes dérivées.
1) quels comportements sont communs à tous les objets, que tu veux appeler en ignorant le paramètre template => ceux là sont définis (interface) et implémentés dans la classe mère. Aucune raison de les descendre dans le template s'ils ne dépendent pas du paramètre de template
2) quels comportement sont dépendants du paramètres template et n'ont pas besoin d'être appelés indépendamment => ceux-là sont définis (interface) et implémentés dans le template
3) est-ce qu'il y a des comportements qui peuvent être définis sans faire référence au paramètre du template, doivent être appelés sans en tenir compte mais doivent être vraiment polymorphes (l'implémentation dépend du paramètre de template)=> s'il y en a il faut que la signature de fonction soit dans la classe mère (la signature ne fait pas référence au paramètre de template) et que la définition soit dans le template. Pour que ça ait du sens il faut:

• soit que cela appelle avec appel à quelque chose du type paramètre de template
• soit que tu envisage de spécialiser le template avec une implémentation différente pour cette méthode

[_56ka]

Ta réponse est très précise, c'est exactement ce que je voulais savoir !
Donc j'étais dans le juste

1000 mercis therwald