Discussion :

[juloss]

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 :

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

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

[Obsidian]

Je vous donne le shéma du fichier source :

Code :

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

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.

[Spout]

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

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 ?

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

[ram-0000]

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.

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é.

[thms92]

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

PS:

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 ?

[Spout]

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

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 !
(le pire c'est que j'en ai déjà utilisé... )

[3DArchi]

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.

[wiztricks]

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 :

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

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 :

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

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

[Jean-Marc.Bourguet]

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

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.

[coyotte507]

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 ?

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é

[Spout]

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

[Jean-Marc.Bourguet]

Décidément, j'en apprendrais tous les jours...
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.

[Jean-Marc.Bourguet]

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.

[poukill]

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 !

[Médinoc]

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

[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 :

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
 
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
Donc ma question est : Comment désallouer la liste?

[Luther13]

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

Code :

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

1
2
3
4
5
6
7
 
while (NULL !=tete)
{
A * tmpTete = tete;
tete = tete->next(); 
delete tmpTete;
}

[Jean-Marc.Bourguet]

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 :

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

[poukill]

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

Node.h :

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
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 :

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
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