Discussion :

[Kush.]

Bonjour,

Je suis en train de faire un mini-projet en C++ pour apprendre à me servir convenablement de Qt, cependant j'ai un petit problème (mais rien à voir avec Qt, la doc est plutôt bien faite )


Synthétiquement, voila ce que j'ai :

J'ai une classe A et une classe B.
A contient une liste de pointeurs sur des objets de type B.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
class A
{
     std::list<B*> laListe;
 public:
     A();
}
 
class B
{
     B();
     void detruire();
}

Et je voudrais tout simplement pouvoir faire en sorte de lorsqu'un objet B soit supprimé, son pointeur dans la liste de A disparaisse.

J'ai essayé avec un destructeur de B mais je n'y arrive pas, l'objet B est toujours accessible dans la liste :/


Mon problème me semble vraiment très simple, c'est d'autant plus frustrant
J'espère que vous pourrez m'éclairer là dessus, merci d'avance.

[bruno_pages]

Bonjour,

si une instance de B connait la/les instance(s) de A qui le référence il suffit de définir une opération sur A retirant l'instance, cette opération étant appelée par le destructeur de B (attention si une elle instance de A est détruite avant l'instance de B ). Bien évidemment si laListe est un attribut de classe c'est encore plus simple.

Mais puisque vous utilisez Qt il peut être plus simple d'utiliser les signaux/slots

[Kush.]

En effet ça répond bien à ma question, je pourrais donc créer un pointeur dans B qui réfèrerais à l'objet dans lequel il est listé, puis utiliser cette variable pour retirer B de la liste.

Mais oui, au final je vais utiliser des un signal et un slot, ça sera sûrement plus propre ... Je dois aimer me compliquer la vie

Merci pour votre réponse (rapide en plus )

[koala01]

Salut,

Pour commencer, je voudrais te mettre en garde sur une éventuelle fonction détruire qui ne serait pas statique...

Typiquement, la destruction est dévolue... au destructeur de la classe

Ceci dit, il y a deux solutions, chacune ayant ses avantages et ses inconvénients:

1- La première est d'utiliser un pointeur sur le contenant (ta classe A) dans ton contenu (ta classe B) et de prévoir une fonction remove( B*) dans la classe A.

Il te "suffit" alors:

• de transmettre le pointeur sur l'instance de type A qui contient ton objet de type B dans son constructeur (ou de prévoir, si le "propriétaire" de ton objet peut être redéfini, un mutateur sur le pointeur)
• d'invoquer la fonction remove au départ du pointeur membre directement dans le destructeur de B.

Cela donne un code proche de
la classe B

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
class A; // déclaration anticipée
class B
{
    public:
        B(A* h /* autres paramètres éventuels*/):holder_(h){}
        /* Attention, le destructeur doit normalement être défini après inclusion
         * de A.h... je ne le présente ici que "par flegme" :D
         */
        ~B()
        {
            if(holder_)
                holder_->erase(this);
        }
        /* éventuellement */
        void defineHolder(A* ptr)
        {
            /* évitons d'avoir plusieurs propriétaires pour un seul pointeur */
            if(holder)
                holder_->erase(this);
            holder_=ptr;
        }
    private:
        A* holder_;
};

la classe A

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
class B; 
class A
{
    public:
        /* ici aussi, toutes les fonctions qui invoquent un comportement
         * de B devraient être définies après inclusion de B.h...
         * Meme cause, memes effets :D
         */
       ~A()
       {
           for(std::list<B*>::iterator it=items_.begin(); it!=items_.end();
               ++it)
               delete (*it); // nous aurions pu utiliser une classe helper 
                             // et foreach ;)
       }
       void remove(B* ptr)
       {
           std::list<B*>::iterator it=items_.begin();
           /* nous aurions pu utiliser remove_if ;) */
           while(it!=items_.end())
               if( (*it)==ptr)
                   items_.remove(it);
       }
    private:
        std::list<B*> items_;
};

NOTA: il est également possible d'envisager que A soit un singleton avec cette solution

2- La deuxième solution consiste à faire que la décision de la destruction d'un des élément contenus (un objet de ta classe B) revienne... au contenant (la classe A).

Pour éviter tout risque de voir quelqu'un de bien intentionné faire une bêtise en essayant de libérer la mémoire allouée au pointeur sur B de manière indue, il est possible de déclarer le destructeur de B comme private (ou protected, si B est destiné à entrer dans une hiérarchie d'héritage) et de déclarer A comme classe amie de B.

Cela prendrait la forme de
La classe A

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
class B
class A
{
    /* allez, amusons nous :D */
    struct deleter
    {
        void operator()(B* ptr)
        {
            delete ptr;
        }
    }
    public:
        ~A()
        {
            for_each(items_.begin(),items_.end(),deleter());
        }
        /* supprime le B indiqué et... le détruit correctement */
        void erase(B* ptr)
        {
            deleter(ptr);
            remove_if(items_.begin(),items_.end(),bind2nd(equal_to<B*>(), ptr));
        }
    private:
        std::list<B*> items_;
};

La classe B

Code :

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

1
2
3
4
5
6
7
8
9
class A;
class A::deleter;
class B
{
    /* tout se joue ici :D*/
    friend class A::deleter;
    private:
        ~B(){} //et ici
};

[Kush.]

la deuxième me solution me semble moins bonne que la première, je préfèrerais que l'objet B se "détruise" lui même, qu'il soit plus autonome.

Par contre la première est parfaite, j'avais à chaque fois un erreur de compilation ... a.h incluait b.h et réciproquement, b.h incluait a.h, et ça causait un problème. Alors qu'avec la déclaration anticipée de A dans b.h je n'ai plus cette erreur (je fais donc l'include de a.h dans b.cpp).

Bref j'ai compris comment ça marche, et mon problème est résolu.
Merci beaucoup

[koala01]

la deuxième me solution me semble moins bonne que la première, je préfèrerais que l'objet B se "détruise" lui même, qu'il soit plus autonome.

Et pourtant... La seconde solution est souvent bien meilleure que la première: il est de bon ton de faire en sorte que la destruction d'un objet dépende... de son propriétaire

[Kush.]

Ah

J'ai encore beaucoup à apprendre ...

Mais ça me semble bizarre puisque dans mon projet, la classe B est une classe Batiment, et la classe A est une classe Joueur.
Donc quand le bâtiment n'a plus de vie il me semblait plus logique qu'il se détruise lui même :/
Mais peut-être que j'adapte trop la conception de mon programme à la réalité ?