Discussion :

[114_49]

Déplacer un robot, dans une grille cellulaire de taille 15*15, partant d’un point de départ (donné) jusque un point d’arrivé (donné aussi).
Et le déplacement d’une cellule à une autre se fait par un choix aléatoire dans le voisinage de cette cellule (les 8 cellules tournant de cette cellule).
Le robot se déplace pas à pas.
Une cellule a les coordonnées (x, y).
Le déplacement d’une cellule à une autre se fait de telle façon que :
x2<=x1<=x, et y2<=y1<=y (dans le cas où les coordonnées de cellule de départ supérieur aux celles d’arrivées).

(x1, y1) : coordonnées de cellule courante.
(x, y) : coordonnées de cellule de départ.
(x2, y2) : coordonnées de cellule d’arrivée.
J’ai une fonction mais je ne sais pas si elle est correcte ou non, parce que quand je l’ai testé le programme cesse de fonctionner.
voilà le code:

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
void deplacer_agent(float **g, int *px,int *py,int *px2,int *py2,bool ** cd,int dep1,int tg, bool *init)
{
    int k;
 
 
    if((&px2>&px) && (&py2>&py))
    {
        k=*px;
        *px=*px2;
        *px2=k;
    }
 
    if(*init&&*px!=-1&&*py!=-1)
    {
 
        cd[*px][*py]=false;
        *init=false;
    }
 
    else
    {
        if(*init&&*px==-1&&*py==-1)
 
        {
 
            *px=rand() %10;
            *py=rand() %10;
            cd[*px][*py]=false;
            *init=false;
        }
        else
        {
            int px1=*px;
            int py1=*py;
 
            if(dep1==-1)
            {
 
                px1=*px;
                py1=*py;
                int compt=0;
                while(((px1<0||px1>tg-1||py1<0||py1>tg-1)||((dep1==-1)) )&&compt<20)
                {
 
                    compt++;
                    px1=*px;
                    py1=*py;
 
                    do
                    {
                        dep1=rand() %8;
                        {
                            if(dep1==0 && (*px2<=px1<=*px) && (*py2<=py1<=*py)){py1=py1-1; }
                            if(dep1==1 && (*px2<=px1<=*px) && (*py2<=py1<=*py)){py1=py1-1;px1=px1-1;}
                            if(dep1==2 && (*px2<=px1<=*px) && (*py2<=py1<=*py)){px1=px1-1;}
                            if(dep1==3 && (*px2<=px1<=*px) && (*py2<=py1<=*py)){py1=py1+1;px1=px1-1;}
                            if(dep1==4 && (*px2<=px1<=*px) && (*py2<=py1<=*py)){py1=py1+1;}
                            if(dep1==5 && (*px2<=px1<=*px) && (*py2<=py1<=*py)){py1=py1+1;px1=px1+1;}
                            if(dep1==6 && (*px2<=px1<=*px) && (*py2<=py1<=*py)){px1=px1+1;}
                            if(dep1==7 && (*px2<=px1<=*px) && (*py2<=py1<=*py)){py1=py1-1;px1=px1+1;}
                        }
                    }
                    while((*px2<=px1<=*px) && (*py2<=py1<=*py));
 
                    if(px1>=0&&px1<=tg-1&&py1>=0&&py1<=tg-1)
                    {
                        if(!cd[px1][py1]){px1=-1;py1=-1;}
                    }
 
 
                }
                if(px1>=0&&px1<=tg-1&&py1>=0&&py1<=tg-1)
                    {cd[px1][py1]=false;*px=px1;*py=py1;   }
                else
                    {*px=-1; *py=-1; }
 
            }
        }
    }
}

[LittleWhite]

Bonjour,

J’ai une fonction mais je ne sais pas si elle est correcte ou non, parce que quand je l’ai testé le programme cesse de fonctionner.

Donc, votre fonction est fausse ,car elle entraine le crash (erreur de segmentation) du programme. Il faut maintenant la déboguer.

Code :

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

if((&px2>&px) && (&py2>&py))

Ceci est ultra étrange. Je pense que vous maitrisez les pointeurs : http://chgi.developpez.com/pointeur/

Code :

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

if(*init&&*px==-1&&*py==-1)

Vous testez si *init ET *px est "vrai" (souvent != 0) et le résultat, soit "vrai", soit "faux", vous le comparez à -1. Ce qui est totalement plus que totalement incorrect.

Pour faire votre algorithme, commencez par l'écrire (son comportement) sur une feuille de papier.

[ternel]

