Découper une chaîne de caractères

Version imprimable

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:

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.

02/02/2007, 18h30
zooro
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:

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é.
02/02/2007, 18h36
The Lord of Nesquik

ca marche tres bien. Merci !

Salut,

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

Code:

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

Pareil, avec un code plus court.

Code:

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

04/02/2007, 00h20
zooro

Citation:

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.