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.