Discussion :

[Nestati]

Bonjour à tous, mon but est de mettre 52 cartes ( ou moins ) toutes différentes dans un fichier texte de la façon suivante "dame carreaux" à la ligne d'en dessous "neuf trefle" etc... mon problème est que je créer une carte aléatoire sous la forme d'une structure et je vérifie qu'elle n'est pas dans le fichier pour l'ajouter à la suite. Mon problème est que la fonction estDansFichier ne trouve aucune fois l'itération de la nouvelle carte alors qu'elle y est la plupart du temps. Je pense donc que ça vient du fait que carteatrouver et la lecture de la ligne n'est pas identique. Merci à vous. PS : J'ai mis que les fonctions utiles au problème et pas toutes celles se trouvant dans le .h
PS2: j'ai déjà essayé de rajouter ou non un "\n" à la fin de chaque str à comparer mais rien à faire ça ne fonctionne pas
Ici mon fichier .h

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
typedef struct {
 char nom[20] ;
 char couleur[20] ;
 int valeur;
} CARTE;
 
int initialiserCarteDe0(CARTE *pcarte);
void afficherCarte(CARTE *carte);
void sauverCarte(CARTE *carte, FILE *FICHIER);
void lireCarte(CARTE *pcarte, FILE *FICHIER);
void CreerJeuCartes(CARTE *pcarte,int taille, FILE *FICHIER);
int estDansFichier(FILE *FICHIER,char *carteatrouver);
void EffacerFichier();

Ici mon fichier .c

Code :

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

1
2
3
#include "carte.h"
char *nomcarte[13]={"deux","trois","quatre","cinq","six","sept","huit","neuf","dix","valet","dame","roi","as"};
char *couleurcarte[13]={"pique","carreaux","trefle","coeur"};

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
int main()
{
    CARTE *pcarte;
    FILE *FICHIER;
    srand (time (NULL));
    int choix;
    pcarte = (CARTE *) malloc (sizeof(CARTE));
    CreerJeuCartes(pcarte,52,FICHIER);
    free(pcarte);
}
void EffacerFichier(){
    FILE *fc;
    fc=fopen("sauve.txt","w");
    fclose(fc);
}
 
int estDansFichier(FILE *FICHIER,char *carteatrouver){
    FICHIER = fopen("sauve.txt", "r");
    char ligne[100];
    char chainecomp[20];
    strcpy(chainecomp,carteatrouver);
    strcat(chainecomp,"\n");
    int iteration=0;
    while(fgets(ligne, 100, FICHIER) != NULL){
        if(strcmp(ligne,chainecomp)==0){
            iteration++;
        }
    }
    return iteration;
}
void CreerJeuCartes(CARTE *pcarte,int taille,FILE *FICHIER){
    int i;
    srand (time (NULL));
    char * nomcarte=(char *)malloc(40);
    EffacerFichier();
    for(i=0;i<taille;i++){
 
        initialiserCarteDe0(pcarte);
        strcpy(nomcarte,pcarte->nom);
        strcat(nomcarte," ");
        strcat(nomcarte,pcarte->couleur);
        while((estDansFichier(FICHIER,nomcarte))!=0){
            initialiserCarteDe0(pcarte);
            strcpy(nomcarte,pcarte->nom);
            strcat(nomcarte," ");
            strcat(nomcarte,pcarte->couleur);
 
        }
        sauverCarte(pcarte,FICHIER);
    }
}
 
void sauverCarte(CARTE *carte, FILE *FICHIER){
    FICHIER = fopen("sauve.txt", "a");
    fprintf(FICHIER,"%s %s\n",carte->nom,carte->couleur);
}
 
int initialiserCarteDe0(CARTE *pcarte){
    strcpy((pcarte->couleur),couleurcarte[rand() % 4]);
    strcpy((pcarte->nom),nomcarte[rand() % 13]);
    return 0;
 
}

[Nestati]

Problème résolu , je n'avais pas fermé les fichiers avec fclose(FICHIER);

[Sve@r]

Bonjour

Problème résolu , je n'avais pas fermé les fichiers avec fclose(FICHIER);

