question a propos d'héritage

Version imprimable

22/01/2008, 16h49
AntoineNSG

question a propos d'héritage

je dispose d'une classe message
dont héritent les classes messages1, message2, message3

j'ai un objet message * m

que j'instancie suivant la valeur d'un entier
si i = 1 : m = new Message1
si i = 2 : m = new Message2
...

Je cherche un moyen d'automatiser cette instanciation.

par exemple en déclarant les différentes classes message1 message2 dans un tableau
et que mon programme crée un objet message1 quand i = 1 sans que cela soit explicitement ecrit dans le code.
Le but étant lors de l'ajout d'un message_i de n'avoir qu'a compléter ce tableau et
pas avoir a rajouter tous les endroits ou l'objet peut etre instancié dans le code.

est ce faisable ? si oui, comment ?
merci pour vos pistes.
22/01/2008, 17h07
NiamorH

Si i est connu seulement à l'execution, il va faloir forcément passer par un truc un peu sale comme tu as.

Si il est connu a la compilation, tu peux passer par un template : Message
22/01/2008, 17h37
r0d

Bonjour,

je ne connais pas la raison pour laquelle tu as cet héritage, je ne peux donc pas être trés précis dans ma réponse. Mais une solution est possible, c'est, comme le propose NiarmorH, de transformer ta classe message en classe template.

Si cette solution n'est pas possible, il y d'autres solutions qui consistent à utilisent l'héritage autrement. Je pense notamment au DP template method.

A voir selon ce que tu souhaites faire exactement avec cette classe message.
22/01/2008, 17h55
NiamorH

Je doute très très fort que le template soit la solution à retenir ici.

Je pense que ce dont tu as besoin est une fabrique ou un monteur.
22/01/2008, 18h19
r0d

Bah, si toutes les classes filles ont la même interface (j'entend par là l'ensemble des méthodes publiques), pourquoi pas?

La fabrique est ici toutes bien venu.
En effet, elle permet de crée des d'objets dérivant d'une même classe de facon transparent en se basant sur des clé de nimporte quel type pour instancier tes objets.
Voici un exemple de fabrique basé sur les templates et une création d'objet via prototypage:

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
#include <iostream>
#include <map>
#include <iterator>
#include <string>
 
using namespace std;
 
//la classe prototype
template <class T> class Prototype
{
	public:
	virtual ~Prototype(){}	
	virtual T* Clone() const =0 ;
};
 
//l'interface "Figure" 
class Figure : public  Prototype<Figure>
{
	public: 
	virtual void SeDessiner()=0;
};
 
class Carre : public Figure 
{
public:
	Figure* Clone() const ;
	void SeDessiner();
};
 
class Cercle : public Figure 
{
public:
	Figure* Clone() const ;
	void SeDessiner();
};
 
//La fabrique a proprement parler
template <class Object,class Key=string> class Factory
{
std::map<Key,Object*> m_map;
public:
 
	//La fonction qui va créer les objets
	Object* Create(const Key& key) const ;
 
	//Celle qui associe clé <=> prototype
	void Register(Key key,Object* obj);
};
 
 
 
Figure* Carre::Clone() const 
{
 return new Carre(*this);
}
 
void Carre::SeDessiner()
{
cout<<"Je suis un Carre"<<endl;
}
 
 
Figure* Cercle::Clone() const 
{ 
	return new Cercle(*this);
}
 
void Cercle::SeDessiner()
{
	cout<<"Je suis un Cercle"<<endl;
}
 
 
 
template <class Object,class Key> void Factory<Object,Key>::Register(Key key,Object* obj)
{
//si la clé n'est pas déja présente
		if(m_map.find(key)==m_map.end())
      	{
			//on ajoute l'objet dans la map
			m_map[key]=obj;
		}
//on pourrai détruire obj mais cette tache ne revient pas à la Register
}
 
template <class Object,class Key> Object* Factory<Object,Key>::Create (const Key& key) const 
{
		Object* tmp=0;
 
		typename std::map<Key, Object*>::const_iterator it=m_map.find(key);
 
		//si l'itérateur ne vaut pas map.end(),cela signifique que la clé à été trouvé     
		if(it!=m_map.end())
		{
			//donc on clone l'objet
	      	tmp=((*it).second)->Clone();
      	}
//on pourrai lancer une exeption au besoin
		return tmp;
}
 
 
 
