Récupérer une sous chaine de caractère

**Alexandre`** · 26/02/2007, 22h48

Bonjour,
Voilà, je voudrais avoir vos avis sur la fonction que j'ai écrite. Elle permet de ressortir un bout de chaine compris entre 2 "#". Je débute en C donc je voudrais savoir quelle chose éviter, etc...

Merci

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
char *get_label(char * cmd)
{
    char *label;
    char c = cmd[0];
    int pos_1 = 0;
    int pos_2 = 0;
    int i = 0;
    int cpt = 0;
    int len = strlen(cmd);
 
    /* il existe au moins un # dans la cmd */
    if (strstr(cmd, "#") != NULL)
    {
        /*printf("parcours de la chaine : %s de taille : %d\n", cmd, len);*/
 
        /* parcours de la chaine cmd */
        while (i < len)
        {
            /* si le caractère courant est un # est que c'est le 1er */
            if (c == '#' && cpt == 0)
            {
                pos_1 = i;
                cpt++;
            } else if (c == '#' && cpt == 1) /* un 2eme # est trouvé */
            {
                pos_2 = i;
                cpt++;
            }
 
            c = cmd[i];
            i++;
        }
 
        /* récupération de la chaine contenu entre les 2 positions */
        label = (char *)realloc(label, pos_2-pos_1-3);
        if (label != NULL)
        {
            cpt = 0; 
            for (i = pos_1+1; i < pos_2-2; i++)
            {
                label[cpt] = cmd[i];
                cpt++;
            }
        }
 
        /* debug
        printf("pos_1 : %d\n", pos_1);
        printf("pos_2 : %d\n", pos_2);
        printf("nb de # : %d\n", cpt);
        printf("label :'%s'\n", label); 
        printf("-->fin de get_label\n");*/
    }
    return label;
}

**hegros** · 26/02/2007, 22h58

Il faut initialiser au départ label à NULL car le realloc ne fonctionne que si tu lui passes en premier paramètre un pointeur récupére par un précédent malloc ou alors si le pointeur vaut NULL.

Ca évite aussi de renvoyer un pointeur dans les choux si ta première condition n'est pas réalisée.

**Emmanuel Delahaye** · 26/02/2007, 23h01

Envoyé par Alexandre`

Bonjour,
Voilà, je voudrais avoir vos avis sur la fonction que j'ai écrite. Elle permet de ressortir un bout de chaine compris entre 2 "#". Je débute en C donc je voudrais savoir quelle chose éviter, etc...

Etant donné que tu veux une sous-chaine, c'est à dire plus petite (ou égale) à la chaine originale, tu ne risques rien en allouant dès le départ une chaine de la même taille (strdup() sufit pour ça : non standard, mais POSIX.1, donc très portable).

Ca évitera des realloc() lourdingues et compliqués à gérer correctement...

