Scinde une chaîne avec des séparateurs en C

Je pense que strsep est toujours le meilleur outil pour cela:

while ((token = strsep(&str, ","))) my_fn(token);

Qui est littéralement une ligne qui divise une chaîne de caractères.

L'extra parenthèses sont un élément stylistique pour indiquer que nous sommes intentionnellement tester le résultat d'une affectation, pas un opérateur d'égalité ==.

Pour que le modèle fonctionne, token et str à la fois de type char *. Si vous avez commencé avec une chaîne littérale, alors vous voulez faire une copie de celui-ci d'abord:

//More general pattern:
const char *my_str_literal = "JAN,FEB,MAR";
char *token, *str, *tofree;
tofree = str = strdup(my_str_literal);  //We own str's memory now.
while ((token = strsep(&str, ","))) my_fn(token);
free(tofree);

Si deux délimiteurs apparaissent ensemble dans str, vous obtiendrez un token valeur est la chaîne vide. La valeur de str est modifié en ce sens que chaque séparateur rencontré est remplacé par un zéro octet - une autre bonne raison pour copier la chaîne pour être analysée en premier.

Dans un commentaire, quelqu'un a suggéré que strtok est mieux que strsep parce que strtok est plus portable. Ubuntu et Mac OS X ont des strsep; il est sûr de deviner que d'autres unixy systèmes de faire aussi bien. Windows manque de strsep, mais il a strbrk qui permet de court et doux strsep de remplacement:

char *strsep(char **stringp, const char *delim) {
if (*stringp == NULL) { return NULL; }
char *token_start = *stringp;
*stringp = strpbrk(token_start, delim);
if (*stringp) {
**stringp = '\0';
(*stringp)++;
}
return token_start;
}

Ici est une bonne explication de strsep vs strtok. Les avantages et les inconvénients peuvent être jugés subjectivement; cependant, je pense que c'est un signe révélateur que strsep a été conçu comme un remplacement pour strtok.

Méthode ci-dessous va faire tout le travail (allocation de mémoire, en comptant la longueur) pour vous. Plus d'informations et une description peut être trouvée ici - La mise en œuvre de Java Chaîne.méthode split() pour diviser chaîne C

int split (const char *str, char c, char ***arr)
{
int count = 1;
int token_len = 1;
int i = 0;
char *p;
char *t;
p = str;
while (*p != '\0')
{
if (*p == c)
count++;
p++;
}
*arr = (char**) malloc(sizeof(char*) * count);
if (*arr == NULL)
exit(1);
p = str;
while (*p != '\0')
{
if (*p == c)
{
(*arr)[i] = (char*) malloc( sizeof(char) * token_len );
if ((*arr)[i] == NULL)
exit(1);
token_len = 0;
i++;
}
p++;
token_len++;
}
(*arr)[i] = (char*) malloc( sizeof(char) * token_len );
if ((*arr)[i] == NULL)
exit(1);
i = 0;
p = str;
t = ((*arr)[i]);
while (*p != '\0')
{
if (*p != c && *p != '\0')
{
*t = *p;
t++;
}
else
{
*t = '\0';
i++;
t = ((*arr)[i]);
}
p++;
}
return count;
}

Comment l'utiliser:

int main (int argc, char ** argv)
{
int i;
char *s = "Hello, this is a test module for the string splitting.";
int c = 0;
char **arr = NULL;
c = split(s, ' ', &arr);
printf("found %d tokens.\n", c);
for (i = 0; i < c; i++)
printf("string #%d: %s\n", i, arr[i]);
return 0;
}

