Discussion :

[Trii42]

Bonjour à tous et merci d'avance pour votre aide

J'ai un problème dans mon code, car j'ai besoin de d'avoir deux classe qui se contienne l'une l'autre sous forme de shared_ptr. J'ai essayer d'utiliser un weak_ptr pour casser la dépendance, mais je le fais mal, le programme crash quand je le créer.

Je suis en train de faire un pattern state, d'ou la dépendance.

Voici mon code.

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
#ifndef CCLIENT_H_INCLUDED
#define CCLIENT_H_INCLUDED
 
#include <memory>
#include "etat.h"
 
class client
{
private:
 
    std::shared_ptr<etat> etat1_;
    std::shared_ptr<etat> etat2_;
    std::shared_ptr<etat> etatCourant_;
 
public:
    client();
    void action();
    void setEtatCourant(std::shared_ptr<etat> etat);
    std::shared_ptr<etat> getEtat1();
    std::shared_ptr<etat> getEtat2();
};
 
#endif // CCLIENT_H_INCLUDED

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
#include "client.h"
#include "etat.h"
 
client::client() : etat1_(new etat(this)), etat2_(new etat(this))
{
    etatCourant_ = etat1_;
}
 
void client::action()
{
    etatCourant_->action();
}
 
void client::setEtatCourant(std::shared_ptr<etat> etat)
{
    etatCourant_ = etat;
}
 
std::shared_ptr<etat> client::getEtat1()
{
    return etat1_;
}
 
std::shared_ptr<etat> client::getEtat2()
{
    return etat2_;
}

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
#ifndef CETAT_H_INCLUDED
#define CETAT_H_INCLUDED
 
#include <memory>
 
class client;
 
class etat
{
private:
 
    std::weak_ptr<client> client_;
 
public:
    etat(client* c);
    void action();
};
 
#endif // CETAT_H_INCLUDED

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
#include "client.h"
#include "etat.h"
#include <iostream>
 
etat::etat(client* c) : client_ (std::shared_ptr<client>(c))
{
}
 
void etat::action()
{
    client_.lock()->setEtatCourant(client_.lock()->getEtat2());
    client_.reset();
}

[iNaKoll]

Bonsoir,

La réponse est dans la FAQ :
http://cpp.developpez.com/faq/cpp/?p...-une-a-l-autre

Le fait que l'ont ait des shared_ptr au lieu d'un pointeur nu ne change pas grand chose à l'histoire. Il faut utiliser au minimum une déclaration anticipée!

[Trii42]

Si tu regarde bien mon code, j'ai déjà résolu se problème, donc l'erreur ne viens pas de là.

[JolyLoic]

Après un coup d'oeil rapide:
Quand tu crées un shared_ptr à partir d'un weak_ptr (à l'aide de lock), cette création peut échouer, si l'objet pointé a été détruit entre temps. Dans ce cas, lock retourne un shared_ptr nul. Tu dois toujours tester la valeur retournée par lock avant de l'utiliser.

[Trii42]

Après ton conseil, j'ai changer mon code cette façon

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
#include "client.h"
#include "etat.h"
#include <iostream>
 
etat::etat(client* c)
{
    std::weak_ptr<client> client_(std::shared_ptr<client>(c));
}
 
void etat::action()
{
    std::shared_ptr<client> temp(client_.lock());
    if(temp)
    {
        temp->setEtatCourant(temp->getEtat2());
    }
    client_.reset();
}

Mais j'ai toujours un problème, client_.lock() me renvoie null quand je l’appelle dans action, alors que j'aurais aimer qu'il me renvoie un shared_ptr. J'imagine que c'est donc mon initialisation que est mauvaise, quelqu'un pourrais m'expliquer pourquoi?

[JolyLoic]

Après ton conseil, j'ai changer mon code cette façon

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
etat::etat(client* c)
{
    std::weak_ptr<client> client_(std::shared_ptr<client>(c));
}

Là, tu définis une variable locale ayant le même nom que ta donnée membre...

Mais sinon, il y a un autre soucis : Tu crées un shared_ptr quand tu associe un état à un client. Donc si tu associe 2 états à un même client, il y aura 2 familles de shared_ptr, chacune avec son propre compteur de référence, qui se feront concurrence pour effacer la donnée...

Il vaudrait mieux que le constructeur d'etat prenne en paramètre un shared_ptr déjà existant. Tu peux regarder du côté de shared_from_this, par exemple dans cette doc : http://loic-joly.developpez.com/tuto...mart-pointers/ (tu est dans le cas où tu voudrais un shared_from_this dans le constructeur).