Modification d'un tableau à 2 dimensions via un pointeur dans une fonction void

Version imprimable

Bonjour à tous et à toutes !

J'ai commencé un bachelier en informatique en cours du soir et dans le cadre d'initiation à la programmation, nous avons un petit projet à faire en langage C.
Je vous explique en grandes lignes ..

On doit faire un jeux 2D en console qui représente +- la légende de Thésée. Le principe est simple:

Le jeu se passe dans un labyrinthe de 21 case sur 21. Trois personnage sont présent : Thésée, le Minotaure et Ariane (la princesse).
Le but est pour Thésée de rejoindre la princesse et pour le Minotaure d'attraper Thésée.

On doit faire un jeux avec la possibilité de jouer seul et à deux joueur.
Pour le mode solo, on doit pouvoir avoir le choix entre 2 niveau de difficulté.

Le premier niveau de difficulté permet de jouer avec un Minotaure immobile.
Et le deuxième avec un Minotaure qui nous pourchasse.

Pour le moment notre prof ne nous a donner que 1 labyrinthe. J'ai fait du coup des fonction uniquement avec ce labyrinthe mais il faut s'imaginer que par la suite d'autre se rajouteront dans mes paramètre de fonction ainsi que dans mes switch.

Je vous met ici mon main.c duquel je lance le programme faisant appel à plusieurs fonctions situé dans d'autres fichiers ".c"

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
 
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <windows.h>
#include <string.h>
#include "menuF.h"
#include "menuAf.h"
#include "fonction.h"
#define Taille_Grille_X 21
#define Taille_Grille_Y 21
 
 
int main()
{
    char nomThesee[20] = {"Thesee"}, nomAriane[20] = {"Ariane"};
    int choixDep, choixLab, choixPara, hero = 4; // Les variable commençant par choix sont les variables des menus, hero est le chiffre qui sera attribué au dernier héro en commençant à 2
    int labSel[Taille_Grille_X][Taille_Grille_Y] = {{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0}};
    int lab1[Taille_Grille_X][Taille_Grille_Y] = {{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}, // Déclaration de mon tableau de dimension 21 x 21
        {1,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1}, // avec les valeurs du labyrinthe 1
        {1,0,1,0,1,1,1,0,1,1,1,0,1,0,1,1,1,1,1,0,1},
        {1,0,1,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,1},
        {1,0,1,1,1,1,1,1,1,0,1,1,1,0,1,0,1,0,1,0,1},
        {1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,1,0,1},
        {1,1,1,1,1,0,1,1,1,0,1,1,1,0,1,1,1,0,1,0,1},
        {1,0,0,0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,1},
        {1,0,1,0,1,1,1,0,1,1,1,0,1,0,1,0,1,1,1,0,1},
        {1,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1},
        {1,0,1,1,1,0,1,1,1,0,1,1,1,0,1,0,1,1,1,1,1},
        {1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1},
        {1,1,1,0,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1},
        {1,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,1},
        {1,0,1,1,1,0,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1},
        {1,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,1,0,1},
        {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,1,1,0,1,0,1},
        {1,0,1,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,1,0,1},
        {1,0,1,0,1,0,1,1,1,1,1,0,1,0,1,1,1,0,1,0,1},
        {1,0,1,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,1},
        {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
    };
    do// Cette boucle permet de sortir du menu uniquement si on a choisi un joueur ou deux joueur, ce qui nous permettra de continuer le jeu
    {
 
        choixDep = menuDep(); // Fait appelle à la fonction menuDep qui renvoi le choix du menu Principale ( Voir menuAf.C )
        switch (choixDep) // fais un switch en fonction du choix dans le menu principale
        {
            case 1: // Choix joueur 1
            {
                system("CLS");
                printf("==============-------- 1 JOUEUR --------==============\n");
                printf("\n");
                choixLab =menuLab(lab1); // Fait appelle à la fonction qui permet de choisir un laby qui renvoi un entier stocker ( Voir menuAf.c)
                switch (choixLab) // fais un switch en fonction du labyrinthe
                {
                case 1: // Choix du premier labyrinthe
                {
                    remplLab(lab1,labSel,Taille_Grille_X,Taille_Grille_Y); // permet de remplacer la bariable labSel qui sera ensuite utilisé comme labyritnthe pendant le jeu
                    printf("Le labyrinthe choisi est le suivant :");
                    printf("\n");
                    printf("\n");
                    afficheLab(labSel,Taille_Grille_X,Taille_Grille_Y); // Affiche le labyrinthe séléctionné.
                }
                break;
                }
            }
            break;
            case 2:
            {
                system("CLS");
                printf("==============-------- 2 JOUEUR --------==============\n");
                printf("\n");
                choixLab =menuLab(lab1); // Fonction menuLab permet selectionner le labyrinthe et de stocker cette valeur dans une variable qu'on switchera ensuite comme au case 1
            }
            break;
            case 3:
            {
                system("CLS");
                do // Cette boucle permet de sortir du menu uniquement si on a choisi l'option quitter
                {
                    choixPara = menuPara(); // Fait appele a la fonction menuPara() qui renvoie un entier permettant de choisir dans le menu
                    switch (choixPara) // Switch sur le choix para pour le choix.
                    {
                    case 1: // Choix de changer le nom du héro Thésée
                    {
                        system("CLS");
                        modifNom(nomThesee, 20); // Permet de modifier le nom du héro via une fonction void ( voir menuF.c )
                        system("CLS");
                    }
                    break;
                    case 2 : // Choix de changer le nom de la princesse Ariane
                    {
                        system("CLS");
                        modifNom(nomAriane, 20); // Permet de modifier le nom du héro via une fonction void ( voir menuF.c )
                        system("CLS");
                    }
                    break;
                    case 3: // Choix de quitter
                        break;
                    }
                }while (choixPara != 3);  // Cette boucle permet de sortir du menu uniquement si on a choisi l'option quitter
                break;
            }
            case 4: // Choix Aide
            {
                system("CLS");
                menuAide(); // Affiche le menu aide suivi d'une pause (voir menuAf.c )e
            }
            break;
 
        }
    }while (choixDep >= 3); // Cette boucle permet de sortir du menu uniquement si on a choisi un joueur ou deux joueur, ce qui nous permettra de continuer le jeu
 
 
 
 
 
        return 0;
    }

[CODE]

Je vais aussi vous mettre le code de ma fonction void affichLab qui fonctionne

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
 
void afficheLab(int (*laby)[21], int l, int c) // *laby est le pointeur de mon tableau, l mon nombre de ligne et c mon nombre de colonnes
{
int i, j;
char asc = 219;
    for (i = 0; i < l; i ++) // Cette double boucle va me permettre d'afficher mon tableau et de remplacer les '1' par des blocks
    {
        for (j = 0; j < c; j ++)
        {
            if (laby[i][j] == 1) // Permet de remlacer les 1 par des blocks
            {
                printf("%c", asc); // remplace les 1 par de blocks
            }
            else if (laby[i][j] == 2)
            {
                printf("%c", 'M');
            }
            else if (laby[i][j] == 3)
            {
                printf("%c", 'T');
            }
            else if (laby[i][j] == 4)
            {
                printf("%c", 'A');
            }
            else
                printf(" "); // remplace les 0 par des espaces
        }
        printf("\n"); // permet de mettre à la ligne après chaque ligne de mon tableau.
    }
}

Il faut savoir que cette fonction va me permettre d'afficher en fonction des valeurs des cases de mon tableau des lettres correspondantes à mes héros.

La fonction qui bloque est la fonction , qui est censé remplacer le labyrinthe qu'on utilisera dans le jeu par le labyrinthe seléctionner dans la fonction menuLab.
Quand je lance le programme, c'est au moment ou j'arrive à ce switch remplLab case 1 ligne 55 dans main

Citation:

Que le programme cesse de fonctionner

Voici la Dite fonction :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
void remplLab(int *(labX)[21], int *(labSel)[21],int tailleX,int tailleY) // permet de remplacer le labyrinthe qui va etre lancé
                                                            //  par celui qu'on a selectionné
{
    int i, j;
    for (i = 0; i < tailleX; i ++) // Permet de selectionner ligne par ligne
    {
        for (j = 0; j < tailleY; j ++)// permet selectionner colonne par coonne à l'interieur de chaque ligne
            labSel[i][j] = labX[i][j]; // Remplace la valeur du labSel ( utilisé dans le jeu) par le labX ( lab choisi dans le menuLab)
    }
}

Voila, si quelqu'un saurai m'aider, ce serai cool.

Je vais mettre le projet complet en lien dropbox (j'arrive pas à le joindre) au cas ou quelqu'un veut y jeter un oeil pour mieux comprendre.

Voici le code d'une autre fonction ( mon srand se trouve dans le main ) qui fait planter le programme de la même manière quand je la lance sans le reste du code.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
void positionHero(int *(labSel)[21], int l, int c, int hero) // Cette fonction permet de positionner les héros ( Thesee, Mino et Ariane dans le laby
{ // La valeur de héro est 4 par défaut
    int x, y,i;
    for (i = 2; i <= hero ; i ++) // La valeur de défaut va permettre de remplacer les 0 par 1 '2', 1 '3' et 1 '4' Qui representeront les 3 héros.
    {
        do
        {
           x = (rand() % (l - 0 + 1)); // La fonction rand me permet de générer un nombre aléatoire qui sera stocker
           y = (rand() % (l - 0 + 1));
           if (labSel[x][y] == 0)
                labSel[x][y] = hero; // Les nombres aléatoires seront ensuite utilisé pour sélectionner une case du tableau aléatoirement.
        }while (labSel[x][y] !=hero); // Cette boucle me permet d'être sur que le héro ai sa position.
    }
}

J'imagine que le problème doit avoir la même origine.

Je vous remercie déja si vous avez lu tout ça, et si vous savez m'aider je vous remercierai d'avantage !

PS : Si vous compilez le programme, pour arriver au message d'erreur, il faut choisir le mode 1 joueur et puis sélectionner un labyrinthe de 1 à 7 ( bien qu'il y en ai que deux qui sont les même )

LIEN FICHIER : https://www.dropbox.com/s/oc22759v1v...taure.zip?dl=0

Les types des arguments que tu fournis à remplLab ne correspondent pas à sa signature. Ton compilateur devrait t'en informer, sois sûr d'activer tous les avertissements, ou warnings (et si tu n'en as toujours aucun alors change de compilateur). Ne survole pas un warning, c'est la plupart du temps une conséquence d'une erreur de programmation.

Tu donnes à remplLab un tableau de tableau d'int mais la fonction l'indexe comme un tableau de pointeurs d'int. Désormais lorsque tu écris labX[0][2], tu ne références plus le troisième int du premier tableau de labX mais l'int se trouvant à l'adresse déduite du contenu de labX[0], plus deux fois sizeof(int).

Pointeurs et tableaux sont des objets différents en C.

Voici un exemple qui illustre les conséquences de chaque type de déclaration sur l'indexation de tableaux avec le type char pour simplifier (on suppose une machine 64-bit où sizeof(char *) == 8) :
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 char tab[N][3]; 0 1 2 3 4 5 6 7 8 +---+---+---+---+---+---+---+---+---+-- | | | | | | | | | | ... +---+---+---+---+---+---+---+---+---+-- ^ ^ ^ ^ | | | | tab[0] | tab[1] tab[2] | tab[0][2] char *tab[N]; 0 1 2 3 4 5 6 7 8 +---+---+---+---+---+---+---+---+---+-- | | | | | | | | | | ... +---+---+---+---+---+---+---+---+---+-- ^ ^ | | tab[0] tab[1] ^ ^ | | +--------------+----------------+ 0 1 2 3 | --+---+---+---+---+-- +-------------------------> ... | | | | | ... --+---+---+---+---+-- ^ ^ | | *(tab[0] + 0) ou tab[0][0] | | tab[0][2]
TL;DR : essaie avec ce prototype void remplLab(int labX[21][21], int labSel[21][21], int tailleX, int tailleY).

En ce qui concerne la deuxième fonction, je ne me suis pas attardé dessus car elle est écrite de façon très brouillonne. Tu y as mis des choses dont tu ne te sers pas encore et la condition d'arrêt de ta boucle while est vraiment bancale. Réécris-la entièrement et tu y verras plus clair je pense. ;)

Citation:

Envoyé par kraoui

Je vous remercie déja si vous avez lu tout ça

Merci à toi, un sujet correctement présenté de temps en temps, ça fait toujours plaisir.

16/12/2015, 14h27
kraoui

Merci pour ta réponse ! Grâce à toi j'ai pu comprendre d'ou venait mon erreur et en modifiant mon code comme tu me l'a conseillé, ça fonctionne ! :mrgreen:

Il y a une petite chose que je ne comprend par contre pas ...
Comment ce fait-il alors que ma fonction affichLab fonctionne alors ? Car au niveau des arguments, je les avais déclarer plus ou moins de la même manière.
Est-ce dû au fait que je ne change rien à mon pointeur et que je me contente d'afficher ma fonction et non pas modifier les valeurs de mon tableau ?

Autre question :

Quand je déclare ma fonction, est- ce que je suis obliger de déclarer la taille de mon tableau ou je peux laisser des [] vides ?

Citation:

Envoyé par Matt_Houston

En ce qui concerne la deuxième fonction, je ne me suis pas attardé dessus car elle est écrite de façon très brouillonne. Tu y as mis des choses dont tu ne te sers pas encore et la condition d'arrêt de ta boucle while est vraiment bancale. Réécris-la entièrement et tu y verras plus clair je pense. ;)

Merci à toi, un sujet correctement présenté de temps en temps, ça fait toujours plaisir.

J'avais fais des erreurs dans ma fonctions en effet, j'ai suivi tes conseils et je l'ai réécrite et elle fonctionne :).

Encore merci pour ton aide !

Hello, concernant la première fonction : elle existe déjà, ne t’embête pas à la recréer.

Comme @Matt_Houston le fait remarquer tes tableaux sont contigües en mémoire. Tu peux utiliser ça à ton avantage.

Code:

1
2
3
void remplLab(int labX[21][21], int labSel[21][21]) { // la taille est données dans le type, pas besoin de la redonner via les paramètres x / y
	memcpy(labX, labSel, sizeof(int) * 21 * 21); // éventuellement un warning ici à faire taire avec un cast
}

Quand à la 2eme fonction, peut être quelque chose du genre ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
void positionHero(int labSel[21][21], int hero) // Cette fonction permet de positionner les héros ( Thesee, Mino et Ariane dans le laby
{ // La valeur de héro est 4 par défaut
	int x, y, i;
	for (i = 2; i <= hero; i++) // La valeur de défaut va permettre de remplacer les 0 par 1 '2', 1 '3' et 1 '4' Qui representeront les 3 héros.
	{
		do
		{
			x = (rand() % 21); // a-t-on besoin de l / c ? Si on cherche à les placer sur la grille complète
			y = (rand() % 21); // alors on à déjà sa taille (via son type)
		} while (labSel[x][y] == 0);
		labSel[x][y] = i; // i au lieu de hero, sinon on place tout le temps le même nombre
	}
}

Mais tes 2 problèmes viennent du fait que int[21][21] != int*[21].

Citation:
Envoyé par Iradrille
Code:

1 2 3 void remplLab(int labX[21][21], int labSel[21][21]) { // la taille est données dans le type, pas besoin de la redonner via les paramètres x / y memcpy(labX, labSel, sizeof(int) * 21 * 21); // éventuellement un warning ici à faire taire avec un cast }
Je ne connais pas encore la fonction memcpy, mas c est vrai que ça à l'air de pas mal simplifier ma fonction :P, je me pencherai dessus :mouarf:
Citation:
Envoyé par Iradrille
Quand à la 2eme fonction, peut être quelque chose du genre ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 void positionHero(int labSel[21][21], int hero) // Cette fonction permet de positionner les héros ( Thesee, Mino et Ariane dans le laby { // La valeur de héro est 4 par défaut int x, y, i; for (i = 2; i <= hero; i++) // La valeur de défaut va permettre de remplacer les 0 par 1 '2', 1 '3' et 1 '4' Qui representeront les 3 héros. { do { x = (rand() % 21); // a-t-on besoin de l / c ? Si on cherche à les placer sur la grille complète y = (rand() % 21); // alors on à déjà sa taille (via son type) } while (labSel[x][y] == 0); labSel[x][y] = i; // i au lieu de hero, sinon on place tout le temps le même nombre } }
Pour le fonction permettant de donner un nombre aléatoire.
Code:

1 2 srand(time(NULL)); nombreMystere = (rand() % (MAX - MIN + 1)) + MIN;
J'avais repérer mon erreur du hero à remplacer par le i. J'avais écris le code rapidement.
Par contre dans celui qui tu me propose, le problème est que il va arrêter de générer des nombres aléatoire que quand il va tomber sur un mur ( '1') de mon labyrinthe et va remplacer celui-ci par la valeur du héro.

Voic la nouvelle fonction que j'ai taper et qui fonctionne bien :) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 void positionIni(int labSel[21][21],int hero) // Cette fonction permet de positionner les héros ( Thesee, Mino et Ariane dans le laby { // La valeur de héro est 4 par défaut int x, y,i; for (i = 2; i <= hero ; i ++) // La valeur de défaut va permettre de remplacer les 0 par 1 '2', 1 '3' et 1 '4' Qui representeront les 3 héros. { do { x = (rand() % (21+ 1)); // La fonction rand me permet de générer un nombre aléatoire qui sera stocker y = (rand() % (21+ 1)); if (labSel[x][y] == 0) labSel[x][y] = i; // Les nombres aléatoires seront ensuite utilisé pour sélectionner une case du tableau aléatoirement. }while (labSel[x][y] != i); // Cette boucle me permet d'être sur que le héro ait sa position. } }
Grâce à ce code j'ai bien mes trois héros ( '2', '3', '4') qui sont placés dans le Labyrinthe.

Citation:

Envoyé par Iradrille

Mais tes 2 problèmes viennent du fait que int[21][21] != int*[21].

Oui :). Et justement d'ou ma question : Es ce que je peux déclarer les paramètres dans ma fonction sans donner la taille du tableau ?
du style : void exemple(int tabl2Dim[][],int para2)
Encore merci pour la rapidité de vos réponse :).