Dans l'exemple ci-dessus, il y aurait un moyen de retourner un tableau de valeur null cordes (comme vous voulez) en place dans la chaîne. Cela ne ferait-il possible de passer une chaîne littérale même si, comme il aurait à être modifié par la fonction:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
char** str_split( char* str, char delim, int* numSplits )
{
char** ret;
int retLen;
char* c;
if ( ( str == NULL ) ||
( delim == '\0' ) )
{
/* Either of those will cause problems */
ret = NULL;
retLen = -1;
}
else
{
retLen = 0;
c = str;
/* Pre-calculate number of elements */
do
{
if ( *c == delim )
{
retLen++;
}
c++;
} while ( *c != '\0' );
ret = malloc( ( retLen + 1 ) * sizeof( *ret ) );
ret[retLen] = NULL;
c = str;
retLen = 1;
ret[0] = str;
do
{
if ( *c == delim )
{
ret[retLen++] = &c[1];
*c = '\0';
}
c++;
} while ( *c != '\0' );
}
if ( numSplits != NULL )
{
*numSplits = retLen;
}
return ret;
}
int main( int argc, char* argv[] )
{
const char* str = "JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC";
char* strCpy;
char** split;
int num;
int i;
strCpy = malloc( strlen( str ) * sizeof( *strCpy ) );
strcpy( strCpy, str );
split = str_split( strCpy, ',', &num );
if ( split == NULL )
{
puts( "str_split returned NULL" );
}
else
{
printf( "%i Results: \n", num );
for ( i = 0; i < num; i++ )
{
puts( split[i] );
}
}
free( split );
free( strCpy );
return 0;
}

Il y a probablement un plus propre façon de le faire, mais vous obtenez l'idée.

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
/**
*  splits str on delim and dynamically allocates an array of pointers.
*
*  On error -1 is returned, check errno
*  On success size of array is returned, which may be 0 on an empty string
*  or 1 if no delim was found.  
*
*  You could rewrite this to return the char ** array instead and upon NULL
*  know it's an allocation problem but I did the triple array here.  Note that
*  upon the hitting two delim's in a row "foo,,bar" the array would be:
*  { "foo", NULL, "bar" } 
* 
*  You need to define the semantics of a trailing delim Like "foo," is that a
*  2 count array or an array of one?  I choose the two count with the second entry
*  set to NULL since it's valueless.
*  Modifies str so make a copy if this is a problem
*/
int split( char * str, char delim, char ***array, int *length ) {
char *p;
char **res;
int count=0;
int k=0;
p = str;
//Count occurance of delim in string
while( (p=strchr(p,delim)) != NULL ) {
*p = 0; //Null terminate the deliminator.
p++; //Skip past our new null
count++;
}
//allocate dynamic array
res = calloc( 1, count * sizeof(char *));
if( !res ) return -1;
p = str;
for( k=0; k<count; k++ ){
if( *p ) res[k] = p;  //Copy start of string
p = strchr(p, 0 );    //Look for next null
p++; //Start of next string
}
*array = res;
*length = count;
return 0;
}
char str[] = "JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC,";
int main() {
char **res;
int k=0;
int count =0;
int rc;
rc = split( str, ',', &res, &count );
if( rc ) {
printf("Error: %s errno: %d \n", strerror(errno), errno);
}
printf("count: %d\n", count );
for( k=0; k<count; k++ ) {
printf("str: %s\n", res[k]);
}
free(res );
return 0;
}

Essayer de l'utiliser.

char** strsplit(char* str, const char* delim){
char** res = NULL;
char*  part;
int i = 0;
char* aux = strdup(str);
part = strdup(strtok(aux, delim));
while(part){
res = (char**)realloc(res, (i + 1) * sizeof(char*));
*(res + i) = strdup(part);
part = strdup(strtok(NULL, delim));
i++;
}
res = (char**)realloc(res, i * sizeof(char*));
*(res + i) = NULL;
return res;
}

Je pense que la solution suivante est l'idéal:

• Ne pas détruire la source de la chaîne de
• Ré-entrant - c'est à dire, vous pouvez appeler en toute sécurité à partir de n'importe où dans un ou plusieurs threads
• Portable
• Gère plusieurs séparateurs correctement
• Rapide et efficace

Explication du code:

