Discussion :

[r0d]

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 :

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

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)?

[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.

[r0d]

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.

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

[Mat007]

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 :

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
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 :

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

`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.

[r0d]

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

[Médinoc]

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 C++ :

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
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);
		}
	}
};