Génération de labyrinthe en récursif à l'aide de structure

Version imprimable

Bonjour , pour un projet scolaire je dois faire un labyrinthe en récursif .

Voilà mon 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
void gen_lab ()
{
 
    srand(time(NULL));
 
 
    if((cellule.tab[x+1][y]) != (cellule.etat==0))
    {
        cpt--;
        return gen_lab(cellule.tab[x][y],cpt);
    }
    if((cellule.tab[x][y-1]) != (cellule.etat==0))
    {
        cpt--;
        return gen_lab(cellule.tab[x][y],cpt);
    }
        if((cellule.tab[x-1][y]) != (cellule.etat==0))
    {
        cpt--;
        return gen_lab(cellule.tab[x][y],cpt);
    }
        if((cellule.tab[x][y+1]) != (cellule.etat==0))
    {
        cpt--;
        return gen_lab(cellule.tab[x][y],cpt);
    }
 
 
    pos = rand()%3;
    if((pos == N)&&(cellule.tab[x+1][y])&&(cellule.etat==0))
    {
        cpt++;
        cellule.etat==1;
        cellule.tab[x][y] = cellule.tab[x+1][y];
        return gen_lab(cellule.tab[x][y],cpt);
    }
    if((pos == O)&&(cellule.tab[x][y-1])&&(cellule.etat==0))
    {
        cpt++;
        cellule.etat==1;
        cellule.tab[x][y] = cellule.tab[x][y-1];
        return gen_lab(cellule.tab[x][y],cpt);
    }
    if((pos == S)&&(cellule.tab[x-1][y])&&(cellule.etat==0))
    {
        cpt++;
        cellule.etat==1;
        cellule.tab[x][y] = cellule.tab[x-1][y];
        return gen_lab(cellule.tab[x][y],cpt);
    }
    if(((pos == E)&&(cellule.tab[x][y-1]))&&(cellule.etat==0))
    {
        cpt++;
        cellule.etat==1;
        cellule.tab[x][y] = cellule.tab[x][y-1];
        return gen_lab(cellule.tab[x][y],cpt);
    }
 
 
}

Ça c'est la fonction . et ça mon headers :

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
struct cellule
{
    int N;
    int E;
    int O;
    int S;
    int etat;
    int tab[9][9];
};
 
 
 
 
 
N = 0;
E = 1;
S = 2;
O = 3;
 
 
 
 
 
 
int cel_dep;
 
int cel_temp;
 
int x = 0;
int y = 0;
int pos;
 
 
 
int cpt = 0;

Alors voilà le tout compile avec mon main est tout mais directement j'ai le message comme quoi ça à cessez de fonctionner,je pense que je n'utilise pas bien ma structure, alors merci à ceux qui vont bien vouloir m'expliquer.

PS : pas de troll pour me dire que mon orthographe ne va pas ou autre, je viens demander de l'aide et rien d'autre.

06/04/2016, 19h49
picodev

Bonjour,

montre-nous ton vrai code en expliquant ta structure cellule, le vrai prototype de ta fonction gen_lab, … parce que là c'est assez confus.
Du coin de l’œil je peux déjà supposer que ta recherche récursive est mal foutue à cause de cpt que tu incrémentes et décrémentes mais je n'en suis pas certain.

Bonsoir,

Alors voilà mon code complet :

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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "variable.h"
 
 
 
lab cellule;
 
void aff_init_lab ();
int gen_lab();
 
 
 