1. Définir une structure token pour stocker l'adresse et les longueurs des jetons
2. Allouer suffisamment de mémoire pour ces, dans le pire des cas, ce qui est quand
   str est entièrement composée de séparateurs il y a donc strlen(str) + 1
   jetons, toutes les cordes à vide
3. Analyse str l'enregistrement de l'adresse et la longueur de chaque jeton
4. L'utiliser pour allouer le tableau de sortie de la taille appropriée, y compris un espace supplémentaire pour un NULL sentinelle valeur
5. Allouer, copier et ajouter des jetons à l'aide de la démarrer et de la longueur
   de l'information - utiliser memcpy comme il est plus rapide que strcpy et nous savons
   les longueurs
6. Gratuit le jeton adresse et la longueur de la matrice de
7. Retourner un tableau des jetons de

typedef struct {
const char *start;
size_t len;
} token;
char **split(const char *str, char sep)
{
char **array;
unsigned int start = 0, stop, toks = 0, t;
token *tokens = malloc((strlen(str) + 1) * sizeof(token));
for (stop = 0; str[stop]; stop++) {
if (str[stop] == sep) {
tokens[toks].start = str + start;
tokens[toks].len = stop - start;
toks++;
start = stop + 1;
}
}
/* Mop up the last token */
tokens[toks].start = str + start;
tokens[toks].len = stop - start;
toks++;
array = malloc((toks + 1) * sizeof(char*));
for (t = 0; t < toks; t++) {
/* Calloc makes it nul-terminated */
char *token = calloc(tokens[t].len + 1, 1);
memcpy(token, tokens[t].start, tokens[t].len);
array[t] = token;
}
/* Add a sentinel */
array[t] = NULL; 
free(tokens);
return array;
}

Note malloc vérification omis par souci de concision.

En général, je ne voudrais pas retourner un tableau de char * pointeurs à partir d'une fonction de répartition comme ça car il donne beaucoup de responsabilités sur les appelant à libérer correctement. Une interface que je préfère est de permettre à l'appelant de passer d'une fonction de rappel et d'appel pour chaque jeton, comme je l'ai décrit ici: Découper une Chaîne en C.

C'est une chaîne de fractionnement fonction qui permet de gérer le multi-caractères délimiteurs. Notez que si le délimiteur est plus longue que la chaîne est de split, puis buffer et stringLengths sera mis à (void *) 0, et numStrings sera mis à 0.

Cet algorithme a été testé et fonctionne. (Avertissement: Il n'a pas été testé pour les non-ASCII cordes, et il suppose que l'appelant a donné des paramètres valides)

void splitString(const char *original, const char *delimiter, char ** * buffer, int * numStrings, int * * stringLengths){
const int lo = strlen(original);
const int ld = strlen(delimiter);
if(ld > lo){
*buffer = (void *)0;
*numStrings = 0;
*stringLengths = (void *)0;
return;
}
*numStrings = 1;
for(int i = 0;i < (lo - ld);i++){
if(strncmp(&original[i], delimiter, ld) == 0) {
i += (ld - 1);
(*numStrings)++;
}
}
*stringLengths = (int *) malloc(sizeof(int) * *numStrings);
int currentStringLength = 0;
int currentStringNumber = 0;
int delimiterTokenDecrementCounter = 0;
for(int i = 0;i < lo;i++){
if(delimiterTokenDecrementCounter > 0){
delimiterTokenDecrementCounter--;
} else if(i < (lo - ld)){
if(strncmp(&original[i], delimiter, ld) == 0){
(*stringLengths)[currentStringNumber] = currentStringLength;
currentStringNumber++;
currentStringLength = 0;
delimiterTokenDecrementCounter = ld - 1;
} else {
currentStringLength++;
}
} else {
currentStringLength++;
}
if(i == (lo - 1)){
(*stringLengths)[currentStringNumber] = currentStringLength;
}
}
*buffer = (char **) malloc(sizeof(char *) * (*numStrings));
for(int i = 0;i < *numStrings;i++){
(*buffer)[i] = (char *) malloc(sizeof(char) * ((*stringLengths)[i] + 1));
}
currentStringNumber = 0;
currentStringLength = 0;
delimiterTokenDecrementCounter = 0;
for(int i = 0;i < lo;i++){
if(delimiterTokenDecrementCounter > 0){
delimiterTokenDecrementCounter--;
} else if(currentStringLength >= (*stringLengths)[currentStringNumber]){
(*buffer)[currentStringNumber][currentStringLength] = 0;
delimiterTokenDecrementCounter = ld - 1;
currentStringLength = 0;
currentStringNumber++;
} else {
(*buffer)[currentStringNumber][currentStringLength] = (char)original[i];
currentStringLength++;
}
}
buffer[currentStringNumber][currentStringLength] = 0;
}

