Discussion :

[yupa]

Bonjour

voila c'est simple

J'ai plusieurs vectors qui contiennent des objets. Un même objet peut etre dans plusieurs vectors.

mes objets ne contiennent rien d'autre que des int ou des String

quand je parcours mes vectors pour supprimer mes objets, il arrive que je fasse plusieurs fois un delete sur un objet qui a deja été delete. Et donc c'est pas bon...

Existe-il un moyens en C++ pour savoir si mon objet a déja été supprimé.

merci a bientot

[Bakura]

Normalement si tu règles le pointeur à NULL, après tu peux refaire un delete dessus sans problème, où bien vérifié s'il est est à NULL pour le supprimer.

Sinon, avec les conteneurs de pointeurs de boost (ici, pour vector : http://www.boost.org/libs/ptr_contai...tr_vector.html), tu as une fonction nommée is_null, qui pourrait peut-être t'aider.

[Emmanuel Deloget]

Il y a un problème dans ton design - notamment la notion d'ownership est mal définie. Un objet appartient à une unique entité. A partir du moment ou un objet appartien à deux entités, il y a un problème.

Le C++ ne permet pas de savoir si un objet a été détruit ou pas, mais il existe des mécanismes qui permettent de s'affranchir de ce "problème" (qui, selon moi n'est pas un problème). Une fois correctement défini qui doit être responsable de quoi, il est possible de de mettre en place une solution qui utilise la librairie smart pointer de boost (ou l'équivalent du TR1 si tu as à ta disposition un compilateur t'offrant la possibilité de l'utiliser tout ou en partie (gcc vient à l'esprit)). Le propriétaire d'un objet peut y accéder via un shared_ptr<>, et les autres objets qui tiennent unr référéence sur cet objet peuvent utiliser udes weak_ptr<>.

Pour plus d'information, cf http://www.boost.org/libs/smart_ptr/smart_ptr.htm

[JolyLoic]

A partir du moment ou un objet appartien à deux entités, il y a un problème.

Je ne vois pas en quoi c'est un problème, les shared_ptr permettent justement d'avoir la notion de propriété partagée.

Le propriétaire d'un objet peut y accéder via un shared_ptr<>, et les autres objets qui tiennent unr référéence sur cet objet peuvent utiliser udes weak_ptr<>.

Les propriétaires d'un objet peuvent y accéder via un shared_ptr<>, et les autres objets qui tiennent unr référéence sur cet objet peuvent utiliser udes weak_ptr<>.

[Emmanuel Deloget]

Je ne vois pas en quoi c'est un problème, les shared_ptr permettent justement d'avoir la notion de propriété partagée.

Les propriétaires d'un objet peuvent y accéder via un shared_ptr<>, et les autres objets qui tiennent unr référéence sur cet objet peuvent utiliser udes weak_ptr<>.

Selon moi (mais ce n'est qu'un opinion), il est nécessaire de savoir qui est propriétaire de quoi à tout moment. Si deux conteneurs sont propriétaires d'un même objet et que l'un d'eux décide que cet objet doit être détruit, permettre à l'autre conteneur de continuer à l'utiliser est une erreur de logique. Par exemple, une particule dans un système de particules: le conteneur qui effectue l'update décide que la particule ets morte, mais le conteneur qui est utilisé dans le rendu continue de la croire vivante - au final, on affiche une particule que l'on est pas censé afficher et dont on ne modifie plus les propriétés.

Les cas de relation many-to-many sont extrèmement rares. La plupart du temps, ils peuvent être remplacés par des relations one-to-many de manière triviale. De plus les relations M2M sont souvent complexes à gérer, et source de bugs difficiles à tracer - notamment dans des contextes de programmation concurrente. Elles necessitent souvent le non respect du principe de dépendance acyclique, ce qui entraine des couplages forts entre les objets et diminue d'autant leur versatilité.

Mais bon, ce n'est qu'une opinion

[loufoque]

Partager de l'état, c'est "mal", mais pour la performance c'est parfois nécessaire.

[yupa]

