Discussion :

[nysay27]

bonjour a tous et merci d'avance pour votre aide

J'ai un fichier .txt qui me donne des informations sur des entités.Toutes ce informations ne me sont pas utiles et par la suite je souhaite faire des blocs pour créer des liaisons de dépendances entre elles.

Pour etre plus clair soit l'extrait du txt suivant :

NOM TOTO
PRENOM xxxxxx
SITUATION MARIE
ENFANT TATA

Je souhaiterai, dans cette extrait, ne sélectionner que les informations NOM, SITUATION et ENFANT, créer un bloc de cette entité pour, par la suite, faire une liaison avec le bloc de son enfant dont la description sera donné dans le txt à un autre endroit.

Si je n'ai pas été assez clair, je peux réexpliquer.

merci.

[Franck.H]

Et qu'a-tu déjà fait comme code ?

[nysay27]

Alors pour l'instant peu de code mais beaucoup d'interrogations :

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
main()
{
char A[] = "NOM";
FILE*prog;
prog=fopen("C:\\xxx\\xxx\\xxx\\prog_load_ref.txt","r");
 
              if (prog != NULL)
              {
 
                    for (i = 0; i <=300; i++)
                    {
                           Lecture des caractères
                                 Si [caractère = A]
                                   {copier la ligne}
                    }                     
             fclose(prog);
             }
   return 0;
}
 
}

En effet, ne sachant pas totalement le nombre de "blocs" a prévoir, je vais devoir faire une fonction malloc pour un nombre x de tableau.Cela est possible?

Pour la recherche par rapport à une chaine de caractère décidé, j'ai vu beaucoup de post avec la fonction fgets, serait-ce un début de piste?

[ternel]

Bonjour!
Connais-tu le concept de liste chainée?

Pourquoi n'as-tu pas écrit une structure (pour matérialiser ton bloc)?

[nysay27]

Leternel bonjour.

Oui je connait le concept de liste chainée, les arbres généalogique sont fais à partir de cette structure et j'ai déja un programme qui le fait puisque j'en ai réaliser un.C'est pour cela que l'enchainement des blocs ne me fait pas trop peur.

Pourquoi faire une structure? Je pensais que la structure était un mélange de plusieurs variables, la je ne cherche qu'a prendre des chaine de caractères.

A moins si je comprends ton point de vue :

Code :

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

1
2
3
4
5
# typedef struct_block
{
char*nom
char*situation
char*enfant}

Et à la lecture du fichier txt, faire un test pour remplir la structure?

Mais comment lire le fichier txt et effectuer ce fameux tests, pour par la suite dégager mes blocs sachant que jen aurais plusieurs?

[BufferBob]

salut,

ne sachant pas totalement le nombre de "blocs" a prévoir, je vais devoir faire une fonction malloc pour un nombre x de tableau.Cela est possible?

c'est là que les listes chainées sont utiles en fait, et assez pertinentes puisqu'il suffit de faire une structure par identité, encore faut-il savoir les implémenter proprement mais c'est bien mieux structuré que d'envisager de jouer avec realloc() par exemple

Pour la recherche par rapport à une chaine de caractère décidé, j'ai vu beaucoup de post avec la fonction fgets, serait-ce un début de piste?

oui ben ca va nécéssairement tourner autour de ce genre de fonctions, fgets(), fscanf() sont les pistes à creuser effectivement

[nysay27]

Bonsoir,

J'ai continué mon code et j'ai toujours quelques soucis:

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 255
 
typedef struct _famille
{
char*prenom;
char*nom;
char*lien;
struct _famille *pSuivant;
} famille;
 
typedef struct
{
int Taille;
famille*Premier;
famille*Dernier;
} _List;
 
int main(void)
{
int n=0;
char ligne[MAX];
_List * EdtList=(_List*)malloc(sizeof( _List));
EdtList->Premier=NULL;
EdtList->Dernier=NULL;
EdtList->Taille=0;
 
FILE*batch;
batch=fopen("C:\\Documents and Settings\\xxx\\Bureau\\famille_load_ref.txt","r");
//fgets (ligne, sizeof ligne, batch);
//printf("1: %s\n",ligne);
while (fgets(ligne,256,famille)!=NULL)
    n++;
printf("%d lignes lues\n",ligne);
ParcourirList(EdtList);
}
 