Oui, enfin il n'y a pas que ça. Déjà ce while((estDansFichier(FICHIER,nomcarte) != 0) qui va tout relire ton fichier à chaque fois c'est super long. Pour 52 cartes ça se gère en RAM et l'écriture se fait une seule fois en final.
Et t'as sprintf() qui peut remplacer avantageusement tous tes strcpy() en rafale (remarque, pourquoi se fatiguer à recopier les chaines alors qu'on pourrait se contenter de recopier juste leurs adresses !!!) Et t'as truncate() qui te permet de mettre directement un fichier à 0 (quoique si tu ne l'écris qu'une seule fois comme je le conseille...). Et enfin pourquoi ce pcarte = (CARTE *) malloc (sizeof(CARTE)) ? Quand t'as besoin d'un "int i", est-ce que tu écris int *i=malloc(sizeof(int)) puis un free(i) au final ? Bon si c'est ton kif d'allouer de la RAM là où une simple variable suffit...

Sinon pourquoi t'as défini "couleurcarte" comme un tableau de 13 strings ? Il y a 13 couleurs dans ton jeu ??? Accessoirement l'ordre consensuel des couleurs, c'est "trèfle, carreau, coeur et pique" (enfin c'est l'ordre hiérarchique des couleurs au Bridge).

Code c :

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
81
82
83
84
85
86
87
88
89
90
91
92
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
typedef struct {
	char *nom;
	char *couleur;
} t_carte;
 
typedef struct {
	t_carte carte[52];
	size_t nb;
} t_jeu;
 
int cmpCarte(t_carte*, t_carte*);
size_t carteInJeu(t_carte*, t_jeu*);
void carteRandom(t_carte*);
 
void jeuInit(t_jeu*);
void jeuCreate(t_jeu*);
void jeuAffich(t_jeu*);
t_jeu* jeuSave(t_jeu*, char*);
 
int cmpCarte(t_carte *x, t_carte *y) {
	int r;
	r=strcmp(x->couleur, y->couleur);
	if (r) return r;
	return strcmp(x->nom, y->nom);
}
 
size_t carteInJeu(t_carte *c, t_jeu *j) {
	t_carte *pt;
	size_t i;
	for (i=1, pt=j->carte; i <= j->nb; i++, pt++) {
		if (cmpCarte(c, pt) == 0) return i;
	}
	return 0;
}
 
void carteRandom(t_carte *c) {
	static char *nomCarte[]={"deux","trois","quatre","cinq","six","sept","huit","neuf","dix","valet","dame","roi","as"};
	static char *couleurCarte[]={"pique","carreaux","trefle","coeur"};
 
	c->couleur=couleurCarte[rand() % 4];
	c->nom=nomCarte[rand() % 13];
}
 
void jeuInit(t_jeu *j) {
	j->nb=0;
}
 
void jeuCreate(t_jeu *j) {
	jeuInit(j);
 
	size_t i;
	for (i=0; i < 52; i++) {
		while (1) {
			carteRandom(&j->carte[i]);
			if (carteInJeu(&j->carte[i], j) == 0) break;
		}
		j->nb++;
	}
}
 
void jeuAffich(t_jeu *j) {
	t_carte *pt;
	size_t i;
	printf("Jeu: nb=%lu\n", j->nb);
	for (i=1, pt=j->carte; i <= j->nb; i++, pt++)
		printf("Carte [%lu/%lu]: %s de %s\n", i, j->nb, pt->nom, pt->couleur);
}
 
t_jeu* jeuSave(t_jeu *j, char *fic) {
	FILE *fp=fopen(fic, "w");
	if (fp == NULL) return NULL;
 
	t_carte *pt;
	size_t i;
	for (i=0, pt=j->carte; i < j->nb; i++, pt++)
		fprintf(fp, "%s de %s\n", pt->nom, pt->couleur);
	fclose(fp);
	return j;
}
 
int main() {
	t_jeu jeu;
 
	srand (time(NULL));
	jeuCreate(&jeu);
	jeuAffich(&jeu);
	jeuSave(&jeu, "toto");
}

Bon c'est pas super aléatoire car chaque nouvelle carte ajoutée réduit le champ des cartes possibles (le tirage n'est donc pas équiprobable). En théorie, il faudrait tirer les 52 cartes et recommencer tant qu'il y a doublon mais ce serait plus long à sortir...

[Nestati]

Merci beaucoup pour ta réponse, en effet pour régler le problème d'ouverture à multiples reprises j'avais pensé faire un tableau de structure..
J'ai deux petites questions concernant le programme que vous m'avez transmis :
-Pourquoi créer une fonction jeuSave qui retourne le fichier ?
-Cautionnez vous le break dans un while(1) ? On m'a appris cette année que ce n'était pas terrible

