Problème avec les pointeurs.
Bonjour.
Mon problème est un peu complexe.
J'essai d'implémenter l'algorithme A* (pathfinding).
Pour cela j'ai une class 'Noeud' qui possède un pointeur vers une autre instance de la class 'Noeud'.
Dans la boucle de recherche j'utilise le conteneur 'Deque'.
Or quant on parcours la liste fermée une fois le chemain trouvé, on s'aperçoit que tous les éléments de la liste fermée ont leur pointeur respectif qui pointent tous vers le même élément (le dernier Noeud trouvé):?
:triste:
Le vous donne une version simplifiée du code...
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
class Noeud
{
public:
Noeud *Parent; //Parent est un pointeur sur le noeud parent.
//-----------Constructeur de recopie---------------------------------------
Noeud (const Noeud &a)
{
Parent=a.Parent;
}
//-----------Constructeur de recopie---------------------------------------
//++++++++++++++++opérateurs+++++++++++++++++++++++++++++++++
//operateur = surchargé
Noeud & operator=( const Noeud &a )
{
Parent=a.Parent;
return (*this);
}
//operateur = surchargé
//operateur () surchargé
Noeud & operator()( Noeud *B)
{
Parent=B;
return (*this);
}
//operateur () surchargé
//++++++++++++++++opérateurs+++++++++++++++++++++++++++++++++
};
class A_star
{
public:
deque<Noeud> Open; //Liste ouverte de la recherche.
deque<Noeud> Closed; //Liste fermée de la recherche.
Noeud Depart, Arriver; //Le départ et arrivée du chemain.
//-----------Constructeur-------------------------------------------------
A_star(int X_depart, int Y_Arriver, int X_fin, int Y_arriver)
: Depart(X_depart, Y_Arriver,1000), Arriver(X_fin, Y_arriver)
{
Depart.Parent=0; //Depart est le seul Noeud à ne pas avoir de parent.
}
//-----------Constructeur-------------------------------------------------
//********************************************************
void Recherche_Chemain()
{
Noeud Courant;
Noeud *CC=&Depart;
Open.push_front(Depart);
while( !Open.empty() )//Boucle de la recherche.
{
Noeud Test(0,0,100000);//Création d'un Noeud avec un 'F' de 100000.
Test.Parent=0;
for(int i=0; i<Open.size(); i++)//On cherche le plus petit élément de Open
{
if( Open[i] < Test) //On se sert du poid F.
Test=Open[i];
}
for(int i=0; i<Open.size(); i++)//On suprime ce pluspetit élément de Open
if( Open[i]==Test)
Open.erase( Open.begin()+i);
Courant=Test;// Courant est le Noeud avec le 'F' le plus faible de 'Open'
Closed.push_front(Courant); Et on le met dans Closed
if(Courant==Arriver)//Si on est arrivé.
{
return; //On arrête de chercher.
}
else
{
CC=&Courant;// CC est un pointeur sur le Noeud courant.
//Au nord
Test(CC);//Opérateur ().
Test.y-=1;//On change les coordonnées de Test pour calculer le poid de ce Noeud.
//Toutes les autres case sont analysée de la même manière, seules les coordonnées de Test changent.
if(Les condition sont peu importantes)
{
Test.Calcul_F(Arriver);// On calcul le poid de la case.
Open.push_front(Test); //On ajoute Test à la liste ouverte
}
}
}//Fin de la boucle de la recherche.
cout<<"Pas de chemain"<<endl;
}
//********************************************************
};
int main(int argc, char *argv[])
{
A_star A(1,1,9,9);
A.Recherche_Chemain();
system("PAUSE");
return EXIT_SUCCESS;
} |
J'ai enlevé tous ce qui n'a pas de rapport avec les pointeur.
Si vous voyez une erreur, merci de me le dire:oops:
