new et delete, mais où?

Bonjour a tous,
pour commencer je voudrais remercier ceux qui m'ont aidés avec mes pointeurs, j'ai réglé le problème en adoptant le même architecture qu'une liste chaînée.
--------------------------------------------------------------------------
Toujours dans l'implémentation de l'A*, j'ai un autre problème.
J'ai une class Noeud. Or chaque instance de cette class est créée grâce à new.
Or je ne sais pas où placer l'opérateur delete.

Je vous donne le shéma du fichier source :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

class Noeud {   };   class A_star { //Dans une fonction quelconque. C = new Noeud(); };

---

Quand je mets delete dans le destructeur de A_star, ça plante, quand je le mets dans le destructeur de Noeud, ça plante...
:help:

Citation:

---

Envoyé par juloss

Je vous donne le shéma du fichier source :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

class Noeud {   };   class A_star { //Dans une fonction quelconque. C = new Noeud(); };

---

---

Attention : tu ne programmes pas en Java, là. Le code ne se met pas dans la déclaration de la classe A_star, sauf si tu veux qu'il soit inline.

Ensuite, new n'est nécessaire que pour faire l'allocation d'un objet persistant. Si tu veux créer un objet au sein d'un bloc, tu le déclares, tout simplement. Il sera initialisé tout seul (comme les types natifs du Java) et disparaîtra quand tu sortiras de ton bloc.

En plus, on ne voit même pas ton delete(), ici.

Citation:

---

Envoyé par juloss

quand je le mets dans le destructeur de Noeud, ça plante...

---

Une classe ne peut pas appeler un delete d'elle-même :nono: !
Raisonnement par l'absurde: admettons que le delete fonctionne, où le code va aller chercher la suite à exécuter vu que l'objet qui a appelé le delete vient d'être détruit :wow: ?

Après, je rejoins Obsidian, à savoir qu'il faut que tu vérifies l'utilité de ton pointeur par rapport à une instance pure et simple de l'objet Noeud.

Enfin, pour te répondre, sache qu'un pointeur et l'objet pointé sont deux choses différentes. Une fois le new fait, l'espace mémoire alloué existera tant qu'il ne sera pas libéré par le fameux delete. Donc tu peux faire un new à peu près partout et idem pour le delete.
Pense seulement à vérifier lors du delete que l'espace alloué existe toujours et que le pointeur pointe bien dessus.

Et garde bien à l'esprit que l'utilisation de pointeurs pose souvent des problèmes lorsqu'ils sont mal gérés... :roll:

Citation:

---

Envoyé par spoutspout

Une classe ne peut pas appeler un delete d'elle-même :nono: !
Raisonnement par l'absurde: admettons que le delete fonctionne, où le code va aller chercher la suite à exécuter vu que l'objet qui a appelé le delete vient d'être détruit :wow: ?

---

Si si, une classe peut appeler elle même son delete car seules les données de la classe sont détruite/désallouées, le code de la classe continue lui à exister.

Par contre, et c'est là le piège, il faut être sûr qu'une fois que le delete est appelé, le code n'utilise plus les données membres de la classe, sinon c'est le crash assuré.

Il faut d'abord se poser des questions sur le type d'association qui existe entre un objet de type "A_star" et un objet de type "Noeud".

1. est ce que toutes les instances de A_star "contiennent" une instance spécifique de Noeud qui lui est associée?
2. est ce que certaines instances de A_star font référence à une instance d'objet noeud qui peut être identique à plusieurs instances?

Dans le cas 2, il me semblerait préférable de réaliser l'association via un boost::shared_ptr.

Dans le premier cas, A_star pourra contenir la valeur d'un Noeud ou une référence.

Si A_star contient la valeur:

Code:

---

1 2 3 4 5 6

class A_star { Noeud C; // on déclare Noeud dans les données de la classe. A_star() // comment le constructeur initialise C? ~A_star() // qui y a t-il de spécifique à faire dans le dtor? }

---

Dans ce cas, le structure incluse a la meme durée de vie que l'objet de type A_star qui le contient. Pas besoin d'allouer ou de libérer quoi que ce soit d'autre que le contenant A_star.

Si A_star contient une référence...

Code:

---

1 2 3 4 5 6

class A_star { Noeud* C; // on déclare un pointeur vers Noeud. A_star() // ici, on va faire l'allocation ~A_star() // ici, on va faire le delete. }

---

Allocation et libération doivent se faire avec la création et la destruction de l'objet... Dans les méthode correspondantes.

- W

Citation:

---

Envoyé par spoutspout

Une classe ne peut pas appeler un delete d'elle-même :nono: !

---

Mince... j'ai quelques delete this; dans mon code, et ca me semble parfaitement conforme, et utile. Naturellement, on ne peut rien faire utilisant les membres de this apres, mais c'est la seule contrainte.

Citation:

---

Envoyé par spoutspout

Une classe ne peut pas appeler un delete d'elle-même :nono: !
Raisonnement par l'absurde: admettons que le delete fonctionne, où le code va aller chercher la suite à exécuter vu que l'objet qui a appelé le delete vient d'être détruit :wow: ?

---

Je ne vois pas le problème, le programme continue la fonction.

En effet, en créant plusieurs instances d'une classes, on duplique les données membres, mais pas les méthodes qui ne sont qu'à un seul endroit dans le programme.

Après, c'est sûr qu'une classe doit éviter d'utiliser/modifier un de ses membres/méthodes après s'être auto-supprimée, et c'est sûr que s'auto-supprimer dans son propre destructeur est une mauvaise idée.

Edit: grillé :(

Si tu veux de l'aide pour A*, un tutoriel avec une implémentation en C++ se trouvent ici.

PS:

Citation:

---

Envoyé par coyotte507

Citation:

---

Envoyé par spoutspout

Une classe ne peut pas appeler un delete d'elle-même !
Raisonnement par l'absurde: admettons que le delete fonctionne, où le code va aller chercher la suite à exécuter vu que l'objet qui a appelé le delete vient d'être détruit ?

---

Si si, une classe peut appeler elle même son delete car seules les données de la classe sont détruite/désallouées, le code de la classe continue lui à exister.

---

C'est vrai ! Sans la possibilité qu'un objet appelle delete sur lui-même, comment faire un singleton ?

Décidément, j'en apprendrais tous les jours... :roll:
Vous pouvez me donner une application concrète de ce cas, pour que ça me parle un peu plus sur son utilité?

Citation:

---

Envoyé par spoutspout

Décidément, j'en apprendrais tous les jours... :roll:
Vous pouvez me donner une application concrète de ce cas, pour que ça me parle un peu plus sur son utilité?

---

Des objets qui decident de se detruire en reponse a des evenements exterieurs (exemple canonique une fenetre). A noter que parfois il y a quand meme interet a retarder la destruction.

Citation:

---

Envoyé par thms92

Sans la possibilité qu'un objet appelle delete sur lui-même, comment faire un singleton ?

---

Citation:

---

Envoyé par Jean-Marc.Bourguet

Des objets qui decident de se detruire en reponse a des evenements exterieurs (exemple canonique une fenetre). A noter que parfois il y a quand meme interet a retarder la destruction.

---

Convaincu :mrgreen: !
(le pire c'est que j'en ai déjà utilisé... :traine: )

juloss, a priori l'endroit ou detruire devrait etre A_star... mais il peut y avoir de bonnes raisons de faire autrement, et de bonne raisons de remettre en cause meme l'allocation dynamique. Tu ne donnes pas assez de renseignements pour faire autre chose que de jouer aux devinettes. On tombe parfois juste, parfois pas a ce jeu.

Dans windows/MFC, les fenêtres utilisent souvent un delete this sur DestroyWindow(). Je crois que wxWidget fait de même mais c'est à prendre avec réserve. En fait, c'est souvent utile (outre le singleton), quand un objet n'a pas vraiment de raison d'appartenir à un autre et d'être managé par lui , par conséquent il s'autodétruit quand il le juge nécessaire. Bien sûr, le plus prudent est que le delete this soit le dernier appel de la méthode.

Citation:

---

Envoyé par juloss

Toujours dans l'implémentation de l'A*, j'ai un autre problème.
J'ai une class Noeud. Or chaque instance de cette class est créée grâce à new.
Or je ne sais pas où placer l'opérateur delete.

---

Ce que tu veux, c'est que quand tu détruits un noeud, tous les enfants soient détruits!
Donc le delete d'un noeud doit appeler un delete sur tous ses enfants, ce qui va détruire tous les noeuds après ton noeud courant !

Conséquence: si tu appelles le destructeur de ton noeud de base, alors tout ton arbre sera détruit ! ;)

Lors d'un comptage de références intrusif, il est d'usage que le Release() de l'objet fasse un delete this lorsqu'on relâche la dernière référence.

C'est également dans ce genre de circonstances, qu'on peut tirer profit de la possibilité de deleter un pointeur const, si l'on offre la possibilité d'obtenir des pointeurs const sur l'objet:

• Nombre de références stocké dans une variable membre mutable.
• Fonctions membres AddRef() et Release() déclarées const.
• delete this dans le Release() quand le compteur atteint zéro...

Je sais bien que mon code n'est pas exhaustif. Mais je peux pas vous donnez tous le code, il est trop long et inutile pour mon problème.
Pour essayer d'être plus précis, imaginez une liste chainée d'instance d'une class A.
Le class B possède un pointeur sur l'une des extrémités de la liste chainée.
Ainsi B peut utiliser la liste chainée.
Mais toutes les instances de A ont été créées avec new (à part la première).

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 A { A * Pointeur_Sur_Parent; };   class B { // Définition : A *Pointeur_Sur_Tete; A Depart; //relation HAS_A   //Constructeur : B () :Depart { Pointeur_Sur_Tete=&Depart; }   //Liste chainée void Fonction() { A *Courant; Courant = new A; A.Pointeur_Sur_Parent = Pointeur_Sur_Tete; Pointeur_Sur_Tete = Courant; }   };

---

Et mon problème est que qhand j'ai finit d'utiliser ma liste chainée je veux desallouer le mémoire dediée à ma liste. Or je n'y arrive pas, le programme plante à l'appel de delete et entre dans une boucle infine :bug:
Donc ma question est : Comment désallouer la liste?

Pour dés allouer une liste chainée,
il faut supprimer les éléments en commençant par la tête.
exemple:

Code:

---

1 2 3 4 5 6 7

while (NULL !=tete) { A * tmpTete = tete; tete = tete->next(); delete tmpTete; }

---

Citation:

---

Envoyé par juloss

Je sais bien que mon code n'est pas exhaustif. Mais je peux pas vous donnez tous le code, il est trop long et inutile pour mon problème.
Pour essayer d'être plus précis, imaginez une liste chainée d'instance d'une class A.
Le class B possède un pointeur sur l'une des extrémités de la liste chainée.
Ainsi B peut utiliser la liste chainée.
Mais toutes les instances de A ont été créées avec new (à part la première).

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

class A { A * Pointeur_Sur_Parent; };   class B { // Définition : A *Pointeur_Sur_Tete; A Depart; //relation HAS_A   //Constructeur : B () :Depart { Pointeur_Sur_Tete=&Depart; }

---

Et mon problème est que qhand j'ai finit d'utiliser ma liste chainée je veux desallouer le mémoire dediée à ma liste. Or je n'y arrive pas, le programme plante à l'appel de delete et entre dans une boucle infine :bug:
Donc ma question est : Comment désallouer la liste?

---

Tu essaies vraisemblablement -- sans voir le code on ne peut jouer qu'aux devinettes -- de faire un delete du membre Depart de B.

A base de boost, j'avais fait un truc comme ça, je sais pas si ça peut t'aider...

Node.h :

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

#pragma once   #include <list> #include <iostream> #include <fstream> #include <boost/ptr_container/ptr_list.hpp> #include "constantes.h" #include <algorithm>     class Node { public: typedef float value_type; typedef boost::ptr_list <Node> Arbre; typedef boost::ptr_list <Node>::const_iterator const_child_iterator; typedef boost::ptr_list <Node>::iterator child_iterator;   Node(value_type val, int pos, Node * parent): m_Value(val), m_Level(pos), m_Parent(parent) { FindChilds(); } ~Node() {}   void FindChilds(); bool HasChilds() const; void AddNode(value_type value); void WritePath(Node *) const;   Node * GetParent() {return m_Parent;} Node * GetParent() const {return m_Parent;} Arbre GetChilds() {return m_Childs;} Arbre GetChilds() const {return m_Childs;}   value_type GetValue() const {return m_Value;} int GetLevel() const {return m_Level;}   static int GetNbSolutions() {return nbSolutions; }     private: Arbre m_Childs; Node * m_Parent; int m_Level; value_type m_Value;   static int nbSolutions; static std::ofstream file; };

---

Node.cpp:

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 53 54 55 56 57

#include "node.h"   std::ofstream Node::file("output.txt"); int Node::nbSolutions = 0;   void Node::AddNode(value_type value) { m_Childs.push_back( new Node(value, m_Level + 1, this) ); }   bool Node::HasChilds() const { return m_Childs.empty(); }   void Node::WritePath(Node * node) const { ++nbSolutions; std::vector<value_type> vect; vect.push_back (node->GetValue() );   Node * node_parent = node ; while (node_parent->GetLevel() != 0) { node_parent = node_parent->GetParent(); vect.push_back(node_parent->GetValue() ); }   std::reverse(vect.begin(), vect.end() ); std::copy(vect.begin(), vect.end(), std::ostream_iterator<value_type>(file, "\t") ); file << "\n"; }         void Node::FindChilds() { if (m_Level + 1 < m_Rows) { std::vector<value_type> & vect = m_Matrix[m_Level + 1]; std::vector<value_type>::const_iterator iter = std::find_if(vect.begin(), vect.end(), std::bind2nd(std::greater_equal<float>(), m_Value) );   if (iter != vect.end() ) { for (; iter != vect.end(); ++iter) { AddNode(*iter); } } } else { WritePath(this); }   }

---

Bonne continuation,

Poukill