int main(void)
{
 Factory<Figure> fac;
 
 fac.Register("Carre",new Carre);
 fac.Register("Cercle",new Cercle);
 
  Figure *c=fac.Create("Cercle");
  Figure *ca=fac.Create("Carre");
 
  c->SeDessiner();
  ca->SeDessiner();
 
  delete c;
  delete ca;
 
  return 0;
}

22/01/2008, 19h56
Alp

En effet, le Design Pattern Factory est ici ce qu'il faut.
J'allais le suggérer avant de lire ton message David ;)

Citation:

Envoyé par r0d

Bah, si toutes les classes filles ont la même interface (j'entend par là l'ensemble des méthodes publiques), pourquoi pas?

Ca n'apportera rien si i n'est connu qu'à l'éxécution.
Code:

1 2 3 4 5 IMessage * GetMessage( int i ) { return new Message(); };
Ne compilera pas.
Code:

1 2 3 4 5 6 template <int i> Message GetMessage() { return Message(); };
Celui-ci marcherait.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 enum MessageList { ALERT = 0, ERROR = 1, INFO = 3 }; int main() { MessageVector vec; vec.push_back( new Message<MessageList::ALERT>() ); vec.push_back( new Message<MessageList::ERROR>() ); vec.push_back( new Message<MessageList::INFO>() ); for_each( vec.begin(), vec.end(), display() ); }
Marcherait aussi, mais ce qu'il cherche à faire est factoriser la création avec un i à l'éxécution et ça c'est pas faisable.

22/01/2008, 20h19
Alp

Oui, en effet NiamorH. Et dans ce cas, la méthode la plus "simple" est la factory...
22/01/2008, 20h21
NiamorH

Voilà, je pense aussi.
23/01/2008, 00h12
r0d

Oui pardon, je me suis mal exprimé. En fait, ce que je voulais dire, c'est qu'il n'a peut-être pas besoin de faire ce if (ou switch).

<mode extrêmiste>
D'ailleurs, dans un bon design, il n'y a pas de if...
</mode extrêmiste>
:)

Effectivement, c'est le pattern Fabrique qu'il faut utiliser. Le code de Davidbrcz est très bien. Je l'ai modifié en enlevant les template (à laisser si tu veux de la généricité) et en introduisant un ptr_map de boost.

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
#include <iostream>
#include <utility>
#include <boost/ptr_container/ptr_map.hpp>
 
struct Message
{
	Message() {}
	virtual ~Message() {}
 
	virtual Message* Clone() const = 0 ;
};
 
struct Message1 : public Message
{
	virtual Message* Clone() const { return new Message1; }
};
 
struct Message2 : public Message
{
	virtual Message* Clone() const { return new Message2; }
};
 
class FabriqueMessage
{
public:
	FabriqueMessage() {}
	virtual ~FabriqueMessage() {}
 
	virtual Message * creerMessage(int ) const;
	void Register(int key,Message* obj);
 
private:
	boost::ptr_map<int, Message> m_map;
};
 
void FabriqueMessage::Register(int key, Message * obj)
{
	//si la clé n'est pas déja présente
	if(m_map.find(key) == m_map.end())
  	{
		//on ajoute l'objet dans la map
		m_map.insert(key, obj);
	}
//on pourrait détruire obj mais cette tache ne revient pas à la Register
}
 
Message* FabriqueMessage::creerMessage(int key) const
{
	Message* tmp = 0;
 
	boost::ptr_map<int, Message>::const_iterator it = m_map.find(key);
 
	//si l'itérateur ne vaut pas map.end(),cela signifique que la clé à été trouvé     
	if(it != m_map.end() )
	{
		//donc on clone l'objet
      	tmp = (it->second)->Clone();
  	}
//on pourrai lancer une exeption au besoin
	return tmp;
}
 
 
int main()
{
	FabriqueMessage fabrique;
 
	fabrique.Register(1, new Message1);
	fabrique.Register(2, new Message2);
 
	Message * message = fabrique.creerMessage(1);
 
	delete message;
	return 0;
}

Bonne continuation,

Poukill

23/01/2008, 13h54
Davidbrcz

Ici l'avantage des templates est de pouvoir créer plusieurs fabrique de chose très différente et de manière transparente
23/01/2008, 14h15
poukill

Je suis complètement d'accord avec toi, j'ai juste simplifié pour que le collègue comprenne bien! 8-)
Personnellement, je l'utiliserai avec les template, of course ! ;)