Exemple de code:

int main(){
const char *string = "STRING-1 DELIM string-2 DELIM sTrInG-3";
char **buffer;
int numStrings;
int * stringLengths;
splitString(string, " DELIM ", &buffer, &numStrings, &stringLengths);
for(int i = 0;i < numStrings;i++){
printf("String: %s\n", buffer[i]);
}
}

Bibliothèques:

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

Mon code (testé):

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int dtmsplit(char *str, const char *delim, char ***array, int *length ) {
int i=0;
char *token;
char **res = (char **) malloc(0 * sizeof(char *));
/* get the first token */
token = strtok(str, delim);
while( token != NULL ) 
{
res = (char **) realloc(res, (i + 1) * sizeof(char *));
res[i] = token;
i++;
token = strtok(NULL, delim);
}
*array = res;
*length = i;
return 1;
}
int main()
{
int i;
int c = 0;
char **arr = NULL;
int count =0;
char str[80] = "JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC";
c = dtmsplit(str, ",", &arr, &count);
printf("Found %d tokens.\n", count);
for (i = 0; i < count; i++)
printf("string #%d: %s\n", i, arr[i]);
return(0);
}

Résultat:

Found 12 tokens.
string #0: JAN
string #1: FEB
string #2: MAR
string #3: APR
string #4: MAY
string #5: JUN
string #6: JUL
string #7: AUG
string #8: SEP
string #9: OCT
string #10: NOV
string #11: DEC

Si vous êtes prêt à utiliser une bibliothèque externe, je ne peux pas le recommander bstrlib assez. Il prend un peu plus de l'installation, mais est plus facile à utiliser sur le long terme.

Par exemple, diviser la chaîne ci-dessous, on crée d'abord un bstring avec le bfromcstr() appel. (Un bstring est un wrapper autour d'un char buffer).
Ensuite, diviser la chaîne sur des virgules, et sauvegarde le résultat dans un struct bstrList, qui a des champs qty et un tableau entry, qui est un tableau de bstrings.

bstrlib a de nombreuses autres fonctions pour fonctionner sur bstrings

Simple comme bonjour...

#include "bstrlib.h"
#include <stdio.h>
int main() {
int i;
char *tmp = "Hello,World,sak";
bstring bstr = bfromcstr(tmp);
struct bstrList *blist = bsplit(bstr, ',');
printf("num %d\n", blist->qty);
for(i=0;i<blist->qty;i++) {
printf("%d: %s\n", i, bstr2cstr(blist->entry[i], '_'));
}
}

Deux questions autour de cette question sont la gestion de la mémoire et de la sécurité des threads. Comme vous pouvez le voir sur de nombreux postes,
ce n'est pas une tâche facile à accomplir de façon transparente en C. j'ai souhaité une solution qui est:

