Shared from this ?

Version imprimable

Shared from this ?

Bonjour à tous,
(Il n'y a pas à dire, dans les sous-forums, on lit moins...)
Je reviens à la charge avec un problème sur les shared_ptr<>.
J'ai deux classes, mettons la classe ClasseGenerale et la classe PetiteClasse, définies comme suit :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 // Dans ClasseGenerale.h class ClasseGenerale { public: ClasseGenerale(); ~ClasseGenerale(); private: boost::shared_ptr<PetiteClasse> Util; } // Dans ClasseGenerale.cpp // ... ClasseGenerale::ClasseGenerale() { // Initialisation de Util. Util.reset(new PetiteClasse(this)); // !!! Comme ça qu'on fait ? }
Et la classe PetiteClasse :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 // Dans PetiteClasse.h class PetiteClasse { public: PetiteClasse(ClasseGenerale* prochainParent); ~PetiteClasse(); private: boost::shared_ptr<ClasseGenerale> parent; } // Dans PetiteClasse.cpp // ... PetiteClasse::PetiteClasse(boost::shared_ptr<ClasseGenerale> prochainParent) { // Initialisation de parent. parent = prochainParent; }
Je voudrais pouvoir faire le double lien classique avec des pointeurs de boost. Le problème c'est que dans la méthode de la classe "plus générale" je ne sais pas comment passer en argument pour que cela fonctionne.
Avec enabled_shared_from_this.hpp je ne comprends pas non plus pourquoi ça ne marcherait pas, si je fais :

Code:

Util.reset(new PetiteClasse(boost::shared_ptr<ClasseGenerale>(this)))

Pouvez-vous me dire ce qui ne va pas ?

Merci d'avance !

