Classe abstraite et methode static de factory

Bonjour,

J'aimerai créer une classe abstraite A et deux classe dérivante AA et AB
Je veux que la classe A contienne une méthode static pour la création des objets de type AA et AB et une méthode virtuel implémenté dans AA et AB

J'ai donc le code suivant

Code:

---

1 2 3 4 5 6 7 8 9

class A { public: static A Create(BOOL bIsB = false); ~A(void); protected: A(void); virtual void Run()=0; };

---

Pour AA et AB

Code:

---

1 2 3 4 5 6 7 8 9

class AA : public A { public: AA(void); ~AA(void); virtual void Run(); };

---

Pour la méthode Create j'ai:

Code:

---

1 2 3 4 5 6 7

A A::Create(BOOL bIsB) { if(bIsB) return AB(); else return AA(); }

---

Et à la compilation j'ai une erreur : error C2259: 'A'*: impossible d'instancier une classe abstraite


J'ai loupé quelque chose???

Merci pour vos lumières ;)

Salut,

Citation:

---

J'ai loupé quelque chose???

---

Oui en effet! La classe A est une classe abstraite (c'est même toi qui le dit ) alors

Code:

---

1 2 3

static A Create(BOOL bIsB = false); ... A A::Create(BOOL bIsB)

---

n'est pas correct, car 'Create' renvoie un objet de la classe A : Comme A est une classe abstraite, on ne peut pas créer d'objets de cette classe. C'est d’ailleurs ce que dit ton message d'erreur.

Oui mais je crée pas réellement un objet de type A, je crée un objet de type AB ou AA et je renvoie un objet de type A.

En c#, cela est possible. Masi en C++ je dois apparemment renvoyé un pointeur de A :

Code:

---

1 2 3 4 5 6 7 8

A* A::Create(BOOL bIsB) { if(bIsB) return new AB(); else return new AA(); }

---

Code:

---

je crée un objet de type AB ou AA et je renvoie un objet de type A.

---

Non, non et non on ne peut pas!!!

Les AA et les AB tu en instancie tant que tu veux, mais pour les A ce n'est pas possible, ou sinon, il faut que A ne soit pas abstraite

De plus, si A n'était pas abstraite, tu pourrais être confronté au problème de 'slicing' développé ici

Citation:

---

Envoyé par bertry

Les AA et les AB tu en instancie tant que tu veux, mais pour les A ce n'est pas possible

---

Argf:aie:, justement je n'instancie pas de A: tu as vu ça où???:aie:

Salut,

Citation:

---

Envoyé par Troopers

Argf:aie:, justement je n'instancie pas de A: tu as vu ça où???:aie:

---

Mais si, justement...

Comme tu ne renvoie ni un pointeur ni une référence, ce que tu renvoie est... une instance de type A (et non de type AA ou de type AB), ce qui est strictement interdit...

Pour que cela fonctionne, et pour profiter du polymorphisme au passage, tu dois renvoyer une référence ou un pointeur sur un objet "passant pour être" de type A.

Tu dois, en outre, faire attention au fait que l'objet référencé ne soit pas détruit au moment de sortir de la fonction, si tu décide de renvoyer une référence.

La signature de ta fonction doit donc être de l'ordre de

Code:

---

1 2 3 4 5

class A { public: static A& Create(BOOL bIsB = false); };

---

ou de

Code:

---

1 2 3 4 5

class A { public: static A Create(BOOL bIsB = false); };

---

et son implémentation proche de

Code:

---

1 2 3 4 5 6 7

A* A::Create(BOOL bIsB) { if(bIsB) return new AB(); else return new AA(); }

---

ou, si cela a un sens, t'orienter vers quelque chose de proche de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

class A { public: static A& Create(BOOL bIsB = false) { if(! m_member) { if(bIsB) m_member = new AB(); else m_member = new AA(); } return *m_member; } private: A* m_member; };

---

Ok! merci pour l'explication

Salut,
Par défaut, en C++, les objets sont manipulés par valeur et non par référence/pointeur. En C#, c'est le contraire, par défaut, les variables manipulent les objets par références. D'où cette confusion.

Autre question:
si je veux que la fonction Create renvoie une référence :

Code:

---

1 2 3 4 5 6 7 8 9 10

A& A::Create(BOOL isB) { A* pA = NULL; if(isB) pA = new AB(); else pA= new AA(); return *pA; }

---

Comment savoir si la référence est initialisée et comment l'initialiser par défaut :

Code:

---

1 2 3 4 5 6 7 8 9 10

A& a; // Nécessite une initialisation par défaut? if(!a)// si a n'est pas initialisé? { a = A::Create(true); } else { a.Run(); }

---

Et faut -il détruire l'objet ou bien il est automatiquement détruit à la fin de la portée?

Il serait plus simple d'utiliser la fonction de Koala01 renvoyant un pointeur :

Code:

---

1 2 3 4 5 6 7

A* A::Create(BOOL bIsB) { if(bIsB) return new AB(); else return new AA(); }

---

C'est plus simple à manipuler.

Citation:

---

Envoyé par Troopers

Et faut -il détruire l'objet ou bien il est automatiquement détruit à la fin de la portée?

---

Si tu le crée un objet avec new, tu dois le détruire toi-même avec delete

Il s'agit d'être particulièrement prudent lorsque tu envisages de renvoyer des objets polymorphes à créer sous la forme de références...

Il faut, en effet, veiller à ne pas perdre l'adresse à laquelle ces objets polymorphes sont placés, et nous serions donc, peu ou prou, dans une situation de "gestionnaire", car on peut envisager de distinguer les responsabilités:

• La responsabilité de décision quant au type réel de l'objet à créer d'un coté et
• La responsabilité de maintenir quelque part l'ensemble des objets créés afin de pouvoir y accéder par la suite (et de les détruires lorsqu'ils ne sont plus nécessaires) d'autre part

