Petit soucis avec un tableau de structures

Version imprimable

1 pièce(s) jointe(s)

Bonjour,

Mon programme a pour but de distribuer des chiffres à deux personnes. Ces deux personnes les reçoivent chacune leur tour.

Le problème est que j'ai l'impression que la main de la première personne écrase celle de la seconde.

Un problème d'allocation mémoire peut être ...
Je suis un peu perdu, un peu d'aide ne serais pas de refus :)

Voila 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
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
#include <stdio.h>
#include <stdlib.h>
 
#define SBUFF 1024
 
 
struct total{
 
int nbchiffre;
char * chiffre[];
 
};
 
 
struct tirer{
 
int nbchiffre;
char * chiffre[];
 
};
 
int main(){
/* Initialisation des différentes variables */
struct total * base;
base = malloc((sizeof(struct total) + sizeof(char**)) * SBUFF);
 
struct tirer * main;
main = malloc((sizeof(struct tirer) + sizeof(char**))*SBUFF);
 
int x = 0;
int k = 0;
int j,i,crt;
int nbtour = 0;
char buf[SBUFF];
srand(time(NULL));
 
 
base->nbchiffre = 13;
 
 
	base->chiffre[0] = "0";
	base->chiffre[1] = "1";
	base->chiffre[2] = "2";
	base->chiffre[3] = "3";
	base->chiffre[4] = "4";
	base->chiffre[5] = "5";
	base->chiffre[6] = "6";
	base->chiffre[8] = "8";
	base->chiffre[9] = "9";
	base->chiffre[9] = "9";
	base->chiffre[10] = "10";
	base->chiffre[11] = "11";
	base->chiffre[12] = "12";
	base->chiffre[13] = "13";
 
 
 
 
 
while(x<6){
 
		crt = rand() % base->nbchiffre;
 
/* Je met le chiffre choisie dans la main du joueur k */
		main[k].chiffre[x]=base->chiffre[crt];
 
/* Je supprime le chiffre tiré de l'ensemble et je réduit ce dernier */
		base->chiffre[crt] = '\0';
		for(j=crt;j<base->nbchiffre;j++)
		base->chiffre[j] = base->chiffre[j+1];
		base->nbchiffre--;
 
/* J'affiche ce qui se trouve dans la main k */
		for(i=0;i<6;i++)
			printf("%s | ",main[k].chiffre[i]);
		printf("\n");
 
/* On passe à la main suivante */
k=1;
nbtour++;
 
/* Si les deux mains ont tiré un chiffre alors je repasse à la première main
	et je met le prochain chiffre à x+1 */
if( nbtour%2 == 0){
k=0;
x++;
printf("\n");
}
}
 
return 0;
}

22/04/2013, 13h19
Metalman

Hmmm... j'ai du mal à voir en effet où est-ce que tu changes de joueur...

Tu devrais faire une fonction qui rempli une main, et tu lui donnes en paramètre chaque joueur pour lui remplir sa main.

La logique sera déjà un peu mieux ! :)
22/04/2013, 13h59
kwariz
Bonjour,

Plusieurs remarques :
- Ce n'est jamais le bon plan d'appeler une variable main en ayant une fonction qui s'appelle main aussi. Le compilateur ne fera la différence entre main=[min] et main=[mè-hinne] :)
- Encore une «erreur» qui n'en est pas une. Quand tu utilises un tableau flexible il faut allouer de la place pour les éléments pas pour le tableau en lui-même : ce n'est pas un sizeof(char**) que tu devrais utiliser mais un sizeof(char*). C'est sans conséquence ici car la taille d'un pointeur ne varie pas suivant le type pointé.
- Ensuite une erreur plus grave. Tu n'alloues qu'une main avec main = malloc((sizeof(struct tirer) + sizeof(char**))*SBUFF); et tu utilises main[k] avec k=0 ou 1 suivant le joueur -> erreur
  Mais le problème est plus complexe car un tableau doit contenir des éléments de même taille or on ne peut avec sizeof déterminer la taille réelle d'un struct avec un flexible member array car le sizeof ne renverra jamais que la taille de lastruct en elle-même pas de ce que tu as sur-alloué pour les éléments du tableau. Finalement ici ça ta complique la vie car en arithmétique des pointeurs la taille du type qui est pointé compte.
Conseil : pour suivre l'avis de metalman, crée des fonctions dédiées à la création/initialisation/modification/libération des types que tu vas manipuler. Dans ton struct utilise plutôt un char** que tu vas allouer à part plutôt qu'un char* []. Change le nom de ta variable main et déclare la réellement en tableau.

Merci, j'ai résolue mon problème, j'ai alloué la mémoire de la façon suivante :
Code:

1 2 3 4 5 6 struct tirer joueur[3]; for(j=0;j<3;j++){ joueur[j].chiffre = (char**) malloc(sizeof(char*)*SBUFF); for(i=0;i<SBUFF;i++) joueur[j].chiffre[i] = (char *)malloc(sizeof(joueur->chiffre)+SBUFF); }
Je ne sais pas si j'ai allouer correctement la mémoire mais en tout cas ça marche.

La prochaine fois je ferais plus attention lorsque j'allouerais de la mémoire.

22/04/2013, 15h51
kwariz
Ce n'est certainement pas juste, et si ça semble fonctionner c'est un coup de bol. Si j'étais toi j'opterais pour un structure beaucoup plus simple :
Code:

1 2 3 4 5 #define MAX_CHIFFRE 1024 struct tirer { int nbchiffre; char* chiffre[MAX_CHIFFRE]; }
Les types struct total et struct tirer sont identiques : pas la peine a priori d'avoir des doublons.

Cela te permet de ne plus avoir besoin d'allocations dynamiques :
Code:

1 2 3 struct tirer base = {14, {"0", "1", "2", ... "13"}}; // tu remplaces les ... par ce qu'il faut struct tirer joueur[3]; etc ...
sauf peut-être quand tu va donner des valeurs à joueur[k].chiffre[c] ...

Bonne continuation et attention aux allocations (->faire un dessin aide toujours, ne jamais oublier que n éléments dans un tableau sont indicés de 0 à n-1, etc ...)