Découper une chaîne de caractères

**The Lord of Nesquik** · 02/02/2007, 18h16

Bonjour,
je souhaiterais découper un chaine de caratère "mot1 \n mot2 \n mot3 \n" et stocker chaqun des "mots" dans un variable (ou plutot dans un tableau de *char). Je crois avoir trouvé pour ca une fonction répondant parfaitement à mes besoins, mais je ne parvient pas à l'utiliser. Il s'agit d'un fonction trouvée sur ce site ( lien ) :

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
 
char **str_split (const char *cs, const char *delim, int *p_size)
{
  size_t size = 0;
  char **ret = NULL;
 
  if (cs && delim)
  {
    int start = 0;
    int end = 0;
    int length = 0;
    const char *t = NULL;
    void *tmp = NULL;
 
    while ((t = strstr (&cs[start], delim)))
    {
      end = t - cs;
      length = end - start;
      if (length > 0)
      {
        size++;
        tmp = realloc (ret, sizeof (*ret) * size);
        if (tmp)
        {
          ret = tmp;
          ret[size-1] = malloc (sizeof (**ret) * (length + 1));
          if (ret[size-1])
          {
            strncpy (ret[size-1], &cs[start], length);
            ret[size-1][length] = '\0';
          }
          else
          {
            fprintf (stderr, "Memoire insufisante");
            exit (EXIT_FAILURE);
          }
        }
        else
        {
          fprintf (stderr, "Memoire insufisante");
          exit (EXIT_FAILURE);
        }
      }
      start = end + 1;
    }
    size++;
    tmp = realloc (ret, sizeof (*ret) * size);
    if (tmp)
    {
      ret = tmp;
      length = strlen (cs) - start;
      if (length > 0)
      {
        ret[size-1] = malloc (sizeof (**ret) * (length + 1));
        if (ret[size-1])
        {
          strcpy (ret[size-1], &cs[start]);
        }
      }
      else
      {
        ret[size-1] = NULL;
      }
    }
    else
    {
      fprintf (stderr, "Memoire insufisante");
      exit (EXIT_FAILURE);
    }
  }
  if (p_size)
  {
    *p_size = size-1;
  }
  return ret;
}

Je ne comprends pas quels arguments il faut passer à cette fonction, ni le genre de valeur qu'elle retourne. Quelqu'un peut-il m'expliquer comment m'y prendre ?
Merci d'avance.

**zooro** · 02/02/2007, 18h30

Bonjour,

Rapidement, je dirais,
pour la valeur renvoyée :
- char** : tableau de chaînes de caractères

pour les paramètres :
- const char *cs : [IN] la chaîne de caractères source
- const char *delim : [IN] le délimiteur
- int *p_size : [OUT] le nombre de chaînes contenues dans le tableau résultat

Donc, dans ton exemple, tu aurais quelque chose comme ça :

Code :

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

1
2
3
4
char **resultat = NULL;
int nb = 0;
 
resultat = str_split("mot1 \n mot2 \n mot3 \n", " \n", &nb);

nb contiendrait le chiffre 3, et resultat contiendrait 3 chaînes : "mot1", "mot2" et "mot3".

Ne pas oublier de libérer la mémoire quand la variable resultat n'est plus utile.

PS: Je n'ai pas vérifié.

**The Lord of Nesquik** · 02/02/2007, 18h36

ca marche tres bien. Merci !

**Thierry Chappuis** · 02/02/2007, 19h04

Salut,

Chez moi, le code ci-dessous compile sans erreurs et fonctionne correctement:

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
char **str_split (const char *cs, const char *delim, int *p_size);
 
int main(void)
{
    int i;
    char **pp_tab_mots = NULL;
    int taille = 0;
 
    pp_tab_mots = str_split("mot1\nmot2\nmot3\n", "\n", &taille);
 
    for (i = 0; i < taille; ++i)
    {
        printf("Tableau - position %d: %s\n", i, pp_tab_mots[i]);
    }
 
    for (i = 0; i < taille; ++i)
    {
        free((void *) pp_tab_mots[i]);
    }
    free((void *) pp_tab_mots), pp_tab_mots = NULL;
 
    return EXIT_SUCCESS;
}
 
char **str_split (const char *cs, const char *delim, int *p_size)
{
    size_t size = 0;
    char **ret = NULL;
 
    if (cs && delim)
    {
        int start = 0;
        int end = 0;
        int length = 0;
        const char *t = NULL;
        void *tmp = NULL;
 
        while ((t = strstr (&cs[start], delim)))
        {
            end = t - cs;
            length = end - start;
            if (length > 0)
            {
                size++;
                tmp = realloc (ret, sizeof (*ret) * size);
                if (tmp)
                {
                    ret = tmp;
                    ret[size-1] = malloc (sizeof (**ret) * (length + 1));
                    if (ret[size-1])
                    {
                        strncpy (ret[size-1], &cs[start], length);
                        ret[size-1][length] = '\0';
                    }
                    else
                    {
                        fprintf (stderr, "Memoire insufisante");
                        exit (EXIT_FAILURE);
                    }
                }
                else
                {
                    fprintf (stderr, "Memoire insufisante");
                    exit (EXIT_FAILURE);
                }
            }
            start = end + 1;
        }
        size++;
        tmp = realloc (ret, sizeof (*ret) * size);
        if (tmp)
        {
            ret = tmp;
            length = strlen (cs) - start;
            if (length > 0)
            {
                ret[size-1] = malloc (sizeof (**ret) * (length + 1));
                if (ret[size-1])
                {
                    strcpy (ret[size-1], &cs[start]);
                }
            }
            else
            {
                ret[size-1] = NULL;
            }
        }
        else
        {
            fprintf (stderr, "Memoire insufisante");
            exit (EXIT_FAILURE);
        }
    }
    if (p_size)
    {
        *p_size = size-1;
    }
    return ret;
}

Thierry

**Lunixinclar** · 03/02/2007, 23h43

Pareil, avec un code plus court.

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>
 
char **split(const char *str, const char delim, int *nb)
{
  char **tab = NULL;
  char mot[200]; // anti-constitutionnellement en fait 26
  int b=0, n=0, len=0, item=0;
 
  tab = calloc(*nb, sizeof(char *));
  if (!tab)  {perror("calloc()"); return tab;}
 
  len = strlen(str);
  for (n=0; n<=len; n++)
  {
    if (str[n]==delim || n==len)
    {
      // réalloue espace du tableau
        tab = (char **) realloc(tab, sizeof(char *) * (item+1));
        if (!tab) {perror("realloc()"); return tab;}
      // alloue espace pour nouveau mot
        tab[item] = malloc(b+1);
        if (!tab[item]) {perror("malloc()"); return tab;}
      //insère mot au tableau
        strncpy(tab[item], mot, b);
        tab[item][b]=0; // le termine par '\0'
        *nb = ++item; b=0;
    }
    else mot[b++]=str[n];
  }
 
  return tab;
}
 
int main ()
{
  char **t;
  int nb=0, n;
 
  t = split("Ceci est une phrase à découper.", ' ', &nb);
 
  printf("La phrase fait %d mots.\n", nb);
  for (n=0; n<nb; n++) printf("\t%d: [%s]\n", n, t[n]);
  free(t);
 
  return 0;
}

**zooro** · 04/02/2007, 00h20

Envoyé par Lunixinclar

Pareil, avec un code plus court.

Pas tout à fait exact. Ton code ne fonctionne que si le délimiteur est un caractère unique, alors que la fonction d'origine permettait d'utiliser une chaîne.

Découper une chaîne de caractères

C

Discussions similaires

Partager

Partager