Cependant, différentes situations peuvent apparaitre, selon que tu es en mesure de déterminer clairement qui décidera de détruire les objets une fois qu'ils ne sont plus nécessaire, ou non.

Tu pourrais, ainsi, avoir effectivement une classe "manager" proche de:

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

class Base; /* je considère que la classe Base dispose d'une méthode id() renvoyant un  * un "size_t" permettant d'identifier chaque objet de manière unique et non  * ambigue ;-)  */ class Manager { /* pour la facilité, à usage interne uniquement */ typedef std::map<int, Base*> BaseMap; typedef typename BaseMap::iterator iterator; typedef typename BaseMap::const_iterator const_iterator; public: void registerItem(Base * toadd) { items_.insert(std::make_pair(toadd->id(),toadd)); } Base & find(size_t id) { iterator it = items_.find(id); assert(it!=items_.end()); return *(it.second); } void unregisterAndDestroy(Base* b) { unregisterAndDestroy(b->id()); } void unregisterAndDestroy(size_t id) { iterator it = items_.find(id); assert(it != items_.end()); delete it.second; items_.erase(it); } void clearAllItems() { for(iterator it = items_.begin(); it!=items_.end();++it) delete it.second; items_.clear(); } size_t itemsCount() const{return items_.size();} private: static BaseMap items_; }; // ne pas oublier l'initialisation de items_ dans un *.cpp Manager::BaseMap Manager::items = Manager::BaseMap();

---

et ta "fabrique" pourrait ressembler à

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

class Fabrique { Base & create(bool isB) { Manager man; size_t id = man.itemsCount(); A * createdObject = 0; if(isB) { createdObject = new AB(id); } else { createdObject = new AA(id); } if(createdObject) { man.registerItem(createdObject ); return man.find(id); } throw std::bad_alloc(); } };

---

Tu remarquera que je n'ai pas utiliser le type Base comme fabrique, simplement parce qu'il me semble important de clairement séparer les différentes responsabilités : Le type de base a déjà une résponsabilité bien à lui : permettre d'identifier les différentes instances de manière unique et non ambigüe et, accessoirement, fournir l'interface commune aux différents types. Il ne semble donc pas opportun d'y rajouter une responsabilité qui serait de créer de nouvelles instances, et encore moins que ces nouvelles instances soient de type dérivés :P

Une fois les objets créés, tu pourras, bien sur, utiliser la référence sur le nouvel objet renvoyée par la fonction Fabrique::create(), mais tu pourra également, en cas de besoin, récupérer n'importe quel objet créé par ailleurs avec un simple

Code:

---

1 2	Manager man; Base & laRef = man.find(une_id_donnee);

---

(pour autant que tu disposes de l'id de l'élément qui t'intéresse, bien sur)

L'avantage étant que, comme tu travaille avec des références, tu évite la tentation à l'utilisateur d'invoquer un delete sur les pointeurs, étant donné qu'il n'a absolument pas à le faire, vu que la durée de vie des éléments est gérée au travers... de la classe Manager (et de ses fonctions membres) ;)

Ok,
Merci pour l'exemple complet et les explications