Discussion :

[nspxroronoa]

Bonjour à tous,

Je bloque sur un problème de conception pour appeler une méthode virtuelle depuis un constructeur. Voici mon cas de figure :

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
 
class mere:
{
public:
	mere()
	{
		display();
	}
 
	virtual void display()
	{
		cout<<"mere::display()"<<endl;
	}
}
 
class fille: public mere
{
public:
	fille():mere()
	{
	}
 
	void display()
	{
		cout<<"fille::display()"<<endl;
	}
}

J'ai plusieurs filles et dans certaines la méthode display() est redéfinit.
Cependant c'est toujours la méthode mere::display() qui est appelée.

Une solution (lourde) serait d'appeler this->display() dans chaque constructeur fille mais n'y a-t-il pas quelquechose de plus propre ?

merci par avance.

[Steph_ng8]

Le fonction membre appelée sera toujours celle de la classe mère.
Lis ce tutoriel sur les fonctions virtuelles en C++.

[r0d]

Effectivement. Dit autrement, la vtable n'est pas opérationnelle dans le constructeur, on ne peut donc pas utilser l'héritage de fonctions dans celui-ci.

Une solution possible consiste à créer la classe en 2 temps, avec une fonction Create (ou Build, ou Init, ...):

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
struct Mere
{
	void Create() { Bar(); }
	virtual void Bar() = 0;
};
 
struct Fille : public Mere
{
	void Bar() { cout << "fille" << endl; }
};
 
int main(int argc, char* argv[])
{
	Fille fille;
	fille.Create();
 
	return 0;
}

D'autres solutions sont possibles, en utilisant une factory par exemple, mais ça dépend de ce que tu veux faire exactement.

[nspxroronoa]

@Steph_ng8 merci pour le lien, ça correspond exactement à mon probleme.. malheureusement !
@r0d en fait c'est quasiement ce que je fais à l'heure actuelle. J'ai enlevé display() du constructeur de ma classe mere et pour chaque fille je fais :

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 fille: public mere
{
public:
	fille():mere()
	{
	}
 
	void display()
	{
		mere::display();
		//blabla...
	}
}

Je trouvais cette méthode un peu lourde mais visiblement je n'ai pas trop le choix.
Mon cas se rapproche pas mal de factory. Tu dis qu'il y a des solutions plus spécifique à ce pattern ?

Merci par avance.

[r0d]

Le problème c'est qeu ça dépend vraiment de ce que tu veux faire.
Par exemple, si la fonction que tu veux appeler dans le constructeur ne modifie pas ta classe, alors tu peux utiliser this et ça change tout.
Si c'est vraiment un problème de construction de la classe, ça dépend de comment sont faites des classes.
Si c'est un problème de comportement, il faut passer par un Template Method.
Si ce sont des classes avec sémantique de valeur, alors peut-être que la solution sera de passer par des templates.
etc...

[nspxroronoa]

Bon ok, je vais détailler un peu alors.

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
28
29
30
31
32
33
34
35
 
class mere:
{
public:
	mere()
	{
		_table = new TABLE();
	}
 
	virtual void display()
	{
		_table->Remplir();
		_table->Afficher();
	}
protected:
	TABLE* _table;
}
 
class fille: public mere
{
public:
	fille():mere()
	{
		this->display();
	}
 
	void display()
	{
		//on affiche _table entièrement
		mere::display();
 
		//comportement particulier spécifique à fille::display()
		_table->CacheColonne(1);
	}
}

En fait ces classes servent à remplir et afficher une table provenant d'une base de donnée, ceci est fait via display(). Mes classes filles peuvent avoir un comportement plus spécifique.
Mais dans ces cas là je suis obligé d'appeler à chaque fois display() dans le constructeur de fille.

J'aurais pensé pouvoir le mettre dans la classe mere et avoir le bon comportement a chaque fois.

[ShaiLeTroll]

Une solution pour ton problème nspxroronoa, est effectivement une Factory qui se charge d'appeler les méthodes virtuelles après l'instanciation ou alors utilisé un pseudo constructeur : Qu'est-ce que l'idiome du constructeur nommé (Named Constructor) ?
Dans les deux cas, tu finis l'initialisation de ton objet en dehors du constructeur !

Le fonction membre appelée sera toujours celle de la classe mère.
Lis ce tutoriel sur les fonctions virtuelles en C++.

Sauf en C++Builder, si l'on hérite des TObject du Delphi, la VMT est chargée dès le début !

Ainsi les méthodes virtuelles sont déjà disponible dès l'ancêtre !
Ce qui est assez gênant car les membres objets en allocation statique sont par contre allouer normalement (au moment de chaque constructeur) mais accessible via RTTI depuis l'ancêtre !
Du coup, on peut modifier dans un constructeur ancêtre mais on perd les données au moment du constructeur hérité ... pour un système d'objet persistant, c'est ballot !

Si vous êtes curieux : Méthodes Virtuelles appelés depuis un Constructeur


L'appel de méthode virtuelle dans un constructeur est même un mécanisme de base en Delphi (dont dépend tout le FrameWork de C++Builder), surtout qu'il existe aussi les constructeurs virtuelles ou même les méthodes de classes virtuelles, éléments manquants en C++Builder 2007 (et semble-t-il en C++ en général dont la philosophie est très différente de mes habitudes Delphi) : Pattern Strategy et Constructeurs Virtuels VCL