[Sve@r]

Merci beaucoup pour ta réponse, en effet pour régler le problème d'ouverture à multiples reprises j'avais pensé faire un tableau de structure..

Eh ben voilà, c'est aussi comme ça que j'ai pensé. Franchement, utiliser un fichier pour voir si un truc existe ou n'exite pas c'est super long. Eventuellement le truc se serait compté en millions d'infos ok mais pour 52...

-Pourquoi créer une fonction jeuSave qui retourne le fichier ?

Il me fallait retourner une valeur spéciale indiquant que le jeu n'avait pas pu être sauvegardé. J'ai donc opté pour le pointeur NULL. J'aurais pu opter aussi pour -1 qui est le standard des fonctions bas niveau donc ce n'est qu'une question de choix. Par opposition il me fallait en retour un pointeur non nul => le fichier. Mais à la réflexion, c'est vrai que retourner ce pointeur fichier devenu inutilisable à sa fermeture c'est pas terrible donc je viens de changer mon code. Maintenant la fonction retourne le pointeur jeu.

-Cautionnez vous le break dans un while(1) ? On m'a appris cette année que ce n'était pas terrible

Arf, la théorie scolaire !!! Ce que je pense c'est que s'il existe des outils, c'est aussi pour qu'ils soient utilisés. Et si on les utilise dans les circonstances pour lesquels ils ont été créés alors c'est ok. Aucun outil n'est mauvais par lui-même et tout prof qui te dirait le contraire serait un des pire profs qui soit car il ne t'appendrait pas à réfléchir par toi-même (son vrai rôle) mais tenterait juste de te formater comme lui. Ce qui est néfaste, ce n'est pas le break (ni le continue, ni le goto) en lui-même, c'est le break (ou continue ou goto) mal utilisé ou rendant alors un programme plus illisible qu'il ne l'est. Ce sera à toi de décider si tel outil est ou n'est pas adapté à la situation. Tu auras même le droit de te tromper, ce n'est pas grave. Ce qui serait grave c'est de dire d'avance "ça c'est mauvais je ne dois pas l'utiliser".

Et (ici) il y a aussi le poids de l'habitude (j'ai trouvé plus simple de dire "je répête à l'infini et si je trouve un cas où je peux sortir alors je sors"). Mais si tes profs sont contres, alors il ne faut pas les heurter (tu auras pas souvent raison). Donc la même fonction sans le break...

Code c :

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

1
2
3
4
5
6
7
8
9
10
11
12
void jeuCreate(t_jeu *j) {
	jeuInit(j);
 
	size_t i;
 
	for (i=0; i < 52; i++) {
		do {
			carteRandom(&j->carte[i]);
		} while (carteInJeu(&j->carte[i], j) != 0);
		j->nb++;
	}
}

Ensuite, tu pourras leur proposer les deux versions et leur demander leur avis sur, dans ce cas précis, l'utilisation du break (les profs aiment bien quand on leur demande leur avis)...

[Nestati]

D'accord merci beaucoup je comprends mieux en retournant un pointeur non NULL dans ce cas.
Je vais opter pour le while sans break, mes profs d'algorithmique ne veulent pas entendre parler d'un break/goto/continue ahah.
Le but de ce TP étant de faire un jeu de carte de notre choix au final. J'ai opté pour une bataille contre un bot, donc diviser le tableau mélangé en deux et faire deux sous tableaux "jeu joueur" et "jeu bot" et tirer les cartes au fur à mesure et remplir un tableau et vider l'autre en fonction de la valeur des cartes.

[Sve@r]

mes profs d'algorithmique ne veulent pas entendre parler d'un break/goto/continue ahah.

C'est tellement triste ces profs qui ont oublié qu'enseigner c'est avant tout apprendre à réfléchir par soi-même et qui assènent leur vérité du haut de leur piédestal inaccessible. C'est tellement... stalinien !!!
Accessoirement en général ils ne veulent pas non plus de return au milieu d'une fonction (fonction cmpCarte(), carteInJeu() et jeuSave()...)

Le but de ce TP étant de faire un jeu de carte de notre choix au final. J'ai opté pour une bataille contre un bot, donc diviser le tableau mélangé en deux et faire deux sous tableaux "jeu joueur" et "jeu bot" et tirer les cartes au fur à mesure et remplir un tableau et vider l'autre en fonction de la valeur des cartes.