Il manque les headers
Cette fonction devrait admettre une chaine non modifiable :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
char *get_label (char const *cmd)
```
Dans certains cas d'erreur, label est retourné alors qu'il n'est pas initialisé. Je recommande NULL comme valeur par défaut.
Le bon type pour len est size_t.
Par conséquend, le bon type pour i, pos_1 et pos_2 est celui de len.
strstr() pour une chaine de un caractère c'est un peu overlkill comme ils disent... strchr() suffit. D'autre part, ces 2 fonctions servent aussi à localiser la premier occurrence de la chaine ou du caractère. Dommage de ne pas utiliser cette propriété... et de re-parcourir la chaine... Pas efficace...
Le cast du realloc() est inutile.
Le realloc est inutile. malloc() suffit. En plus, avec label non initialisé, c'est le drame... avec NULL, ça va, mais autant mettre malloc()...

Le calcul de la taille pos_2 - pos_1 - 3 est horriblement faux ! C'est (pos_2 - pos_1) - 1 + 1 :

Code :

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

1
2
3
4
5
6
 
0123456789
   #xx#
5 - 2 = 3
- 1 = 2 OK
+1 = 3 pour le zéro final...

La copie est tout aussi horriblement fausse. C'est à partir de pos_1 + 1 et on s'arrête en pos_2... Il manque le 0 final...

Le résultat est douteux :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
int main (void)
{
   char const *s = "Hello#wild#world";
 
   char *sub = get_label (s);
 
   if (sub != NULL)
   {
      printf ("'%s'\n", sub);
      free (sub), sub = NULL;
   }
   return 0;
}

donne :

Code :

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

1
2
3
4
 
'il='
 
Press ENTER to continue.

Ou alors, j'ai rien compris à la spécification...

L'algo me parait un peu compliqué. J'aurais fait :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
recherche du premier #
si trouve
 noter la position
 rechercher le 2ème #
 si trouvé
  noter la position.
  déterminer la taille de la sous-chaine selon les positions
  allouer la sous-chaine
  copier la sous-chaine chaine en fonction des positions
  retourner l'adresse de la sous-chaine

Finalement, c'est à peu près ton code... une fois ton code mis au point :

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
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
char *get_label (char const *cmd)
{
   char *label = NULL;
   if (cmd != NULL && *cmd != 0)
   {
      /* il existe au moins un # dans la cmd */
      if (strchr (cmd, '#') != NULL)
      {
         /*printf("parcours de la chaine : %s de taille : %d\n", cmd, len); */
         size_t pos_1 = 0;
         size_t pos_2 = 0;
         {
            size_t i = 0;
            int cpt = 0;
            size_t const len = strlen (cmd);
 
            /* parcours de la chaine cmd */
            while (i < len)
            {
               int c = cmd[i];
               /* si le caractère courant est un # est que c'est le 1er */
               if (c == '#' && cpt == 0)
               {
                  pos_1 = i;
                  cpt++;
               }
               else if (c == '#' && cpt == 1) /* un 2eme # est trouvé */
               {
                  pos_2 = i;
                  cpt++;
               }
 
               i++;
            }
         }
         /* récupération de la chaine contenu entre les 2 positions */
         label = malloc (pos_2 - pos_1);
         if (label != NULL)
         {
            size_t cpt = 0;
            size_t i;
            for (i = pos_1 + 1; i < pos_2; i++)
            {
               label[cpt] = cmd[i];
               cpt++;
            }
            label[cpt] = 0;
         }
      }
   }
   return label;
}
 
int main (void)
{
   char const *s = "Hello#wild#world";
 
   char *sub = get_label (s);
 
   if (sub != NULL)
   {
      printf ("'%s'\n", sub);
      free (sub), sub = NULL;
   }
   return 0;
}

Ca donne :

Code :

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

1
2
3
4
 
'wild'
 
Press ENTER to continue.

Je propose ça :

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
 
#include <string.h>
#include <stdlib.h>
 
char *get_label (char const *cmd)
{
   char *label = NULL;
   if (cmd != NULL && *cmd != 0)
   {
      /* il existe au moins un # dans la cmd */
      char *p1 = strchr (cmd, '#');
      if (p1 != NULL)
      {
         char *p2 = strchr (p1 + 1, '#');
         if (p2 != NULL)
         {
            size_t len = (size_t) (p2 - 1 - p1);
            label = malloc (len + 1);
 
            if (label != NULL)
            {
               memcpy (label, p1 + 1, len);
               label[len] = 0;
            }
         }
      }
   }
   return label;
}

**Alexandre`** · 26/02/2007, 23h09

Merci pour la précision hegros

J'ai une petite question par contre Emmanuel. Si j'alloue à label la même taille que la chaine de départ. Or label aura moins de caractères que celle de départ et donc le \0 sera bien avant la fin de la chaine. D'où ma question, ca passe où tout ce qu'il y a après mon \0 ?

merci

**Emmanuel Delahaye** · 26/02/2007, 23h12

Envoyé par Alexandre`

J'ai une petite question par contre Emmanuel. Si j'alloue à label la même taille que la chaine de départ. Or label aura moins de caractères que celle de départ et donc le \0 sera bien avant la fin de la chaine. D'où ma question, ca passe où tout ce qu'il y a après mon \0 ?

Ben rien, c'est pas utilisé, mais ce sera récupéré au prochain free() de ce bloc... (strdup() fait un malloc())

**hegros** · 26/02/2007, 23h13

Envoyé par Alexandre`

Si j'alloue à label la même taille que la chaine de départ. Or label aura moins de caractères que celle de départ et donc le \0 sera bien avant la fin de la chaine. D'où ma question, ca passe où tout ce qu'il y a après mon \0 ?

merci

Ce sera ignoré.La fonction printf par exemple s'arrête au premier \0 rencontré de même que strlen par exemple.

Donc ca sert un peu à rien.

Désolé de te hupper la question Emmanuel.

EDIT : trop rapide pour moi

**Alexandre`** · 26/02/2007, 23h41