Probleme comparaison structure

Version imprimable

Hello
je vous expose mon probleme, j'ecrit dans un fichier une structure qui comporte "Adherent.nom" et dans un autre fichier une structure comportant "RDV.nom"
et je souhaite comparer les 2 et lorsqu'elles sont egale, afficher la structure RDV.
mais voila, cela marche uniquement lorsque les noms egaux sont à la meme position dans leurs fichiers respectif.
Par exemple si adherent.nom = billy et est enregistrer en 2nd position dans le fichier, mais que RDV.nom = billy est en 3ieme position, le programme ne trouvera rien ...

voici le 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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define NOM 30
#define PRENOM 30
#define DATE_NAISSANCE 10
#define NIVEAU 30
#define CONTACT 11
 
typedef struct
{
	char Nom[NOM];
	char Prenom[PRENOM];
	char DateNaissance[DATE_NAISSANCE];
	double Poids;
	double Taille;
	char Niveau[NIVEAU];
	char Contact[CONTACT];
} Adherent;
typedef struct
{
	double Date;
	double Heure;
	char NomAdherent[NOM];
} RDV;
void adherentRDV(void) \\ gros soussie, si les enregistrement ne sont pas à la meme position dans le fichier, ca ne fonctionne pas
{
FILE* fichierRDV = NULL;
FILE* fichierAdherent = NULL;
	RDV RDV;
	Adherent Adherent;
	int retourRDV = 0, retourAdherent = 0;
	int trouve = 0;
	/*Effacer ecran*/
	system("CLS");
 
	/*Titre*/
	printf("--- Liste RDV Adherents---\n\n");
 
	/*Recuperation des données*/
	fichierRDV=fopen("FichierRDV.txt","r");
	fichierAdherent=fopen("FichierAdherent.txt","r");
 
	if (fichierRDV != NULL && fichierAdherent != NULL)
	{
		retourRDV = fscanf(fichierRDV,"%lf\n%lf\n%s\n\n", &RDV.Date,&RDV.Heure,RDV.NomAdherent);
		retourAdherent = fscanf(fichierAdherent, "%s\n%s\n%s\n%lf\n%lf\n%s\n%s\n\n",
		Adherent.Nom, Adherent.Prenom, Adherent.DateNaissance, &Adherent.Poids, &Adherent.Taille, Adherent.Niveau, Adherent.Contact);
		while(retourRDV != EOF && retourAdherent != EOF)
		{
			if (strcmp(Adherent.Nom, RDV.NomAdherent) == 0) 
					{
						printf("Adherent : %s a RDV a %.0f H le %.0f\n\n", RDV.NomAdherent, RDV.Heure, RDV.Date);
					}
		trouve =1;
		retourRDV = fscanf(fichierRDV,"%lf\n%lf\n%s\n\n", &RDV.Date,&RDV.Heure,RDV.NomAdherent);
		retourAdherent = fscanf(fichierAdherent, "%s\n%s\n%s\n%lf\n%lf\n%s\n%s\n\n",
		Adherent.Nom, Adherent.Prenom, Adherent.DateNaissance, &Adherent.Poids, &Adherent.Taille, Adherent.Niveau, Adherent.Contact);
 
		}
		if(trouve!=1)
		{
			printf("Aucun Adherent n'a de RDV");
		}
		fclose(fichierRDV);
		fclose(fichierAdherent);
	}
	else
	{
		printf("Impossible d'ouvrir le fichier");
		getchar();
	}
 
	system("PAUSE");
}

Si vous avez des idées, n'hesitez pas :)
Merci

12/03/2008, 21h42
souviron34

tu lis tes 2 fichiers dans des tableaux de structure, et tu boucles...
12/03/2008, 22h01
theoffss

c'est pas ce qui est fait ?
13/03/2008, 01h50
souviron34

non là tu lis 2 structures, mais tu les écrases à chaque ligne..
13/03/2008, 09h15
theoffss