on ne peut pas passer de shared_from_this depuis le constructeur de l'objet. En fait, le shared_from_this n'est construit que quand notre objet est assigné au smart_ptr.
Pour resoudre ce problème, tu peut prévoir une construction en 2 temps du genre
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 classe A : public enable_shared_from_this { private: A(params); // constructeur en privé void AfterCreate(params) // méthode qui construit l'objet { // initialisation des objets qui necessitent d'utiliser le shared_from_this }; public: static shared_ptr<A> Create(params) { shared_ptr ret = new A(params); ret->AfterCreate(params); return ret; } }
et qu lieu d'appeler le constructeur de la classe, du appel la factory methode qui va te retourner un smart_pointer vers ton instance.

14/10/2007, 18h39
Le Barde

Merci beaucoup pour ta réponse !
J'essaye ça de suite ;)

beurk

Je me suis donc intéressé à enable_shared_from_this, et je suis allé voir du côté du tutoriel sur les pointeurs de boost.
J'ai créé la classe exemple ci-dessous en incluant simplement en en-tête le header dans le fichier main :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #include <boost/shared_ptr.hpp> #include <boost/enable_shared_from_this.hpp> class exemple : public enable_shared_from_this<exemple> { public: void callDoSomething() { doSomething(shared_from_this()); } }; void doSomething(boost::shared_ptr<exemple>) { // Faire quelque chose avec ce pointeur intelligent }
Et là, catastrophe :

Citation:

g++ -c -pipe -Wall -W -O2 -D_REENTRANT -DQT_NO_DEBUG -DQT_THREAD_SUPPORT -DQT_SHARED -DQT_TABLET_SUPPORT -I/usr/share/qt3/mkspecs/default -I. -I/usr/include/qt3 -I/usr/X11R6/include -I/usr/X11R6/include -o Main.o Main.cpp
exemple.h:16: erreur: expected template-name before «<" token
exemple.h:16: erreur: expected `{' before «<" token
exemple.h:16: erreur: expected unqualified-id before «<" token
Main.cpp: In function «int main(int, char**)":
Main.cpp:6: attention : statement n'a pas d'effet
Main.cpp:7: attention : statement n'a pas d'effet
make: *** [Main.o] Erreur 1
*** Exited with status: 2 ***

Pourtant mon fichier enable_shared_from_this.hpp est bien inclus !! :(

14/10/2007, 21h15
JolyLoic

Code:

class exemple : public boost::enable_shared_from_this<exemple>
14/10/2007, 21h21
Le Barde

Ouh là :aie:

Madre mia, merci beaucoup ! Je n'oublie jamais, il suffit que la confusion vienne et on oublie tout ;)
Merci ;)
15/10/2007, 10h55
Le Barde
Salut à tous,
Je reviens à la charge avec mes shared from this. Maintenant tout fonctionne bien.
Notamment, les boost::enable_shared_from_this<>.

Mais quand-même (s'il n'y avait pas de "mais" ce ne serait pas drôle), j'ai une classe A qui hérite de enable_shared_from_this<>, et une classe a qui hérite de A. Et, bien sûr, je voudrais pouvoir utiliser le shared from this depuis la classe a.
Donc je fais quelque-chose comme :
Code:

1 2 3 4 5 6 7 class A : public boost::enable_shared_from_this<A> { }; class a : public A { }
Dans des méthodes de a, les appels à shared_from_this() donnent en retour un shared_ptr<A>, et non un shared_ptr<a> comme je le voudrais. Y a-t-il une solution à votre avis ?
15/10/2007, 11h15
Matthieu Brucher

C'est normal que ça retourne un <A> et non un <a>. Maintenant, tu peux caster ton pointeur intelligent de force.

En revanche, si tu dois le faire, c'est qu'il y a potentiellement un problème structurel.
15/10/2007, 11h41
Le Barde
- Qu'entends-tu par problème structurel ?
- En regardant sur le net, j'ai vu que certains faisaient quelque-chose du genre :
  Code:
  
  1 2 3 4 5 6 7 8 9 10 class A : public boost::enable_shared_from_this<A> { private: using boost::enable_shared_from_this<AtelierPerfo>::shared_from_this; } class a : public A { }
  Ou quelque-chose dans ce goût-là... Mais chez moi ça ne fonctionne pas.
15/10/2007, 11h48
Matthieu Brucher

Si tu as besoin d'accéder à la classe fille de A dans ton code, tu a vraisemblablement un problème structurel.

Sinon, dans mon tuto, il y a les fonctions qu'il te faut : http://miles.developpez.com/tutoriel...rtptrs/#LIII-B
Définit une fonction qui te fera automatiquement la transformation et ça ira :)

Le using ne permet que de faire apparaître dans la classe fille la méthode shared_from_this, rien d'autre.
15/10/2007, 12h08
Le Barde
Ouh là, mais j'essaye un truc du genre
Code:

1 2 3 4 5 a::Get_shared_from_this() { return boost::dynamic_pointer_cast<a, A>(A::shared_from_this()); }
Mais ça ne fonctionne pas... J'avoue qu'avec ce niveau d'abstraction j'ai un peu de mal...
15/10/2007, 12h12
Matthieu Brucher

C'est quoi l'erreur ?

Dans mon projet :
A <=> Atelier
a <=> AtelierPerfo

La fonction :

Code:

1
2
3
4
boost::shared_ptr<AtelierPerfo> AtelierPerfo::Get_shared_from_this()
{
   return boost::dynamic_pointer_cast<AtelierPerfo, Atelier>(Atelier::shared_from_this());
}

Les erreurs :

Code:

1
2
3
4
5
6
7
8
9
10
compiling AtelierPerfo.cpp (g++)
/usr/include/boost/enable_shared_from_this.hpp: In member function «AtelierPerfoPtr AtelierPerfo::Get_shared_from_this()":
/usr/include/boost/enable_shared_from_this.hpp:47: erreur: «boost::shared_ptr<T> boost::enable_shared_from_this<T>::shared_from_this() [with T = Atelier]" is inaccessible
FlowshopPerfo/AtelierPerfo.cpp:423: erreur: à l'intérieur du contexte
/usr/include/boost/shared_ptr.hpp: In constructor «boost::shared_ptr<T>::shared_ptr(const boost::shared_ptr<Y>&, boost::detail::dynamic_cast_tag) [with Y = Atelier, T = AtelierPerfo]":
/usr/include/boost/shared_ptr.hpp:387: instantiated from «boost::shared_ptr<T> boost::dynamic_pointer_cast(const boost::shared_ptr<U>&) [with T = AtelierPerfo, U = Atelier]"
FlowshopPerfo/AtelierPerfo.cpp:423: instantiated from here
/usr/include/boost/shared_ptr.hpp:177: erreur: cannot dynamic_cast «r->boost::shared_ptr<Atelier>::px" (of type «class Atelier* const") to type «class AtelierPerfo*" (source type is not polymorphic)
make: *** [AtelierPerfo.o] Erreur 1
*** Exited with status: 2 ***

15/10/2007, 12h32
Matthieu Brucher

Comme tu peux le constater, l'erreur ne vient pas du transtypage mais du fait que tu ne peux pas récupérer shared_from_this depuis une classe dérivée, apparemment. Je n'ai pas boost sous la main pour voir si shared_from_this() est une méthode privée, mais il ya des chances (C'est aussi une protection contre les designs nécessitant des casts, comme le tien, car ils sont potentiellement non optimaux).

Pourtant, c'est étrange car shared_rfom_this() est publique :

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
enable_shared_from_this.hpp

#include <boost/weak_ptr.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/assert.hpp>
#include <boost/config.hpp>

namespace boost
{

template<class T> class enable_shared_from_this
{
protected:

    enable_shared_from_this()
    {
    }

    enable_shared_from_this(enable_shared_from_this const &)
    {
    }

    enable_shared_from_this & operator=(enable_shared_from_this const &)
    {
        return *this;
    }

    ~enable_shared_from_this()
    {
    }

public:

    shared_ptr<T> shared_from_this()
    {
        shared_ptr<T> p(_internal_weak_this);
        BOOST_ASSERT(p.get() == this);
        return p;
    }

    shared_ptr<T const> shared_from_this() const
    {
        shared_ptr<T const> p(_internal_weak_this);
        BOOST_ASSERT(p.get() == this);
        return p;
    }

    typedef T _internal_element_type; // for bcc 5.5.1
    mutable weak_ptr<_internal_element_type> _internal_weak_this;
};

} // namespace boost

Bizarre...

15/10/2007, 13h14
Le Barde
... et naturellement, si je ne mets plus le Atelier:: devant shared_from_this(), à la compilation cela donne :
Code:

1 2 3 4 AtelierPerfoPtr AtelierPerfo::Get_shared_from_this() { return boost::dynamic_pointer_cast<AtelierPerfo, Atelier>(shared_from_this()); }
(Je rappelle la déclaration de mes classes :
Code:

1 2 3 class Atelier : public boost::enable_shared_from_this<Atelier> {// ... };
Code:

1 2 3 class AtelierPerfo : public Atelier, boost::enable_shared_from_this<AtelierPerfo> {// ... };
)

Et oui, je sais, je n'aime pas non plus avoir à faire cet héritage multiple :'(

Peut-être qu'à la lumière de cela tu verrais une grosse bourde ?
15/10/2007, 13h18
Matthieu Brucher

Dans ton deuxième héritage, tu ne devrais pas avoir à nouveau enable_shared_from_this. ICi, tu te retrouves avec 2 pointeurs intelligents pour le même objet, c'est très très très très risqué. Et logiquement, tu supprimes le A::, ça marche puisqu'il récupère le pointeur de la classe fille et non celui de la classe mère.

:oops: J'avais laissé un using machin bidule dans private, c'est pour ça que c'était privé.

Par contre, en ayant bien nettoyé et sans plus faire hériter AtelierPerfo (a, donc) de enable_shared_from_this<>, cela me donne le message d'erreur :

Code:

1
2
3
4
5
6
7
compiling AtelierPerfo.cpp (g++)
/usr/include/boost/shared_ptr.hpp: In constructor «boost::shared_ptr<T>::shared_ptr(const boost::shared_ptr<Y>&, boost::detail::dynamic_cast_tag) [with Y = Atelier, T = AtelierPerfo]":
/usr/include/boost/shared_ptr.hpp:387: instantiated from «boost::shared_ptr<T> boost::dynamic_pointer_cast(const boost::shared_ptr<U>&) [with T = AtelierPerfo, U = Atelier]"
FlowshopPerfo/AtelierPerfo.cpp:423: instantiated from here
/usr/include/boost/shared_ptr.hpp:177: erreur: cannot dynamic_cast «r->boost::shared_ptr<Atelier>::px" (of type «class Atelier* const") to type «class AtelierPerfo*" (source type is not polymorphic)
make: *** [AtelierPerfo.o] Erreur 1
*** Exited with status: 2 ***

15/10/2007, 14h19
Matthieu Brucher

Y'a un problème de const dans le tas.

Sinon, je ne comprends toujours pas pourquoi tu as besoin de ça dans ton code.
15/10/2007, 14h28
Le Barde

En fait le projet sur lequel je suis résulte d'un portage depuis C# vers le C++... Comme il n'y a pas beaucoup de delete dans un programme C# (!), j'étais bien embêté... Donc dans tout le projet j'utilise des shared_ptr et non pas des pointeurs classiques.
/mode provoc ON :D
C'est une erreur de conception que de vouloir utiliser des shared_ptr ?
/mode provoc OFF
15/10/2007, 14h31
Matthieu Brucher

Non, c'est une erreur de conception que de vouloir récupérer un pointeur vers la classe fille parce que la classe mère ne suffit pas. Cette dernière est donc mal conçue.

L'histoire du const vient d'un rpoblème qu'on ne peut pas voir d'ici. Tu transformes ton pointeur intelligent qui pointe sur un objet constant en un autre pointeur vers une donnée non constante. Ca ne peut pas marcher.
15/10/2007, 15h01
Le Barde

Ah, ben je viens de regarder... En effet, je n'ai pas besoin d'avoir un shared_ptr ici. En effet, si je crée une classe qui prend en paramètre de son constructeur un shared_ptr, en fait ce n'est pas à l'intérieur de cette classe que l'on va détruire l'objet depuis lequel il est appelé, donc un pointeur "classique" suffit. L'objet this est détruit plus tard.

Je te remercie en tous cas pour t'être démené à trouver la solution, du moins à moi ça m'a permis d'apprendre plein de choses réutilisables également ;)
Je considère donc mon problème comme résolu, il y avait bien une erreur de conception mais je ne comprenais pas en quoi ;)
Merci encore,
Adrien Poupin.
15/10/2007, 15h38
Matthieu Brucher

Citation:

Envoyé par Le Barde

Je te remercie en tous cas pour t'être démené à trouver la solution, du moins à moi ça m'a permis d'apprendre plein de choses réutilisables également ;)
Je considère donc mon problème comme résolu, il y avait bien une erreur de conception mais je ne comprenais pas en quoi ;)

:king:

P.S. : si résolu, faut appuyer sur le bouton résolu :D
15/10/2007, 15h44
Le Barde

Naturellement ;)
(J'oublie très rarement pourtant !)

Très bonne journée à toi.