Hum... dans ce cas il y aura à un moment donné une étape "comparaison de carte". Et comment pourras-tu dire "le quatre vaut plus que le trois" ???
C'est possible bien entendu (tout est toujours possible quand on est face à un problème qu'on peut résoudre avec un papier et un crayon) mais ce sera... chiant (faudra tout gérer terme par terme).
Donc là, moi je partirais sur une autre approche: remplacer les valeurs littérales ("deux", "trois", etc) par des valeurs numériques et utiliser ces valeurs lors des calculs internes. Et seulement lors de l'affichage (ou de l'enregistrement dans le fichier) remplacer la valeur numérique par la valeur littérale. C'est d'ailleurs la base de la programmation MVC (séparer le Modèle, la façon dont on stocke et organise les données, de la Vue, la façon dont on les voit et du Contrôleur, la façon dont on les gère et utilise).

Et justement, comme j'ai bien tout séparé, la modif n'est pas super compliquée à faire. Suffit de rajouter un élément "valeur" dans la structure carte, puis ensuite l'utiliser partout où j'utilisais le nom. Tout en laissant le nom pour pouvoir l'afficher au bon moment
Ensuite on met un peu de const là où les choses sont constantes, on met un petit peu de pointeur partout où il y a des crochets (optimisation) on remplace "j" et "c" par "jeu" et "carte" (faut pas oublier que j'ai tapé le premier jet hier soir entre la poire et le fromage !!!) bref on commence à programmer un vrai projet dans les règles de l'art. Ce qui donne...

Code c :

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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
 
typedef struct {
	unsigned short valeur;
	char *couleur;
	char *nom;
} t_carte;
 
typedef struct {
	t_carte carte[52];
	size_t nb;
} t_jeu;
 
int carteComp(const t_carte* const, const t_carte* const);
size_t carteInJeu(const t_carte* const, const t_jeu* const);
void carteRandom(t_carte* const);
 
void jeuInit(t_jeu* const);
void jeuCreate(t_jeu* const);
void jeuAffich(const t_jeu* const);
t_jeu *jeuSave(const t_jeu* const, const char* const);
 
int carteComp(const t_carte* const x, const t_carte* const y) {
	int r;
	r=strcmp(x->couleur, y->couleur);
	if (r != 0) return r;
	return x->valeur - y->valeur;
}
 
size_t carteInJeu(const t_carte* const carte, const t_jeu* const jeu) {
	const t_carte *pt;
	size_t i;
	for (i=1, pt=jeu->carte; i <= jeu->nb; i++, pt++) {
		if (carteComp(carte, pt) == 0) return i;
	}
	return 0;
}
 
void carteRandom(t_carte* const carte) {
	static char *couleur[]={"trefle", "carreau", "coeur", "pique"};
	static char *nom[]={"deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf", "dix", "valet", "dame", "roi", "as"};
 
	//carte->couleur=couleur[rand() * 4 / RAND_MAX];
	//carte->valeur=rand() * 13 / RAND_MAX;
	carte->couleur=couleur[rand() % 4];
	carte->valeur=rand() % 13;
	carte->nom=nom[carte->valeur];
}
 
void jeuInit(t_jeu* const jeu) {
	jeu->nb=0;
}
 
void jeuCreate(t_jeu* const jeu) {
	jeuInit(jeu);
 
	size_t i;
	t_carte *pt;
 
	for (i=0, pt=jeu->carte; i < 52; i++, pt++) {
		do {
			carteRandom(pt);
		} while (carteInJeu(pt, jeu) != 0);
		jeu->nb++;
	}
}
 
void jeuAffich(const t_jeu* const jeu) {
	const t_carte *pt;
	size_t i;
	printf("Jeu: nb=%lu\n", jeu->nb);
	for (i=1, pt=jeu->carte; i <= jeu->nb; i++, pt++)
		printf("Carte [%lu/%lu]: (%hu) %s de %s\n", i, jeu->nb, pt->valeur+1, pt->nom, pt->couleur);
}
 
t_jeu *jeuSave(const t_jeu* const jeu, const char* const fic) {
	FILE *fp=fopen(fic, "w");
	if (fp == NULL) return NULL;
 
	const t_carte *pt;
	size_t i;
	for (i=0, pt=jeu->carte; i < jeu->nb; i++, pt++)
		fprintf(fp, "%s de %s\n", pt->nom, pt->couleur);
	fclose(fp);
	return (t_jeu*)jeu;
}
 
int main() {
	t_jeu jeu;
 
	srand(time(NULL));
	jeuCreate(&jeu);
	jeuAffich(&jeu);
	jeuSave(&jeu, "toto");
}

Pour la suite tu devrais y arriver seul. N'oublie pas, de petites fonctions simples ne faisant qu'une chose mais la faisant bien. Que tu pourras ensuite utiliser comme autant de petites briques.

[Nestati]

C'est ce que je pensais faire en effet merci beaucoup de ton aide.
Je reviendrais si je suis face à un problème...

[Nestati]

Le programme associe une carte admettons le dix a une valeur de 9 le six à une valeur de 5 etc.
en changeant cette ligne ci on affiche bien la bonne valeur :

Code :

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

printf("Carte [%lu/%lu]: (%hu) %s de %s\n", i, jeu->nb, pt->valeur+2, pt->nom, pt->couleur);

cependant j'ai peur que dans la structure la valeur associée ne soit pas la bonne
PS: je viens de me rendre compte que c'était pas très grave pour la comparaison de toute façon...

Autre petite question, je vois que tu utilises souvent des static ou des const devant les variables, je n'ai jamais appris à rajouter ça. Quelle est l'utilité ? Merci bcp

[Sve@r]

en changeant cette ligne ci on affiche bien la bonne valeur :

Ah ? Parce que pour toi, la bonne valeur pour le (par exemple roi) c'est 13 ? Et pourquoi ce ne serait pas 57 ???

PS: je viens de me rendre compte que c'était pas très grave pour la comparaison de toute façon...

Exactement. On s'en fout si le roi vaut 13 ou 57 ou 872, l'important c'est que la dame vaille moins que lui mais plus que le valet.

Autre petite question, je vois que tu utilises souvent des static ou des const devant les variables, je n'ai jamais appris à rajouter ça. Quelle est l'utilité ?

"const" si tu ne sais pas alors tu peux l'enlever, c'est pas grave. En écrivant par exemple void jeuAffich(const t_jeu* const jeu) j'indique que le pointeur "jeu" est invariable (interdit dans la fonction d'écrire jeu=NULL par exemple), ainsi que son pointé (interdit d'acrire alors jeu->nb=53). C'est une façon de me protéger contre une erreur d'écriture (si je tente de modifier le pointeur ou le pointé, le compilo me préviendra).
Attention au sens de lecture. Pour dire que "jeu" est invariable, c'est le second const. Pour dire que le pointé est invariable, c'est le premier. En fait, chaque "const" ne s'applique qu'à ce qui le suit.
Mais ce n'est pas vraiment nécessaire. C'est juste la partie "fangio" du code.

En revanche, "static" (exemple static char *couleur[]={"trefle", "carreau", "coeur", "pique"}) là c'est super important. Ca permet de rendre la variable résidente en RAM.
Il faut bien que tu comprennes qu'il n'y a qu'une seule et unique zone de RAM pour un programme, et que les diverses fonctions n'en voient qu'une petite partie (c'est ce qu'on nomme la "visibilité"). Et que les variables non statiques et non globales sont perdues quand la fonction se termine (ce qu'on nomme "durée de vie").
Donc sans "static", le tableau "couleur" disparaitrait à la fin de la fonction et tu te retrouverais (parce que j'espère que t'as remarqué que je ne récupère que les adresses des strings et non les strings elles-même) donc avec des pointeurs pointant sur plus rien du tout. Ca m'évite de mettre ce tableau en global (car les globales, généralement, les programmeurs n'aiment pas car elles apportent plus de soucis que ça n'en résout, même si ici ce n'aurait pas été le cas).
Donc quand la fonction se termine, le tableau existe toujours en RAM et quand j'affiche mon jeu, ça affiche les strings qui y sont associées et dont j'ai gardé précieusement les adresses.