Okai
mais je ne voie pas comment faire :(
j'aimerais quelques explication pliz
13/03/2008, 09h37
corentin59
moi, je ferai une liste chainée qui contient toutes les structures du premier fichier, une deuxième liste chainée qui contient toutes les structures du second puis deux boucles imbriquées pour rechercher dans la liste 2 les noms de tous les éléments de la liste 1.
Citation:
Envoyé par theoffss

Code:

1 2 RDV RDV; Adherent Adherent;
évite de donner aux variables le même nom que leur type, cela ne te viendrait pas à l'idée d'appeler une variable entière "int" ...
13/03/2008, 10h01
theoffss

qu'entends tu par liste chainée ?

pour les structures, je vais rectifié cela :)
13/03/2008, 10h27
corentin59

disons que tu as deux possibilités : 1) tu connais à l'avance le nombre N de structures qu'il y a dans un fichier, 2) tu ne le connais pas.

Dans le cas 1), tu peux faire un tableau de N structures, lire ton fichier et stocker dans ton tableau tes N structures.

Dans le cas 2), tu rajoutes dans tes structures un pointeur vers une structure du même type. Quand tu lis ton fichier, tu procèdes ainsi :
- tu lis la première structure et tu crées une structure dont ce pointeur à NULL.
- tu lis la deuxième structure et tu crées une structure dont ce pointeur pointe vers la structure lue précédemment
- et ainsi de suite

comme cela, tu stockes au fur et à mesure toutes les structures qui sont dans ton fichier. On appelle cela une liste chainée (il y a des tutoriels sur cela sur dvp).
13/03/2008, 10h43
theoffss

Okai merci de l'eclaircissement
je vais chercher le tuto, car je ne metrise pas encore tres bien les pointeurs
13/03/2008, 16h22
theoffss

j'ai lu et relu : http://nicolasj.developpez.com/articles/listesimple/

