Probleme comparaison structure

**theoffss** · 12/03/2008, 19h46

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 :

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
#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

**souviron34** · 12/03/2008, 21h42

tu lis tes 2 fichiers dans des tableaux de structure, et tu boucles...

**theoffss** · 12/03/2008, 22h01

c'est pas ce qui est fait ?

**souviron34** · 13/03/2008, 01h50

non là tu lis 2 structures, mais tu les écrases à chaque ligne..

**theoffss** · 13/03/2008, 09h15

Okai
mais je ne voie pas comment faire

j'aimerais quelques explication pliz

**corentin59** · 13/03/2008, 09h37

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.

Envoyé par theoffss

Code :

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

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" ...

**theoffss** · 13/03/2008, 10h01

qu'entends tu par liste chainée ?

pour les structures, je vais rectifié cela

**corentin59** · 13/03/2008, 10h27

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).

**theoffss** · 13/03/2008, 10h43

Okai merci de l'eclaircissement
je vais chercher le tuto, car je ne metrise pas encore tres bien les pointeurs

**theoffss** · 13/03/2008, 16h22

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

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

**corentin59** · 13/03/2008, 17h28

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 :

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
#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;
}

**theoffss** · 13/03/2008, 20h17

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.

**Emmanuel Delahaye** · 14/03/2008, 01h48

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 ?

**Sve@r** · 14/03/2008, 08h06

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 bash :

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
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...

**corentin59** · 14/03/2008, 08h53

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 :

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

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;
}

**Emmanuel Delahaye** · 14/03/2008, 10h33

Envoyé par corentin59

Code :

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

1
2
 
        if ( !strcomp(temp1->nom,temp2->nom) ) {

strcmp() ...

**corentin59** · 14/03/2008, 11h10

voila ce que c'est de taper trop vite !

Merci

**theoffss** · 14/03/2008, 11h34

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

Probleme comparaison structure

C

Discussions similaires

Partager

Partager