void ParcourirList(_List * MaList)
{
     while(MaList->Premier)
     {
                        printf("prenom/nom %s%s\n",MaList->Premier->identifiant,MaList->Premier->description);
                        printf("lien %s\n",MaList->Premier->lien);
                        MaList->Premier=MaList->Premier->pSuivant;
                        }
     }

Donc j'ai bien parcouru le fichier txt, maintenant je ne sais pas comment faire le test pour remplir mes structures.Il faudrait faire un test
avec une chaine de caractère de référence mais cela marche t'il et comment le présenter (sachant que je vais par exemple tester si je trouve le mot "nom" et devoir copier la suite
qui sera le nom de la personne block).

exemple de txt:

nom : dudule prenom : fabien
age : 25
lien : pere

selection de nom, prenom et lien et création d'une structure

Sachant que dans le fichier txt, la liste doit s'établir sur le lien, ma fonction est-elle bien écrite?

Sachant qu'il peut ne pas y avoir de lien, est ce que ces structures vont être visibles?

[BufferBob]

exemple de txt:

nom : dudule prenom : fabien
age : 25
lien : pere
(...)
Sachant qu'il peut ne pas y avoir de lien

• dans ton fichier d'exemple on trouve le prenom sur la même ligne que le nom, c'est bien ça/ça peut arriver dans le fichier ?
• aussi tu dis qu'il peut ne pas y avoir de lien, ton fichier d'exemple en trop court, pour bien faire il faudrait nous montrer un fichier plus réaliste avec plusieurs enregistrements (typiquement, comment on sait qu'on change d'entité, il y a une ligne vide entre chaque, un séparateur quelconque ?)

[nysay27]

Sans problème, voici un exemple avec les deux cas de figures soit avec lien soit sans.

Je n'arrive vraiment pas a trouver un exemple de fichier txt que l'on rentre dans une structure ni quel test effectué.

[BufferBob]

ok, en se basant sur les données que tu fournis :

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
 BLOCK  FAMILLE(ADD)
   MEMBRE(001)  NOM(DUDULE)  PRENOM(JACK) 
   XXXXXX
   METIER('Technicient informatique')
   XXXXX(000060 ans)
   SEXE(H)
   CHEVEUX(B) YEUX(V) 
   NATION (F)
   LIEND (Y)
      LIEN DIRECT(DUDU)
        PERE(MARCEL)
      LIEN DIRECT 2 (DUDU)
        MERE(MARCH)
 BLOCK  FAMILLE(ADD)
   MEMBRE(002)  NOM(NIEDS)  PRENOM(MONIQUE) 
   XXXXXX
   METIER('NURSE')
   XXXXX(000043 ans)
   SEXE(F)
   CHEVEUX(B) YEUX(B) 
   NATION (G)
   LIEND (N)

si je comprends bien, ton propos est de construire en temps réel les arbres généalogiques avec la totalité des enregistrements contenus dans le fichier, donc encore une fois les listes chainées se prêtent particulièrement bien à l'exercice, mais ce que tu essayes de faire n'est pas trivial du tout, sans être très complexe techniquement ça demande surtout beaucoup de rigueur à mon avis

ça veut dire que tu vas avoir besoin de fonctions d'insertion, de suppression, de recherche etc. sur tes listes chainées, et d'une logique d'insertion de tes identités, càd te baser sur LIEND par exemple pour déterminer où insérer la personne
ça veut également dire que comme une personne peut avoir 0 enfant et une autre en avoir 160 (bon ça fait peut-être un peu beaucoup mais 100-110 facile ) il va falloir ici aussi avoir recours à une liste chainée

concernant le parsing du fichier, si tu as la possibilité d'avoir recours aux expressions régulières tant mieux, sinon ça n'est pas très compliqué d'implémenter une recherche de patterns spécifiques.