mais j'echoue encore et encore :'(
Help pliz

Voici un exemple de liste chainée. Tu retrouves deux fonctions essentielles : une qui permet d'ajouter un élément à la liste, l'autre qui permet de vider la liste (libérer l'espace mémoire). Dans l'exemple, je lis un fichier ligne par ligne, je stocke les informations (la ligne et la longueur) dans une structure, j'ajoute cette structure à la liste chainée. Une fois le fichier lu en entier, j'affiche un par un les éléments de la liste.

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define NBCHAR 1000
 
typedef struct MAILLON {
    char *nom;
    size_t L;
    struct MAILLON *prec;
} MAILLON;
 
/******************************************************************************/
/* ajoute un element a la fin de la liste                                     */
/******************************************************************************/
int ajouterElement(const char *nom,size_t L,MAILLON **dernier) {
    MAILLON *temp=NULL;
 
    temp = malloc(sizeof(MAILLON));
    if ( temp == NULL ) {
        fprintf(stderr,"probleme allocation memoire\n");
        return 1;
    }
    temp->nom = malloc(L+1);
    if ( temp->nom == NULL ) {
        fprintf(stderr,"probleme allocation memoire\n");
        free(temp);
        return 1;
    }
    strcpy(temp->nom,nom);
    temp->L = L;
    temp->prec = *dernier;
    *dernier = temp;
 
    return 0;
}
 
/******************************************************************************/
/* vide la liste                                                              */
/******************************************************************************/
void viderListe(MAILLON **dernier) {
    MAILLON *temp;
 
    while ( *dernier != NULL ) {
        temp = (*dernier)->prec;
        free((*dernier)->nom);
        free(*dernier);
        *dernier = temp;
    }
}
 
/******************************************************************************/
/* main                                                                       */
/******************************************************************************/
int main(void) {
    char ligne[NBCHAR];
    FILE *fichier=NULL;
    MAILLON *dernier=NULL, *temp;
 
    // ouverture du fichier
    fichier = fopen("nomdufichier","r");
    if ( fichier == NULL ) {
        fprintf(stderr,"erreur lors de l'ouverture du fichier\n");
        exit(EXIT_FAILURE);
    }
 
    // lecture des lignes une par une
    // stockage de chacune d'entre elles dans un maillon de la liste
    while ( fgets(ligne,NBCHAR,stdin) != NULL ) {
        if ( ajouterElement(ligne,strlen(ligne),&dernier) ) {
            fprintf(stderr,"erreur lors de l'ajout d'un element a la liste\n");
            viderListe(&dernier);
            fclose(fichier);
            exit(EXIT_FAILURE);
        }
    }
    fclose(fichier);
 
    // affichage de chacun des maillons
    temp = dernier;
    while ( temp != NULL ) {
        printf("%s (%d)\n",temp->nom,temp->L);
 
        temp = temp->prec;
    }
 
    viderListe(&dernier);
 
    return 0;
}

13/03/2008, 20h17
theoffss

okai merci pour ton exemple,

j'ai réussi via cette solution à copier mes 2 fichiers (remplie de structures) dans 2 fichier respectifs en ''liste chainée'', mais je ne voie pas comment ensuite pouvoir faire le comparatif des noms pour afficher les structure possédant les meme nom.
14/03/2008, 01h48
Emmanuel Delahaye

Citation:

Envoyé par theoffss

<...> je ne voie pas comment ensuite pouvoir faire le comparatif des noms pour afficher les structure possédant les meme nom.

strcmp(), ça te parle ?

Citation:

Envoyé par theoffss

okai merci pour ton exemple,

j'ai réussi via cette solution à copier mes 2 fichiers (remplie de structures) dans 2 fichier respectifs en ''liste chainée'', mais je ne voie pas comment ensuite pouvoir faire le comparatif des noms pour afficher les structure possédant les meme nom.

Ben tu balayes la première liste. Et pour chaque élément de la première tu balayes la 2° (boucles imbriquées) - Dès que tu trouves deux noms égaux (vois la remarque d'Emmanuel) tu affiches.

Evidemment pour N éléments tu dois faire NxN comparaisons. Ca peut se réduire à condition que les deux listes soient triées par noms. Là tu peux implémenter un algorithme d'appareillage de la façon suivante
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 flag1=vrai flag2=vrai faire si flag1 = vrai alors prendre élément suivant de la liste 1 ou sortir si la liste est entièrement traitée flag1=faux fin si si flag2 = vrai alors prendre élément suivant de la liste 2 ou sortir si la liste est entièrement traitée flag2=faux fin si si nom liste 1 = nom liste 2 alors afficher fin si si nom liste 1 <= nom liste 2 alors flag1=vrai fin si si nom liste 2 <= nom liste 1 alors flag2=vrai fin si fin faire
Avec cet algo qui ne marche que si les listes sont triées par nom, tu as un truc comme seulement 2N comparaisons à faire ce qui est mieux que NxN...

Citation:

Envoyé par theoffss

j'ai réussi via cette solution à copier mes 2 fichiers (remplie de structures) dans 2 fichier respectifs en ''liste chainée''

Euh, normalement, tu lis les deux fichiers et tu les stockes en mémoire sous forme de deux listes chainées. Pourquoi parles-tu de "fichiers en liste chainée" ? Que veux-tu dire par là, ça n'a pas trop de sens pour moi ?

Pour la comparaison, tu fais, comme je te le disais plus haut, deux boucles imbriquées
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 temp1 = dernierListe1; while ( temp1 != NULL ) { temp2 = dernierListe2; while ( temp2 != NULL ) { if ( !strcomp(temp1->nom,temp2->nom) ) { // les noms sont les memes } else { // les noms se sont pas les memes } temp2 = temp2->prec; } temp1 = temp1->prec; }

14/03/2008, 10h33
Emmanuel Delahaye
Citation:
Envoyé par corentin59

Code:

1 2 if ( !strcomp(temp1->nom,temp2->nom) ) {
strcmp() ...
14/03/2008, 11h10
corentin59

:oops:
voila ce que c'est de taper trop vite !

Merci
14/03/2008, 11h34
theoffss

oui effectivement je pensait stocker ca dan sun fichier, mais c'est inutile, je vais tanter le coup dès que j'aurai un peu de temps libre dans la journée