Je suis nouveau sur le forum et je suis agréablement surpris de l'entraide qu'il y a ici !

J'espère qu'un jour je pourrai à mon tour aider les débutants dans mon genre :P.

16/12/2015, 16h09
kraoui

En faite Bizarement, les nombres générés ne sont pas aléatoire.

Mes Héros sont à chaque fois placés au même endroit ...
Voici ma ligne de code :
x = (rand() % (21 - 0+ 1+ 0));
Je me suis vraiment basé sur cette ligne

nombreMystere = (rand() % (MAX - MIN + 1)) + MIN;
16/12/2015, 16h15
ternel

Tu as du raté d'appeler srand() avec une valeur changeante (comme time(NULL)).
16/12/2015, 16h28
Iradrille

Citation:

Envoyé par kraoui

Voici ma ligne de code :
x = (rand() % (21 - 0+ 1+ 0));
Je me suis vraiment basé sur cette ligne

nombreMystere = (rand() % (MAX - MIN + 1)) + MIN;

Ça semble faux.

nombreMystere = (rand() % (MAX - MIN + 1)) + MIN; -> c'est bon, mais ici min = 0, max = 20; donc nombreMystere = (rand() % (20 - 0 + 1)) + 0;, ou plus simplement n = rand() % 21;.

21 cases qui sont numérotées de 0 à 20. :)
16/12/2015, 17h08
kraoui

Citation:

Envoyé par leternel

Tu as du raté d'appeler srand() avec une valeur changeante (comme time(NULL)).

Je pensais l'avoir mit dans ma main.c mais tu as raison, il était manquant ... J'ai tellement modifié le programme que j'ai du l'enlevé à un moment :P

Citation:

21 cases qui sont numérotées de 0 à 20.

Merci ...:roll: je suis un peu distrait des fois :P.

Un candidat pour répondre à ma question que je traîne depuis 3 post :P ?

Est ce que je peux déclarer les paramètres dans ma fonction sans donner la taille du tableau ?
du style : void exemple(int tabl2Dim[][],int para2)

EDIT : ça fonctionne bien après vos précieuses indications :)

Merci pour vos réponses en tout cas ! Franchement ça me fait me rendre compte de pas mal d'erreurs que je commet et ça me fait beaucoup avancer :).