[Nestati]

D'accord je vois merci mais dans ce cas est ce qu'un malloc lors de la déclaration et l'utilisation de pointeurs font le travail du static ?

[Sve@r]

D'accord je vois merci mais dans ce cas est ce qu'un malloc lors de la déclaration et l'utilisation de pointeurs font le travail du static ?

Pas mal. Effectivement il y a une grosse ressemblance entre les deux.

malloc() alloue une zone dans ce qu'on nomme "le tas", une espèce de zone mémoire sans structure, avec juste des cases qui se suivent. Et te renvoie l'adresse de cette zone. Si ensuite tu conserves précieusement cette adresse et que tu la passes de fonction en fonction, alors toutes les fonctions en question pourront accéder à la zone.
static c'est aussi la même chose. Si je déclare une zone en static, et que je conserve précieusement son adresse, alors toutes les fonctions qui la recevront pourront aussi y accéder car la zone perdurera durant tout le temps d'exécution du programme.

La grosse différence, c'est que je peux faire plein de malloc selon mes besoins (j'aurai alors plein de zones distinctes) tandis que la zone "static" est unique pour un programme. Et si 2 fonctions vont y écrire des trucs, la seconde à y écrire écrase les données de la première (on nomme ces fonctions des fonctions "non réentrantes"). Par exemple la fonction strtok() qui permet de splitter une string et qu'on appelle en boucle pour récupérer les parties splittées de la chaine, utilise une zone statique pour mémoriser son travail en cours pour s'y retrouver quand on la rappelle à la boucle suivante. Ca marche tant qu'on ne demande pas à sous-splitter la chaine en cours de traitement (ce qui peut arriver quand on veut splitter un PATH qui contient des chemins séparés par ":", avec les dossiers des chemins séparés par un "/").