A priori, un crash, c'est quasiment toujours un *NULL ou un free() d'un pointeur déjà libéré.

Comme ton code est bourré de pointeur, le problème vient de là.

Je te recommande fortement d'utiliser une structure de position
typedef struct position {
int x, y;
} position;

Tu as trop de pointeurs.
Seul les variables sur d'énorme structures (pointeurs constants) et les arguments à modifier (pointeurs non-constants) devraient être passé par pointeurs.
Pour les tableaux, je recommande d'utiliser la notation [] dans les arguments.

void deplacer_agent(float **g, int *px,int *py,int *px2,int *py2,bool ** cd,int dep1,int tg, bool *init)devrait être
void deplacer_agent(float const grille[][], int const taille_grille, position actuelle, position const cible, position const source, bool const cd[][], int dep1, bool *init).
Et encore, je ne comprends ni init, ni cd ni dep1, les noms sont mal donné.

N'hésite jamais à marquer const tout argument un peu complexe (tableau, structure, pointeur) qui n'a pas vocation à être modifié.

[gangsoleil]

Bonjour,

En plus des commentaires précédents : lorsque tu écris cela : (*px2<=px1<=*px) tu veux vérifier que px1 est compris entre *px2 et *px ? Si oui, il faut que tu sépares ça en deux tests distincts.

[114_49]

Comme ton code est bourré de pointeur, le problème vient de là.

Tu as trop de pointeurs.

Voilà cette fonction (deplacer_agent) qui travaille sans problèmes portant qu’elle utilise plusieurs pointeurs.

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
58
59
60
61
62
63
64
65
66
 
void deplacer_agent(float **g, int *px,int *py,bool ** cd,int dep1,int tg, bool *init)
{
 
    if(*init&&*px!=-1&&*py!=-1)
    {
       cd[*px][*py]=false;
       *init=false;
 
    }
    else
    {
        if(*init&&*px==-1&&*py==-1)
        {
          *px=rand() %10;
          *py=rand() %10;
          cd[*px][*py]=false;
          *init=false;
          }
          else
          {
 
         int px1=*px;
           int py1=*py;
 
 
        if(dep1==-1)
          {
           px1=*px;
           py1=*py;
           int compt=0;
    while(((px1<0||px1>tg-1||py1<0||py1>tg-1)||((dep1==-1)) )&&compt<20)
                {
 
               compt++;
           px1=*px;
           py1=*py;
                  dep1=rand() %8;
        if(dep1==0){py1=py1-1; }
        if(dep1==1){py1=py1-1;px1=px1-1;}
        if(dep1==2){px1=px1-1;}
        if(dep1==3){py1=py1+1;px1=px1-1;}
        if(dep1==4){py1=py1+1;}
        if(dep1==5){py1=py1+1;px1=px1+1;}
        if(dep1==6){px1=px1+1;}
        if(dep1==7){py1=py1-1;px1=px1+1;}
 
        if(px1>=0&&px1<=tg-1&&py1>=0&&py1<=tg-1)
        {
        if(!cd[px1][py1]){px1=-1;py1=-1;}
        }
 
 
 
                }
      if(px1>=0&&px1<=tg-1&&py1>=0&&py1<=tg-1)
        {cd[px1][py1]=false;*px=px1;*py=py1;   }
      else
        {*px=-1; *py=-1; }
 
           }
 
 
    }
}
}

En fait la fonction deplacer_agent2 () c’est la fonction deplacer_agent () avec modification, j’essaie de la modifier pour arriver à programmer le problème écrite dans la discussion.

[ternel]

On va jouer à un jeu.
Tu vas donner de vrais noms à chaque variable et surtout à chaque paramètre.

Et en plus, tu as un devoir supplémentaire:
tu nous fais la liste des variables de l'utilisateur de la fonction qui doivent être modifiés par l'appel.

Code :

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

1
2
3
4
5
6
 
        if(dep1==0){py1=py1-1; }
        if(dep1==1){py1=py1-1;px1=px1-1;}
        if(dep1==2){px1=px1-1;}
        if(dep1==3){py1=py1+1;px1=px1-1;}
        if(dep1==4){py1=py1+1;}

Ca, c'est très très moche.
Ca se remplace par un switch sur dep1, et surtout un commentaire avant, genre, "faire un déplacement".

et puis px1 devrait probablement etre source_x, dest_x ou current_x

[Médinoc]

De plus, on dirait que tu fais un effort pour réduire la lisibilité de ton code. Les espaces coûtent cher, chez toi?