Discussion :

[RomainVST]

Bonjour,

Je viens vers vous car j'aimerai avoir un peu d'aide pour réaliser une extraction de plusieurs chaines de caractère présentent dans un fichier .txt

Actuellement j'écris via un programme C, dans un fichier data.txt les informations suivantes :

Network:Name = "Romain"
Network:NodeType = "leader"
IPv6:MeshLocalAddress = "fdf2:fd0f:3469:0:930c:8f11:c4e6:f811"

J'aimerai viens un programme C faire une extraction des chaines de caractère "Romain", "Leader" et "fdf2:fd0f:3469:0:930c:8f11:c4e6:f811" sans les ".

Sachant qu'elles sont entre ", je me dis que cela est possible (ces datas sont variable).

Par ailleurs je ne souhaite pas extraire les trois à l'éxecution, seulement une parmis les trois suivant le choix de l'utilisateur.

Exemple avec un programme extractData.c :

./extractData 1
Renvoi Romain

./extractData 2
Renvoi leader

./extractData 3
Renvoi fdf2:fd0f:3469:0:930c:8f11:c4e6:f811

Voilà je sais pas si je suis très clair, j'ai effectué quelques recherche et j'ai trouvé des choses similaire mais jamais en C.

Merci d'avance !

Romain

[Matt_Houston]

https://en.cppreference.com/w/c/string/byte/strchr

Par ailleurs je ne souhaite pas extraire les trois à l'éxecution, seulement une parmis les trois suivant le choix de l'utilisateur.

Avec une signature de point d'entrée de la forme int main(int argc, char *argv[]), les paramètres passés à ton programme sont disponibles dans argv pour consultation. Tu trouveras probablement une entrée dans la FAQ C concernant cela. Le reste c'est de l'algorithmique.

[Sve@r]

Bonjour

Actuellement j'écris via un programme C, dans un fichier data.txt les informations suivantes :
Network:Name = "Romain"
Network:NodeType = "leader"
IPv6:MeshLocalAddress = "fdf2:fd0f:3469:0:930c:8f11:c4e6:f811"

Oui, un peu comme les fichiers ".ini".

Sachant qu'elles sont entre ", je me dis que cela est possible (ces datas sont variable).

Il vaut mieux te caler sur le "=" qui sépare le titre de sa valeur plutôt que sur les guillemets qui ne sont (enfin dans les vrais fichiers ".ini") pas toujours présents.

Par ailleurs je ne souhaite pas extraire les trois à l'éxecution, seulement une parmis les trois suivant le choix de l'utilisateur.

Tu fais comme Matt_Houston t'indique en regardant ensuite le contenu de argv[1] Et fais attention car argv[x] est une chaine or une chaine contenant (par exemple) "1" ce n'est pas égal à 1.

[RomainVST]

Super merci des réponses, je pense pouvoir me débrouiller !

[RomainVST]

Voilà j'ai créer le code suivant qui répond à mes attentes ! Merci pour l'aide

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <regex.h>
 
int main (int argc, char **argv)
{
 
    if(argc != 2)
    {
        printf("USAGE: %s [0] = NetworkName ; [1] = NodeType ; [2] = IPv6 Addr \n", argv[0]);
        exit(-1);
    }
 
 
   int err;
   int i, iLigne = atoi(argv[1]);
   regex_t preg;
   char *str_request = NULL;
   const char *str_regex = "\"(.*)\"";
 
 
 
   FILE *fp = fopen ("data.txt", "r");
 
   if (fp != NULL)
   {
 
      for (int i=0; i<=iLigne; i++) {
 
      str_request = fgets (ligne, sizeof ligne, fp);   
 
      }      
 
      fclose (fp);
   }
   else
   {
      printf ("Erreur d'ouverture du fichier\n");
   }
 
 
 
   err = regcomp (&preg, str_regex, REG_EXTENDED);
   if (err == 0)
   {
      int match;
      size_t nmatch = 0;
      regmatch_t *pmatch = NULL;
 
      nmatch = preg.re_nsub;
      pmatch = malloc (sizeof (*pmatch) * nmatch);
      if (pmatch)
      {
 
         match = regexec (&preg, str_request, nmatch, pmatch, 0);
 
         regfree (&preg);
 
         if (match == 0)
         {
            char *site = NULL;
            int start = pmatch[0].rm_so + 1;
            int end = pmatch[0].rm_eo - 1;
            size_t size = end - start;
 
            site = malloc (sizeof (*site) * (size + 1));
            if (site)
            {
               strncpy (site, &str_request[start], size);
               site[size] = '\0';
               printf ("%s\n", site);
               free (site);
            }
         }
 
         else if (match == REG_NOMATCH)
         {
            printf ("%s n\'est pas une data valide\n", str_request);
         }
 
         else
         {
            char *text;
            size_t size;
 
 
            size = regerror (err, &preg, NULL, 0);
            text = malloc (sizeof (*text) * size);
            if (text)
            {
 
               regerror (err, &preg, text, size);
               fprintf (stderr, "%s\n", text);
               free (text);
            }
            else
            {
               fprintf (stderr, "Memoire insuffisante\n");
               exit (EXIT_FAILURE);
            }
         }
      }
      else
      {
         fprintf (stderr, "Memoire insuffisante\n");
         exit (EXIT_FAILURE);
      }
   }
 
   return (0);
}

[Bousk]

Tu devrais rajouter des exit sur tous les cas d'erreurs. Sinon tu vas avoir un crash ou comportements indetermines.
En plus de rendre le tout plus homogene vu que t'en as deja quelques-uns

[Sve@r]

Et peut-être aussi, en cas d'erreur à une étape X, libérer ce qui est alloué lors des X-1 étapes précédentes.

A ce propos d'ailleurs, faire de l'allocation "précise" c'est bien, c'est robuste, mais parfois ce n'est pas nécessaire.
Exemple, tu alloues "text" en fonction d'une regex (enfin il me semble). Mais si tu pars de l'hypothèse que ce texte ne fera jamais plus de 100 caractères, tu peux alors tenter un char text[100] et te passer du couple maudit malloc + free. Et si c'est pas 100 mais 1000 ben tu adaptes.
C'est prendre un risque (tu ne peux pas être certain que "text" ne sera jamais dépassé) mais c'est un risque dont la criticité dépend de la probabilité que l'évènement arrive. Bref c'est un équilibre triangulaire entre "robustesse", "simplicité de développement" et "risque calculé".

PS: dans ton code, la variable "ligne" n'a pas été définie.