• Thread-safe. (strtok n'est pas thread-safe)
• N'emploie pas de malloc ou un de ses dérivés (pour éviter les problèmes de gestion mémoire)
• Vérifie les limites du tableau sur les champs individuels (pour éviter segment de défauts sur des données inconnues)
• Fonctionne avec multi-octets séparateurs de champ (utf-8)
• ignore les champs supplémentaires dans l'entrée
• fournit douce routine d'erreur pour le champ non valide longueurs

La solution je suis venu répond à tous ces critères. C'est probablement un peu plus de travail pour le programme d'installation
que certains autres solutions posté ici, mais je pense que, dans la pratique, le travail supplémentaire en vaut la peine
afin d'éviter les pièges courants d'autres solutions.

#include <stdio.h>
#include <string.h>
struct splitFieldType {
char *field;
int   maxLength;
};
typedef struct splitFieldType splitField;
int strsplit(splitField *fields, int expected, const char *input, const char *fieldSeparator, void (*softError)(int fieldNumber,int expected,int actual))  {
int i;
int fieldSeparatorLen=strlen(fieldSeparator);
const char *tNext, *tLast=input;
for (i=0; i<expected && (tNext=strstr(tLast, fieldSeparator))!=NULL; ++i) {
int len=tNext-tLast;
if (len>=fields[i].maxLength) {
softError(i,fields[i].maxLength-1,len);
len=fields[i].maxLength-1;
}
fields[i].field[len]=0;
strncpy(fields[i].field,tLast,len);
tLast=tNext+fieldSeparatorLen;
}
if (i<expected) {
if (strlen(tLast)>fields[i].maxLength) {
softError(i,fields[i].maxLength,strlen(tLast));
} else {
strcpy(fields[i].field,tLast);
}
return i+1;
} else {
return i;
}
}
void monthSplitSoftError(int fieldNumber, int expected, int actual) {
fprintf(stderr,"monthSplit: input field #%d is %d bytes, expected %d bytes\n",fieldNumber+1,actual,expected);
}
int main() {
const char *fieldSeparator=",";
const char *input="JAN,FEB,MAR,APRI,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC,FOO,BAR";
struct monthFieldsType {
char field1[4];
char field2[4];
char field3[4];
char field4[4];
char field5[4];
char field6[4];
char field7[4];
char field8[4];
char field9[4];
char field10[4];
char field11[4];
char field12[4];
} monthFields;
splitField inputFields[12] = {
{monthFields.field1,  sizeof(monthFields.field1)},
{monthFields.field2,  sizeof(monthFields.field2)},
{monthFields.field3,  sizeof(monthFields.field3)},
{monthFields.field4,  sizeof(monthFields.field4)},
{monthFields.field5,  sizeof(monthFields.field5)},
{monthFields.field6,  sizeof(monthFields.field6)},
{monthFields.field7,  sizeof(monthFields.field7)},
{monthFields.field8,  sizeof(monthFields.field8)},
{monthFields.field9,  sizeof(monthFields.field9)},
{monthFields.field10, sizeof(monthFields.field10)},
{monthFields.field11, sizeof(monthFields.field11)},
{monthFields.field12, sizeof(monthFields.field12)}
};
int expected=sizeof(inputFields)/sizeof(splitField);
printf("input data: %s\n", input);
printf("expecting %d fields\n",expected);
int ct=strsplit(inputFields, expected, input, fieldSeparator, monthSplitSoftError);
if (ct!=expected) {
printf("string split %d fields, expected %d\n", ct,expected);
}
for (int i=0;i<expected;++i) {
printf("field %d: %s\n",i+1,inputFields[i].field);
}
printf("\n");
printf("Direct structure access, field 10: %s", monthFields.field10);
}

Ci-dessous est un exemple de compilation et de sortie. Notez que dans mon exemple, j'ai volontairement énoncé "AVRIL", de sorte que vous pouvez voir comment le soft erreur œuvres.

$ gcc strsplitExample.c && ./a.out
input data: JAN,FEB,MAR,APRIL,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC,FOO,BAR
expecting 12 fields
monthSplit: input field #4 is 5 bytes, expected 3 bytes
field 1: JAN
field 2: FEB
field 3: MAR
field 4: APR
field 5: MAY
field 6: JUN
field 7: JUL
field 8: AUG
field 9: SEP
field 10: OCT
field 11: NOV
field 12: DEC
Direct structure access, field 10: OCT

Profitez-en!