dans l'idée tu lis ligne à ligne, si la ligne commence par "BLOCK" c'est qu'on crée une nouvelle identité (et qu'on en a terminé avec la précédente éventuellement)
on cherche alors NOM( et on prend tout jusqu'au prochain ), on copie le tout dans un buffer fraichement malloc et on a alors plus qu'a changer la valeur du pointeur char *nom dans la structure pour y accrocher le buffer, idem avec le prénom.

avec les liens (LIEND dans le fichier fourni) le parsing est un peu différent, si LIEND vaut N on laisse tomber, on continue à parser et normalement on devrait tomber sur un nouveau tag BLOCK bientôt
si il vaut Y en revanche ça se complique, il va falloir (...) faire une soupe entre LIEN DIRECT(nom de famille ?) et la ligne immédiatement en dessous PERE(MARCEL) pour :

• identifier les personnes auxquelles la personne courante est liée (parenté) par leur couple prénom-nom
• modifier ou insérer chez les personnes liées un maillon dans leurs liens respectifs en se basant sur le lien de parenté inversé (si le lien est "PERE" alors chez le père on modifiera le champ "ENFANT")

(c'est donc ici qu'une fonction de recherche dans ta liste chainée s'impose)

donc on pourrait imaginer des pseudo-structures remplies du genre :

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
struct _famille {
   char *prenom = malloc("MONIQUE")
   char *nom = malloc("NIEDS")
   struct _liens *lien = NULL
   struct _famille *psuivant = (struct _famille *)"JACK DUDULE"
   struct _famille *pprecedent = NULL // je suis le 1er élément de la liste (doublement-)chainée
}
 
struct _famille {
   char *prenom = malloc("JACK")
   char *nom = malloc("DUDULE")
   struct _liens *lien = (struct _liens *)PAPA  // l'identifiant "PAPA" est totalement arbitraire et symbolique ici, concrètement la structure n'a pas de nom évidemment
   struct _famille *psuivant = NULL // je suis le dernier élément de la liste (doublement-)chainée
   struct _famille *pprecedent = (struct _famille *)"MONIQUE NIEDS"
}
 
enum tParenté {MERE, PERE, ENFANT, ONCLE, TANTE, NEVEU, etc.}
 
struct _liens PAPA {
   enum tParenté type_parenté = PERE
   struct _famille *personne_concernee = (struct _famille *)"MARCEL DUDU"
   struct _liens *psuivant = (struct _liens *)MOMAN // même remarque que précédemment ;p
}
 
struct _liens MOMAN {
   enum tParenté type_parenté = MERE
   struct _famille *personne_concernee = (struct _famille *)"MARCH DUDU"
   struct _liens *psuivant = NULL // je suis le dernier élément de la liste (simplement-)chainée
}

[nysay27]

Merci pour ta réponse.

J'ai bien compris ton algorithme (les listes chainées encore un peu flou mais cela viendra).

J'ai écrit ceci.

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
int main(void)
{
int n=0;
char ligne[MAX];
_List * EdtList=(_List*)malloc(sizeof( _List));
EdtList->Premier=NULL;
EdtList->Dernier=NULL;
EdtList->Taille=0;
 
FILE*batch;
batch=fopen("C:\\Documents and Settings\\gacia delamare\\Bureau\\Batch_load_ref.txt","r");
    while (fgets(ligne,sizeof ligne,batch)!=NULL)
    printf("%s\n",ligne);
    n++;
            //if (strcmp(ligne,mot)==0){
              //  printf ("mot trouvé \n");
      }

J'arrive donc a extraire mon txt mais tu dis de lire ligne par ligne pour reperer le début du bloc et puis associé le nom a la structure.

Le soucis c'est que je ne vois pas comment d'une part déterminé le début du bloc (j'ai lu la fonction strcmp, penses tu que cela soit efficace?), surtout que comme tu dis une fois le block identifié, les informations sont dedans, c'est juste une sorte de balise pour dire attention nouveau membre.

Comment fais tu après pour trouver les informations et les rattachées aux différents pointeurs?

[BufferBob]

j'ai lu la fonction strcmp, penses tu que cela soit efficace?

je miserais plutôt sur strstr et strchr je pense

Comment fais tu après pour trouver les informations et les rattachées aux différents pointeurs?

probablement quelque chose du genre :

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
char *p1 = strstr(line, "PRENOM(")
char *p2 = strstr(p1, ")")
 
 NOM(DUGENOUX) PRENOM(MAURICETTE)
               ^      ^         ^
               |      |         |
               p1     |         p2
                      [<--len->]
                      |
                      p3
 
char *p3 = p1 + strlen("PRENOM(")
len = p2 - p3
char *buff = malloc(len)
memset(buff, 0, len)
strncpy(buff, p3, len)
ma_structure->nom = buff

les listes chainées encore un peu flou mais cela viendra

vu d'ici on a le sentiment que tu t'attaques à un morceau peut-être un peu trop gros pour toi, quelque chose qui nécessite une certaine aisance avec le C qu'il te manque manifestement, tu galères déjà avec des fonctions de base et ce qui t'attend regorge de problématiques liées à la mémoire, de malloc(), de free() etc.

[nysay27]

Merci pour toutes ces réponses, cela prendra le temps que cela prendra.