merci pour vos explications ( que j'ai plus ou moins compris...)

mais je ne vois pas trop comment faire.
En gros j'ai deux pointeurs qui pointent vers le meme objet, et je fais un delete sur mes deux pointers.
Bien sur au deuxieme pointeur ca pante...

comment indiquer qu'un object est deleted?
comment savoir qu'un pointer pointe vers qq chose ?

d'autre conceil ?

[koala01]

Salut,

Tu peux peut etre, aussi, envisager de travailler avec quelque chose qui se rapproche du design pattern mediateur (désolé, le lien est en anglais )

Cela pourrait prendre la forme, simple, suivante:

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/*L'objet que tu utilise réellement */
class TonObjet
{
    /* tout ce qu'il te faut */
};
/* par facilité, autant définir un type de tableau :D */
typedef std::vector<TonObjet*> TabObjet;
/* déclaration anticipée du médiateur */
class Mediateur;
/* la classe au départ de laquelle l'objet est créé/ détruit */
class CreateurObjet
{
    public:
        CreateurObjet(Mediateur* med);
        ~CreateurObjet();
        TonObjet* CreeObjet(/* parametres utiles */);
        void DetruitObjet(TonObjet*);
    private:
        Mediateur * med;
}; 
/* soit le médiateur contient tous les tableaux d'objet, soit, on peut même
    envisager qu'une classe séparée s'en occupe, sous la forme de */
class GestionaireTabObjet
{
    public:
        GestionaireTabObjet( Mediateur* med);
        ~GestionaireTabObjet();
        void AjouteObjet(TonObjet*);
        void ObjetaNUll(TonObjet*);
        const TabObjet& GetTableau() const;
    private: 
        TabObjet tab;
};
/* "Tant qu'à faire", un tableau de gestionnaire, c'est pas mal :D */
typede std::vector<GestionaireTabObjet*> TabGestionnaire
/* et, enfin, la classe qui communique avec tout cela */
class Mediateur
{
    public:
        Mediateur();
        ~Mediateur();
        void AjoutGestionnaire(GestionaireTabObjet*);
        void ObjetCree(TonObjet*);
        void ObjetDetruit(TonObjet*);
    private:
        TabGestionnaire gest;
};

Toute création ou destruction d'objet va alors passer par la méthode CreerObjet ou DetruitObjet de la classe CreateurObjet, qui serait implémentée sous la forme de

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
CreateurObjet::CreateurObjet(Mediateur* med):med(med)
{ 
    assert(med!=NULL);
}
CreateurObjet::~CreateurObjet()
{
    med=NULL;
}
TonObjet* CreateurObjet::CreeObjet(/*les parametres utiles */)
{
    TonObjet* nouveau=new TonObjet(/* les parametre utiles */);
    med->ObjetCree(nouveau);
    return med;
}
void CreateurObjet::DetruitObjet(TonObjet* adet)
{
    med->ObjetDetruit(adet);
    delete adet;
}

et qui s'occupe, en gros, de s'assurer que le médiateur est tenu au courent des constructions/destructions d'objet.

Le médiateur va se charger de transmettre les créations/destructions d'objet à la classe qui gère le tableau d'objet sous une forme proche de

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
 
Mediateur::Mediateur()
{
 
}
Mediateur::~Mediateur()
{  
    /* j'ai considéré ici que la gestion de la mémoire utilisé par
     * les GestionaireTabObjet est prise en compte ailleurs :D 
     */
}
void Mediateur::AjoutGestionnaire(GestionaireTabObjet* toadd)
{
    /*Idéalement, cette fonction ne devrait être appelée qu'à l'initialisation */
    gest.push_back(toadd);
}
void Mediateur::ObjetCree(TonObjet* cree)
{
    for(size_t i=0;i<gest.size();i++)
       gest[i]->AjouteObjet(cree);
}
void Mediateur::ObjetDetruit(TonObjet* detruit)
{
    for(size_t i=0;i<gest.size();i++)
       gest[i]->ObjetaNull(cree);
}

et, enfin, GestionaireTabObjet serait implémenté sous la forme de

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
GestionaireTabObjet::GestionaireTabObjet():tab(){}
GestionaireTabObjet::~GestionaireTabObjet(){}
const TabObjet& GestionaireTabObjet::GetTableau() const
{
    return tab;
}
void GestionaireTabObjet::AjouteObjet(TonObjet* toadd)
{
    tab.push_back(toadd);
}
void GestionaireTabObjet::ObjetaNUll(TonObjet* torem)
{
    for(size_t i=0;i<tab.size();i++)
        if(tab[i]== torem)
            tab[i]=NULL;
}

NOTA:

• on pourrait envisager de fournir en parametre les tableaux d'objets auxquels il faut signaler la création de tes objets (pour ce qui est de la destruction, le temps perdu reste négligeable, à moins d'avoir des tableaux réellement immences )
• Plusieurs optiques sont envisageables au niveau de la persistances des GestionaireTabObjet et du Mediateur... mais là, il manque quelques infos pour en parler
• *idealement* il faudrait prévoir un système qui s'assure que TonObjet ne puisse être créé/détruit qu'au travers de ObjetCreateur (ea: constructeur/destructeur privé et amitié avec ObjetCreateur)

[yupa]

Merci pour vos réponses
merci koala01, j'ai appris plein de trucs.

je me suis débrouillé pour avoir un truc tout simple, un vector.

Est ce la fonction erase() de vector suffit bien a supprimer tout les objects contenus dedans, ou faut-il que je fasse un delete sur chaqu'un de mes elements dans une boucle ?

merci

[koala01]

Non, il faut effectivement que tu fasse en delete sur tes pointeurs...

La fonction erase se "contente" de vider le contenu du tableau, mais, comme tu as décidé au départ d'être responsable de la durée de vie des pointeur que le tableau contient, elle te laisse cette responsabilité

[loufoque]

mais je ne vois pas trop comment faire.
En gros j'ai deux pointeurs qui pointent vers le meme objet, et je fais un delete sur mes deux pointers.
Bien sur au deuxieme pointeur ca pante...

T'utilises boost::shared_ptr

[screetch]

avoir deux proprietaires sur un objet n'est pas choquant. ce que tu decris plus haut, Emmanuel :

Selon moi (mais ce n'est qu'un opinion), il est nécessaire de savoir qui est propriétaire de quoi à tout moment. Si deux conteneurs sont propriétaires d'un même objet et que l'un d'eux décide que cet objet doit être détruit, permettre à l'autre conteneur de continuer à l'utiliser est une erreur de logique.

tu ne partages toujours pas la propriété de l'objet.

Le vecteur ne peut pas decider de detruire l'objet. il peut selement dire qu'il n'en a plus besoin. si il etait le dernier a l'utiliser, alors l'objet est devenu inutile : il sera detruit.