[Nestati]

D'accord je comprends mieux merci. Je me posais cette question car je vais devoir "vider" ou "remplir" les nouveaux tableaux de structures que j'ai déclaré comme des "tas de cartes" de 26 cartes (un tas pour chaque joueur)

Code :

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

1
2
3
4
typedef struct {
	t_carte TasCarte[26];
	size_t nb;
} t_main;

Or si un joueur gagne plusieurs fois d'affilé la taille du tableau devra depasser les 26. Est-il donc utile de faire un realloc dans ce cas ?

[Sve@r]

Or si un joueur gagne plusieurs fois d'affilé la taille du tableau devra depasser les 26. Est-il donc utile de faire un realloc dans ce cas ?

Comme dans le "jeu de bataille" ou le joueur récupère les cartes de son adversaire ?
Il existe plusieurs façons d'aborder le "besoin en mémoire"

• j'estime que mon besoin ne dépassera pas 100, 1000, 10000 et je définis mon tableau dans ce sens. Je peux même utiliser une macro pour ça. Si je prends soin de l'utiliser de partout où j'utilise la taille, alors si je me rends compte après-coup que je n'avais pas pris assez grand il me suffit de la changer (une seule modif) et recompiler et tout le code s'adapte en conséquence
  Exemple (un annuaire avec des noms)

  Code c :

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

  1
  2
  3
  4
  #define SZ_NOM			(20)
   
  char nom[SZ_NOM + 1];
  for (i=0; i < SZ_NOM; i++) ...

  Si je me rends compte que je dois aussi stocker des noms comme "compagnie nationale des chemins de fer français" (49 caractères), je remplace 20 par 100 (une seule et unique modif) et je recompile.
• je ne peux pas présumer de mon besoin, il est totalement imprévisible (exemple un firewall qui reçoit des trames réseau à l'infini). Il me faudra alors passer par malloc/realloc. Et dans ce cas, pour éviter d'allouer et de réallouer à chaque nouvel arrivant, je passe par la bufferisation => j'alloue N et je remplis, et quand N est atteint, j'alloue N de plus (N étant lui aussi une macro ce qui permet de paramétrer mon programme selon le client)

Sauf qu'ici le souci ne semble pas se présenter. Il n'y a qu'un seul jeu de 52 cartes, aucun joueur ne pourra alors avoir plus de 52 cartes en main non ??? Le besoin me semble donc tout à fait prévisible.

[Nestati]

Je pensais refaire des tableaux de structure de taille 26 mais on peut juste réutiliser la structure de taille 52 et la remplir qu'avec 26 cartes pour un joueur...

[Sve@r]

Je pensais refaire des tableaux de structure de taille 26 mais on peut juste réutiliser la structure de taille 52 et la remplir qu'avec 26 cartes pour un joueur...

Hé oui. C'est d'ailleurs un peu ce que t'avais fait avec ton premier code. T'avais défini des noms de 20 mais tu n'y mettais que 3 caractères ("roi"). Et c'est bien d'avoir créé une structure "t_jeu" car j'y ai mis le nb de cartes mais si t'as besoin d'y mettre d'autres outils de gestion/contrôle, c'est open.