void aff_init_lab ()  //Ne pas faire attention à cette fonction car elle est fausse même si je ne sais pas vraiment comment la faire 
{
    int cpt_1;
    int cpt_2;
 
 
    for(cpt_1=0;cpt_1<=9;cpt_1++)
    {
        for(cpt_2=0;cpt_2<=9;cpt_2++)
        {
            printf("|_|");
            cellule.etat = 0; //Cellule Fermer
        }
        printf("\n");
    }
 
}
int gen_lab ()
{
 
    srand(time(NULL));
 
 
 
    if((cellule.tab[x+1][y]) != (cellule.etat==0))
    {
        //w--;
        cpt--;
        return gen_lab(cellule.tab[x][y],cpt);
    }
    if((cellule.tab[x][y-1]) != (cellule.etat==0))
    {
       // w--;
        cpt--;
        return gen_lab(cellule.tab[x][y],cpt);
    }
        if((cellule.tab[x-1][y]) != (cellule.etat==0))
    {
        //w--;
        cpt--;
        return gen_lab(cellule.tab[x][y],cpt);
    }
        if((cellule.tab[x][y+1]) != (cellule.etat==0))
    {
        //w--;
        cpt--;
        return gen_lab(cellule.tab[x][y],cpt);
    }
 
 
    pos = rand()%3;
    if((pos == N)&&(cellule.tab[x+1][y])&&(cellule.etat==0))
    {
        //lab cellule[w];
        //w++;
        cpt++;
        cellule.etat==1;
        cellule.tab[x][y] = cellule.tab[x+1][y];
        return gen_lab(cellule.tab[x][y],cpt);
    }
    if((pos == O)&&(cellule.tab[x][y-1])&&(cellule.etat==0))
    {
        //lab cellule[w];
        //w++;
        cpt++;
        cellule.etat==1;
        cellule.tab[x][y] = cellule.tab[x][y-1];
        return gen_lab(cellule.tab[x][y],cpt);
    }
    if((pos == S)&&(cellule.tab[x-1][y])&&(cellule.etat==0))
    {
        //lab cellule[w];
        //w++;
        cpt++;
        cellule.etat==1;
        cellule.tab[x][y] = cellule.tab[x-1][y];
        return gen_lab(cellule.tab[x][y],cpt);
    }
    if(((pos == E)&&(cellule.tab[x][y-1]))&&(cellule.etat==0))
    {
        //lab cellule[w];
        //w++;
        cpt++;
        cellule.etat==1;
        cellule.tab[x][y] = cellule.tab[x][y-1];
        return gen_lab(cellule.tab[x][y],cpt);
    }
 
 
}
 
 
int main()
{
    gen_lab();
 
    return 0;
}

et le headers :

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
typedef struct lab lab;
struct lab
{
    int N;
    int E;
    int O;
    int S;
    int etat;
    int tab[9][9];
};
 
 
 
 
 
N = 0;
E = 1;
S = 2;
O = 3;
 
 
int w = 1;
 
 
int cel_dep;
 
int cel_temp;
 
int x = 0;
int y = 0;
int pos;
 
 
 
int cpt = 0;

J'ai changé 2 ou 3 trucs en essayant de faire fonctionner tout ça.
Merci.

06/04/2016, 20h43
picodev

La première chose à faire dans le code est de prototyper tes fonctions : dire quels paramètres tu passes, parce que là ce n'est pas du C que tu fais. Tu as déjà fait du C ou es-tu en train d'apprendre ?
Ensuite il faut que tu nous explique ce que sont pour toi les membres de ta structure et l'algorithme que tu comptes écrire.
07/04/2016, 11h10
daftangel

Je suis en train d'apprendre, c'est la première année ou j'en fais.
Quand tu parle de prototype, j'ai déclaré ma fonction en en-tête du programme et elle prend aucun paramètre vu que ma structure est dans un headers. Je ne comprends pas trop ce que tu veut me dire.
07/04/2016, 12h00
ternel
Bon, dans ce cas, il convient d'apprendre les fondamentaux du langage.

Un programme est composé de ce que la norme nomme des "unités de compilations".
Une unité de compilation correspond à un fichier .c une fois que le préprocesseur est passé dessus. C'est à dire une fois que chaque #include a été remplacé par le contenu du fichier indiqué, et que les macros ont été remplacées par leur texte de substitution.

Cela permet entre autre de faire de la compilation par morceau: chaque unité de compilation est compilée indépendamment.

Une fois chaque unité compilée, les fichiers produits sont reliés entre eux pendant l'édition de liens.
C'est à ce moment là qu'apparaissent les erreurs de type "undefined reference to Bidule".

Chaque unité de compilation doit être composée uniquement de déclaration et/ou définitions de fonctions (et parfois de variables globales, mais il faut éviter).

Partant de là, on comprend le rôle d'un en-tête: partager des déclarations entre plusieurs unités de compilation.
Pour que cela ne pose pas de problème, il ne doit contenir que des déclarations extern ou static.

Une déclaration de fonction (un prototype sans code) est extern par défaut.
Une variable est toujours définie, à moins de passer justement par une déclaration extern, telle que extern int entier;, qui ne donne pas de valeur.

Une déclaration extern impose qu'il y ait une (et une seule) unité de compilation donnant la définition de l'objet déclaré.

Un en-tête peut aussi contenir des typedefs, des définitions de types complexes (struct, enum ou union).
Il peut aussi définir des macros, mais il faut être très prudent avec ca.

Toute autre instruction posera problème.
En fait, un en-tête ne devrait jamais contenir de valeur explicite, c'est quasiment toujours une erreur.

Par ailleurs, il existe un gros soucis avec le mécanisme des #include: un fichier pouvant être inclus par plusieurs autres, il peut arriver qu'il soit inclus au final plusieurs fois dans une même unité de compilation (c'est généralement le cas de certains en-têtes systèmes comme stdio.h)
Pour éviter cela, on utilise ce qu'on appelle une garde contre les doubles inclusions (double inclusion guard):
Code:

