utiliser enable_shared_from_this::shared_from_this() dans le constructeur

Version imprimable

Bonjour,

Mon bout de code ci dessous me pose problème :cry:.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class IInteraction : public enable_shared_from_this<IInteraction> { public: IInteraction( boost::weak_ptr<CPointMechanicsEngine> iEngine ) : _Engine( iEngine ) { boost::shared_ptr<CPointMechanicsEngine> Engine(_Engine); Engine->AddInteraction( shared_from_this() ); } protected: boost::weak_ptr<CPointMechanicsEngine> _Engine; };
Le constructeur implémente le fait que IInteraction doit toujours être liée à un CPointMechanicsEngine et que si un IInteraction est lié à un CPointMechanicsEngine, celui ci a un lien vers lui.

Cependant, lors de l'appel au constructeur de IInteraction, shared_from_this() lève une exception car le pi du shared_ptr est nul. En effet, pn, px, pi ne sont pas initialisés.

Voici l'appel au constructeur, où CFriction est une classe qui dérive de IInteraction
Code:

1 2 3 4 5 boost::shared_ptr<CFriction> Friction ( new Medias::PointMechanicsEngine::Interactions::CFriction( PhysicalPoint , 0.3 , Engine ) );
Si je fais appel à shared_from_this() dans une méthode après le constructeur ait terminé, il n'y a pas de problème.
Cependant, cela casse la RAII X(

Est ce que quelqu'un aurait une solution à mon problème, svp???
Merci!!!

Bonsoir,
shared_from_this() ne peut pas fonctionner dans le constructeur. Une alternative est de mètre le constructeur en private, et de passer par une méthode static qui fait office de constructeur.
Par exemple:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class IInteraction : public enable_shared_from_this<IInteraction>  
{
private:
  IInteraction( boost::weak_ptr<CPointMechanicsEngine> iEngine ) :
    _Engine( iEngine )
  {
  }
 
public:
  static boost::shared_ptr<IInteraction> Create(boost::weak_ptr<CPointMechanicsEngine> iEngine)
  {
     boost::shared_ptr<IInteraction> newPtr(new IInteraction(iEngine));
     boost::shared_ptr<CPointMechanicsEngine> Engine(iEngine);
     Engine->AddInteraction(newPtr);
     return newPtr;
  }
 
protected:
  boost::weak_ptr<CPointMechanicsEngine> _Engine;
};

07/06/2010, 15h26
Xemame

OK, merci, ça marche nickel!!!

Par contre, IInteraction est une classe abstraite qui est dérivée beaucoup de fois. Du coup, je dois réécrire la fonction Create dans chacune des classes filles, ce qui n'est pas très propre au point de vue programmation: avant, le code dans le constructeur d'IInteraction était obligatoirement appelé dans les constructeurs des classes filles et les modification du code dans le constructeur d'IInteraction y étaient répercutées aussi. Maintenant ce n'est plus le cas puisque le code n'est plus dans le constructeur :?

Est ce quelqu'un a une idée pour résoudre ce problème???
Merci!!!

Si j'ai bien compris, le problème est de copier/coller le code de Create dans toute les class filles?
Une solution serais de faire de Create une fonction libre, et template:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 template<typename I> boost::shared_ptr CreateInteraction(boost::weak_ptr<CPointMechanicsEngine> iEngine) { boost::shared_ptr newPtr(new I(iEngine)); boost::shared_ptr<CPointMechanicsEngine> Engine(iEngine); Engine->AddInteraction(newPtr); return newPtr; } class IInteraction : public enable_shared_from_this<IInteraction> { template<typename I> friend boost::shared_ptr CreateInteraction(boost::weak_ptr<CPointMechanicsEngine> iEngine); protected: IInteraction( boost::weak_ptr<CPointMechanicsEngine> iEngine ) : _Engine( iEngine ) { } boost::weak_ptr<CPointMechanicsEngine> _Engine; };
Il va de soit que, mis a par l'appel a Engine->AddInteraction, le code de construction des class reste bien dans leurs constructeurs respectifs.

EDIT:
Après réflexion, vos class d'Interaction n'auront peut-etre pas les même constructeurs.
Une autre solution pourrait être de laisser CPointMechanicsEngine::AddInteraction faire tout le travaille:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 struct CPointMechanicsEngine { boost::shared_ptr<IInteraction> AddInteraction(IInteraction *interPtr) { boost::shared_ptr<IInteraction> sharedInter(interPtr); sharedInter->setParent(shared_from_this()); //Ajout de l'IInteraction dans l'Engine //... return sharedInter; } }; //Utilisation: shared_ptr<IInteraction> interPtr = Engine->AddInteraction(new InteractionSpecifique(x, y, z));

08/06/2010, 10h43
Xemame

Ce qui serait bien, c'est que:
- une fois la fonction pour créer mon interaction terminée, il n'y ait plus rien à faire pour qu'elle soit utilisable (RAII)
- que les classes qui dérive de IInteraction soit obligées de faire comme il faut (s'attacher au moteur, etc). Avant, elles devaient appeller le constructeur de IInteraction, qui faisait ce qu'il fallait, et du coup elles faisaient ce qu'il fallait. Maintenant, elles ne sont plus obligées de faire ce qu'il faut.

Effectivement, les constructeurs de mes interactions sont différents les un des autres.

La dernière méthode proposée est bien mais pas parfaite car l'utilisateur peut faire un new InteractionSpecifique(x, y, z) quelque part dans le code, sans Engine->AddInteraction, et la RAII ne se ferait pas :?

C'est frustrant, il n'y aurait pas de problèmes si j'utilisais des pointeurs basiques :(
08/06/2010, 14h55
JolyLoic

Pas si le constructeur est privé, et la fonction de création amie de la classe.

Bon alors, voici une autre proposition qui permet d'éviter les new, et d'avoir des constructeurs avec des nombre d'arguments divers:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 struct CPointMechanicsEngine { //Cette fonction prend un shared boost::shared_ptr<IInteraction> AddInteraction(boost::shared_ptr<IInteraction> sharedInter) { sharedInter->setParent(shared_from_this()); //Ajout de l'IInteraction dans l'Engine //... return sharedInter; } }; //Utilisation: On utilise make_shared shared_ptr<IInteraction> interPtr = Engine->AddInteraction(make_shared<InteractionSpecifique>(x, y, z));
L'astuce, c'est que les constructeur doivent être privés, et la classe IInteraction doit être friend avec make_shared.
Le seul inconvénient qui reste est que l'utilisateur n'est pas obligé d'ajouter l'Interaction a l'Engine. Mais est-ce vraiment un problème?

Je ne vois pas d'autre solution sans passer par des variadic template, ou faire une fonction par nombre d'arguments.

Une dernière solution, probablement la bonne^^.
En faite la première solution avec la fonction membre "Create" était certainement la meilleur. Le seul inconvénient était de devoir copier/coller quelque ligne de code dans chaque class filles...
Pourquoi ne pas les factoriser??
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 class IInteraction : public enable_shared_from_this<IInteraction> { protected: IInteraction( boost::weak_ptr<CPointMechanicsEngine> iEngine ) : _Engine( iEngine ) { } template<typename I> boost::shared_ptr addToEngine(boost::weak_ptr<CPointMechanicsEngine> iEngine, I *nakedInter) { boost::shared_ptr sharedInter(nakedInter); boost::shared_ptr<CPointMechanicsEngine> Engine(iEngine); Engine->AddInteraction(sharedInter); return sharedInter; } public: static boost::shared_ptr<IInteraction> Create(boost::weak_ptr<CPointMechanicsEngine> iEngine) { return addToEngine(iEngine, new IInteraction(iEngine)); } protected: boost::weak_ptr<CPointMechanicsEngine> _Engine; };
Comme ca la fonction Create ne fait plus qu'une ligne. J'espère que cette solution vous conviendra.

09/06/2010, 18h28
Xemame

Merci pour toute la peine que tu te donnes pour moi, Nogane!!! :ccool:

En fait, le problème n'est pas seulement le copier/coller, mais d'obliger les classes filles à se lier au moteur. Je veux dire par là que si un autre codeur créer une classe dérivant de IInteraction, il lui sera impossible de faire en sorte qu'une instance de sa classe ne soit pas liée au moteur après sa création.

Si j'utilisais les pointeurs basiques et non les shared_ptr, je ferais Engine->AddInteraction( this ); dans le constructeur de IInteraction et ce serait le cas.

@ JolyLoic: je n'ai pas compris si tu voulais dire qu'il y a une solution au problème.
09/06/2010, 18h40
Nogane

Citation:

Je veux dire par là que si un autre codeur créer une classe dérivant de IInteraction, il lui sera impossible de faire en sorte qu'une instance de sa classe ne soit pas liée au moteur après sa création.

C'est ce que permet ma dernière solution, si on met tout les constructeurs en private/protected, et que l'on ajoute une fonction Create public a chaque class fille de IInteraction. Évidement, les méthodes Create prennent un engine en argument.

Citation:

Envoyé par Nogane

C'est ce que permet ma dernière solution, si on met tout les constructeurs en private/protected, et que l'on ajoute une fonction Create public a chaque class fille de IInteraction. Évidement, les méthodes Create prennent un engine en argument.

Un utilisateur qui n'en ferait qu'à sa tête pourrait créer une nouvelle interaction qui ne serait pas attachée au moteur ainsi:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class CFriction : public IInteraction { protected: CFriction ( boost::weak_ptr<CPointMechanicsEngine> iEngine ) : IInteraction( iEngine ) { } ** public: static boost::shared_ptr<IInteraction> Create(boost::weak_ptr<CPointMechanicsEngine> iEngine) { return CFriction (iEngine); } *};
L'assertion "une interaction est toujours attachée au moteur" ne serait alors pas respectée.
:aie: :aie: :aie: :aie: