[heritage] caster classe fille

Version imprimable

10/04/2008, 11h07
r0d

[heritage] caster classe fille
Bonjour,

voici mon contexte:
- Une classe Mere et une classe Fille. Les 2 sont instanciables.
- La classe Mere est définie dans une lib A.
- La classe Fille est définie dans une lib B.
- Une fonction fA, définie dans la lib A, qui prend un vector ( par référence constante) de Mere en parametre
- Un vector de Fille qui appartient à la lib B.
Un peu de code pour illustrer:
Code:

1 2 3 4 5 6 7 8 9 // dans la lib A void fA( const std::vector<Mere> & vector); // dans la lib B std::vector<Fille> v; // je voudrais faire, dans ma lib B: A::fA( v );
Mais bien évidemment ça ne fonctionne pas. Or, afin de conserver l'indépendance de ces lib, il ne faut pas que la lib A connaisse la classe Fille ni que la lib B connaisse la classe Mere.

Quelle est(sont) la(les) solution(s)?
10/04/2008, 12h31
Mat007

Salut,

Ce ne sont pas plutôt des Mere* et des Fille* ?
Si ce n'est pas le cas, c'est particulièrement dangereux et très mal joué de ne pas avoir empêché la copie sur la classe Mere...

MAT.
10/04/2008, 12h38
r0d

Citation:

Envoyé par Mat007

Ce ne sont pas plutôt des Mere* et des Fille* ?

Bah non, ce sont bien des instance (pas des pointeurs). Vu le design de l'appli, ce serait 100 fois mieux si je pouvais conserver des conteneurs d'instances, et non de pointeurs.

Citation:

Envoyé par Mat007

Si ce n'est pas le cas, c'est particulièrement dangereux et très mal joué de ne pas avoir empêché la copie sur la classe Mere...

MAT.

Ben en fait, dans le design que j'essaie de mettre en place, ce ne sera pas dangereux. Où alors j'oublie quelque chose.

Ce que je voudrais faire, c'est une lib qui fournit une classe Mere dont le but est d'être dérivée pour être spécialisée, et un ensemble de fonctionnalités pour manipuler des instances de cette classe mère, indépendamment de leurs spécialisations. Donc cette lib n'utilisera pas les membres des classes qui héritent de ma classe Mere. Je ne sais pas si je suis clair :oops:

Citation:

Envoyé par r0d

Ben en fait, dans le design que j'essaie de mettre en place, ce ne sera pas dangereux. Où alors j'oublie quelque chose.

Je ne vois pas comment ça pourrait être utilisable à cause du 'slicing' :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 #include <iostream> namespace { class Mere { public: virtual void f() { std::cout << __FUNCTION__ << std::endl; } }; class Fille : public Mere { public: virtual void f() { std::cout << __FUNCTION__ << std::endl; } }; void g( Mere m ) { m.f(); } } int main() { Fille fille; g( fille ); return 0; }
La sortie :

Code:

`anonymous-namespace'::Mere::f

(vc80)

C'est vraiment ce que tu veux ?
Peut-être que j'ai mal interprété "être dérivée pour être spécialisée" ?

MAT.

10/04/2008, 13h55
r0d

Citation:

Envoyé par Mat007

Peut-être que j'ai mal interprété "être dérivée pour être spécialisée" ?

Non en fait c'est moi qui me suis mal exprimé. Dans mon mécanisme, aucune fonction de la classe Mere ne sera surchargée. D'ailleurs, je suis à la recherche d'un mécanisme qui empêche l'utilisateur de ma lib de surcharger les fonctions de cette classe.

En fait, j'ai fais le tour des DP et des sites où l'on peut trouver des designs intéressants, mais je ne trouve rien qui parle de cette architecture que je souhaite mettre en place. Pourtant ça me parait assez classique. On pourrait utiliser ça, par exemple, pour un système de plug-in.

Mais je crois que tu as raison: je ne suis pas sur la bonne piste :(

Un conteneur "par valeur" sur une classe ne peut pas contenir d'objets d'une classe dérivée.

Il te faut un vecteur de pointeurs, forcément. Ta fonction fA() devra prendre un vecteur de Mere* en paramètre.

Ensuite, tu peux faire un truc de ce genre, sans doute:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 class MereVector { private: std::vector< Mere * > m_vect; public: template< class T > MereVector(std::vector< T > & v) { //Verif compatibilite { T * pd = NULL; Mere *pm = NULL; pm = pd; pd = static_cast< T* >(pm); } //Remplissage du vecteur de pointeurs for(std::vector< T >::iterator it=v.begin() ; it != v.end() ; ++it) { Mere * p = &*it; m_vect.push_back(p); } } };