Bonjour,
effectivement, je me pose la question de connaitre la portée de la surcharge. De par mon expérience, j'ai l'impression que la surcharge de fonctions (des fonctions portant le même nom mais ayant des signatures différentes) ne peut se faire qu'au sein d'une même classe et pas au sein de deux classes ayant une relation mère/fille.
Le cas concret qui me pose problème et où j'aimerai bien que la portée soit "héréditaire" en quelque sorte, est le suivant:
Je défini une fonction template dans une classe mère, utilisée par plusieurs classes filles, avec des types spécifiques. Chacune de ces classes filles utilisent la fonction template, qui fait appel à des fonctions spécialisées, ayant des paramètres différents, mais portant le même nom; d'où la notion de surcharge. Mais, cela ne fonctionne pas.
Concrètement :
Soit une classe "AbstractClient", classe mère qui implémente la fonction template.
Une autre classe, gère une collection de classes filles de AbstractClient sous forme de pointeur AbstractClient*, et appelle les fonctions virtuelles "processFrame" avec des objets de classes filles de Frame, sous la forme de Frame* :
et une des classe fille de AbstractClient :
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 AbstractClient { template < typename FrameSpe > void checkFrame( Frame* pFrame) { FrameSpe* pFrameSpe = dynamic_cast<FrameSpe*>(pFrame); if ( pFrameSpe ) processFrame( pFrameSpe ); } virtual void processFrame( Frame* ) { TRACE("Ce type de Frame n'est pas géré ! "); } };
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 class ConcreteClient { void processFrame( Frame* pFrame ) { checkFrame<FrameToto>(pFrame); checkFrame<FrameTata>(pFrame); checkFrame<FrameTiti>(pFrame); } // fonction qui traite les FrameToto void processFrame( FrameToto* pFrame) { // faire quelque chose avec des FrameToto } // fonction qui traite les FrameTata void processFrame( FrameTata* pFrame) { // faire quelque chose avec des FrameTata } };
Cette structure de classes me permettrait de gérer un grand nombre de classes héritant de Frame (j'en ai 46 dans le monde concret, selon un arbre d'héritage de à 3 niveaux), et un nombre de classes clientes variables (au moins une vingtaine), héritant de "AbstractClient".
Mais ce code ne marche pas, tel quel : les fonctions "spécialisées pour les sous-types de Frame" ne sont jamais appelées.
Par contre, si je mets la fonction template dans ConcreteClient, la ça fonctionne.
D'où mon impression de départ : "la portée de la surcharge de fonction semble n'être possible qu'au sein d'une même classe, et ne peut s'hériter".
Et c'est bien dommage !
Je ne sais pas si j'ai été très clair. L'avis des experts m'intérresse...
La seule solution que je vois est de ne pas utiliser de fonction template, mais de coder le "dynamic_cast" dans chaque processFrame(Frame*) des classes héritant de AbstractClient.
Partager