1 2 3 4 5 6 #ifndef MON_ENTETE_H_INCLUDED #define MON_ENTETE_H_INCLUDED /* tout l'en-tête*/ #endif /*MON_ENTETE_H_INCLUDED */
En procédant ainsi, lors de la deuxième inclusion, le #ifndef est faux et l'intégralité du fichier est sauté, évitant ainsi de définir deux fois chaque chose
07/04/2016, 12h07
ternel

Citation:

Envoyé par daftangel

Je suis en train d'apprendre, c'est la première année ou j'en fais.
Quand tu parle de prototype, j'ai déclaré ma fonction en en-tête du programme et elle prend aucun paramètre vu que ma structure est dans un headers. Je ne comprends pas trop ce que tu veut me dire.

La structure n'est pas sensée être dans un en-tête. Son type y est certes défini, mais l'objet est sensé n'être qu'une variable locale de main() (ou d'une autre fonction).
Il faut absoluement éviter les variables globales (surtout quand on débute) car elles sont un très bon moyen de s'embrouiller.
07/04/2016, 12h20
daftangel

Dans ce cas là comment je peut utiliser dans plusieurs fonction la même structure si elle n'est pas en global.Sinon merci de t'être posé pour m'expliquer les vrai bases de la prog et de m'aider .
07/04/2016, 12h38
picodev

Citation:

Envoyé par daftangel

Bonjour , pour un projet scolaire je dois faire un labyrinthe en récursif .
[...]

Si c'est un projet scolaire qui demande d'utiliser la récursivité je suppose que tu as vu dans le cours comment passer des paramètres à tes fonctions ?

Bon apparemment non car :

Citation:

Envoyé par daftangel

Dans ce cas là comment je peut utiliser dans plusieurs fonction la même structure si elle n'est pas en global.Sinon merci de t'être posé pour m'expliquer les vrai bases de la prog et de m'aider .

Avant même de vouloir commencer à créer un programme de ce genre il va falloir revoir toutes les bases, soit avec ton cours, soit avec les cours sur le net. Il te reste combien de temps pour ce projet ?
07/04/2016, 12h42
daftangel

Il me reste une semaine(mardi prochain), mais on as vu comment mettre en paramètre mais pas comment mettre en paramètre des structures, d'où l'utilisation le headers.

En fait, tu n'as pas l'air d'avoir saisi comment fonctionne une fonction.

Posons un peu de code pour avoir de quoi causer:
Code:

1 2 3 4 5 6 int f (int a) {return 2*a;} int main(void) { int a = 2; return f(a); }
Transcrivons cela en français.
J'inverse volontairement la lecture de type, pour aider à comprendre les typedef complexes et surtout éviter une erreur avec les pointeurs. Pose la question si tu veux en savoir plus.

Soit un entier, celui retourné par f quand on lui donne un entier a.
La définition de f est:
    sachant l'entier a, retourner 2*a;

Soit un entier, celui retourné par main quand on ne lui donne pas d'argument.
La définition de main est:
    Soit un entier a de valeur 2;
    Retourner la valeur de f pour la valeur courante de a.
Concrêtement, j'ai choisi int comme type d'argument, mais j'aurai pu prendre autre chose.

Dans tous les cas, le code produit par le compilateur est fonctionnellement équivalent à ceci:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 //appeler main int a = 2; //évaluation de return f(a); //création du premier argument de la fonction int f(int), en l'initialisant avec la valeur passé en argument int a@"int f(int)" = a; //appel de f(a): //création de la valeur de retour de l'appel de fonction int temp = 2*a@"int f(int)"; //fin de l'appel de f //destruction de a@"int f(int)" //continuation de l'évaluation de return f(a); return temp;
Si tu avais choisis une structure comme argument, ca ferai pareil:
à l'appel de la fonction, une structure est créée, en copiant celle passée en argument.
à la sortie de l'appel de la fonction, la structure copiée est détruite (puisque c'était une temporaire pour l'appel de la fonction).
Code:

1 2 3 4 5 6 7 8 9 struct Bidule {int valeur;} int f (struct Bidule a) {return 2*a.valeur;} int main(void) { struct Bidule a = {2;} return f(a); }
Dans ce code, en appelant f(a), on crée un Bidule temporaire, copie de a trouvé dans main.

C'est à ce moment là qu'on risque de te parler de pointeur, de passage par référence, et de pointeur vers une constante.
L'idée sera de ne pas copier la structure, mais d'utiliser directement son adresse en mémoire.

Mais la encore, c'est un détail pour cette explication. Tu en auras par contre besoin si tu veux pouvoir modifier la structure de l'appelant depuis la fonction appelée.