Split-string-mit-Trennzeichen in C

Können Sie die strtok() Funktion zum aufteilen einer Zeichenkette (und geben Sie das Trennzeichen zu verwenden). Beachten Sie, dass strtok() wird, ändern Sie die Zeichenfolge an Sie übergeben. Wenn die ursprüngliche Zeichenfolge erforderlich ist anderswo kopieren Sie es und geben Sie die Kopie an strtok().

EDIT:

Beispiel (Hinweis: es behandelt nicht aufeinander folgende Trennzeichen, "JAN, FEB,MAR" zum Beispiel):

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

char** str_split(char* a_str, const char a_delim)
{
    char** result    = 0;
    size_t count     = 0;
    char* tmp        = a_str;
    char* last_comma = 0;
    char delim[2];
    delim[0] = a_delim;
    delim[1] = 0;

    /* Count how many elements will be extracted. */
    while (*tmp)
    {
        if (a_delim == *tmp)
        {
            count++;
            last_comma = tmp;
        }
        tmp++;
    }

    /* Add space for trailing token. */
    count += last_comma < (a_str + strlen(a_str) - 1);

    /* Add space for terminating null string so caller
       knows where the list of returned strings ends. */
    count++;

    result = malloc(sizeof(char*) * count);

    if (result)
    {
        size_t idx  = 0;
        char* token = strtok(a_str, delim);

        while (token)
        {
            assert(idx < count);
            *(result + idx++) = strdup(token);
            token = strtok(0, delim);
        }
        assert(idx == count - 1);
        *(result + idx) = 0;
    }

    return result;
}

int main()
{
    char months[] = "JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC";
    char** tokens;

    printf("months=[%s]\n\n", months);

    tokens = str_split(months, ',');

    if (tokens)
    {
        int i;
        for (i = 0; *(tokens + i); i++)
        {
            printf("month=[%s]\n", *(tokens + i));
            free(*(tokens + i));
        }
        printf("\n");
        free(tokens);
    }

    return 0;
}

Ausgabe:

$ ./main.exe
months=[JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC]

month=[JAN]
month=[FEB]
month=[MAR]
month=[APR]
month=[MAY]
month=[JUN]
month=[JUL]
month=[AUG]
month=[SEP]
month=[OCT]
month=[NOV]
month=[DEC]

InformationsquelleAutor hmjd

String tokenizer dieser code sollte dich in die richtige Richtung.

int main(void) {
  char st[] ="Where there is will, there is a way.";
  char *ch;
  ch = strtok(st, " ");
  while (ch != NULL) {
  printf("%s\n", ch);
  ch = strtok(NULL, " ,");
  }
  getch();
  return 0;
}

InformationsquelleAutor thenetimp

Hier ist meine zwei Cent:

int split (const char *txt, char delim, char ***tokens)
{
    int *tklen, *t, count = 1;
    char **arr, *p = (char *) txt;

    while (*p != '\0') if (*p++ == delim) count += 1;
    t = tklen = calloc (count, sizeof (int));
    for (p = (char *) txt; *p != '\0'; p++) *p == delim ? *t++ : (*t)++;
    *tokens = arr = malloc (count * sizeof (char *));
    t = tklen;
    p = *arr++ = calloc (*(t++) + 1, sizeof (char *));
    while (*txt != '\0')
    {
        if (*txt == delim)
        {
            p = *arr++ = calloc (*(t++) + 1, sizeof (char *));
            txt++;
        }
        else *p++ = *txt++;
    }
    free (tklen);
    return count;
}

Verwendung:

char **tokens;
int count, i;
const char *str = "JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC";

count = split (str, ',', &tokens);
for (i = 0; i < count; i++) printf ("%s\n", tokens[i]);

/* freeing tokens */
for (i = 0; i < count; i++) free (tokens[i]);
free (tokens);

InformationsquelleAutor razzak

Diese Funktion einen char* - string und teilt es durch die deliminator. Es können mehrere deliminators in einer Reihe. Beachten Sie, dass die Funktion verändert den originalen string. Sie müssen eine Kopie der original-string zuerst, wenn Sie brauchen die Originale bleiben unverändert. Diese Funktion benutzt keine cstring-Funktion aufruft, so ist es vielleicht ein wenig schneller als andere. Wenn Sie kümmern sich nicht um die Speicherreservierung, die Sie zuordnen können sub_strings am Anfang der Funktion mit Größe strlen(src_str)/2 und (wie die c++ "version" genannt) überspringen Sie die untere Hälfte der Funktion. Wenn Sie dies tun, die Funktion reduziert sich auf O(N), aber der Speicher optimiert unten gezeigt wird, ist O(2N).

Die Funktion:

char** str_split(char *src_str, const char deliminator, size_t &num_sub_str){
  //replace deliminator's with zeros and count how many
  //sub strings with length >= 1 exist
  num_sub_str = 0;
  char *src_str_tmp = src_str;
  bool found_delim = true;
  while(*src_str_tmp){
    if(*src_str_tmp == deliminator){
      *src_str_tmp = 0;
      found_delim = true;
    }
    else if(found_delim){ //found first character of a new string
      num_sub_str++;
      found_delim = false;
      //sub_str_vec.push_back(src_str_tmp); //for c++
    }
    src_str_tmp++;
  }
  printf("Start - found %d sub strings\n", num_sub_str);
  if(num_sub_str <= 0){
    printf("str_split() - no substrings were found\n");
    return(0);
  }

  //if you want to use a c++ vector and push onto it, the rest of this function
  //can be omitted (obviously modifying input parameters to take a vector, etc)

  char **sub_strings = (char **)malloc( (sizeof(char*) * num_sub_str) + 1);
  const char *src_str_terminator = src_str_tmp;
  src_str_tmp = src_str;
  bool found_null = true;
  size_t idx = 0;
  while(src_str_tmp < src_str_terminator){
    if(!*src_str_tmp) //found a NULL
      found_null = true;
    else if(found_null){
      sub_strings[idx++] = src_str_tmp;
      //printf("sub_string_%d: [%s]\n", idx-1, sub_strings[idx-1]);
      found_null = false;
    }
    src_str_tmp++;
  }
  sub_strings[num_sub_str] = NULL;

  return(sub_strings);
}

, Wie es zu benutzen:

  char months[] = "JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC";
  char *str = strdup(months);
  size_t num_sub_str;
  char **sub_strings = str_split(str, ',', num_sub_str);
  char *endptr;
  if(sub_strings){
    for(int i = 0; sub_strings[i]; i++)
      printf("[%s]\n", sub_strings[i]);
  }
  free(sub_strings);
  free(str);

InformationsquelleAutor Sam Petrocelli

Versuchen, verwenden Sie diese.

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

InformationsquelleAutor David Jr.

Dies ist ein string-splitting-Funktion kann mit den multi-Charakter-Trennzeichen. Beachten Sie, dass, wenn das Trennzeichen ist länger als der string, der aufgeteilt wird, dann buffer und stringLengths auf (void *) 0, und numStrings auf 0.

Dieser Algorithmus wurde getestet und funktioniert. (Disclaimer: Es wurde nicht getestet, für nicht-ASCII-strings, und es wird davon ausgegangen, dass der Anrufer gab Gültiger Parameter)

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

Beispielcode:

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

Bibliotheken:

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

InformationsquelleAutor Élektra

Diese optimierte Methode erstellen (oder ein vorhandenes aktualisieren) array von Zeigern in *result und gibt die Anzahl der Elemente in *zählen.

Verwenden Sie "max", um anzugeben, die maximale Anzahl der Zeichenfolgen, die Sie erwarten (wenn Sie angeben, dass ein vorhandenes array oder jede andere reaseon), sonst setzen Sie es auf 0

Zu vergleichen mit einer Liste von Trennzeichen definieren delim als char* und ersetzen Sie die Zeile:

if (str[i]==delim) {

mit den folgenden zwei Zeilen:

 char *c=delim; while(*c && *c!=str[i]) c++;
 if (*c) {

Genießen

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

char **split(char *str, size_t len, char delim, char ***result, unsigned long *count, unsigned long max) {
  size_t i;
  char **_result;

  //there is at least one string returned
  *count=1;

  _result= *result;

  //when the result array is specified, fill it during the first pass
  if (_result) {
    _result[0]=str;
  }

  //scan the string for delimiter, up to specified length
  for (i=0; i<len; ++i) {

    //to compare against a list of delimiters,
    //define delim as a string and replace 
    //the next line:
    //    if (str[i]==delim) {
    //
    //with the two following lines:
    //    char *c=delim; while(*c && *c!=str[i]) c++;
    //    if (*c) {
    //      
    if (str[i]==delim) {

      //replace delimiter with zero
      str[i]=0;

      //when result array is specified, fill it during the first pass
      if (_result) {
        _result[*count]=str+i+1;
      }

      //increment count for each separator found
      ++(*count);

      //if max is specified, dont go further
      if (max && *count==max)  {
        break;
      }

    }
  }

  //when result array is specified, we are done here
  if (_result) {
    return _result;
  }

  //else allocate memory for result
  //and fill the result array                                                                                    

  *result=malloc((*count)*sizeof(char*));
  if (!*result) {
    return NULL;
  }
  _result=*result;

  //add first string to result
  _result[0]=str;

  //if theres more strings
  for (i=1; i<*count; ++i) {

    //find next string
    while(*str) ++str;
    ++str;

    //add next string to result
    _result[i]=str;

  }

  return _result;
}  

Beispiel:

#include <stdio.h>

int main(int argc, char **argv) {
  char *str="JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC";
  char **result=malloc(6*sizeof(char*));
  char **result2=0;
  unsigned long count;
  unsigned long count2;
  unsigned long i;

  split(strdup(str),strlen(str),',',&result,&count,6);
  split(strdup(str),strlen(str),',',&result2,&count2,0);

  if (result)
  for (i=0; i<count; ++i) {
    printf("%s\n",result[i]);
  }

  printf("\n");

  if (result2)
  for (i=0; i<count2; ++i) {
    printf("%s\n", result2[i]);
  }

  return 0;

}

InformationsquelleAutor luxigo

Ich denke, die folgende Lösung ist ideal:

• Nicht zerstören, die Quelle string
• Re-entrant, d.h., Sie können sicher nennen Sie es von überall aus in einem oder mehreren threads
• Portable
• Behandelt mehrere Separatoren richtig
• Schnelle und effiziente

Erklärung des Codes:

1. Definieren Sie eine Struktur token zu speichern, die Adresse und die Länge des Token
2. Genügend Speicher für diese im schlimmsten Fall, was ist wenn
   str ist völlig Separatoren, so gibt es strlen(str) + 1
   Token, alle leeren Saiten
3. Scan str Aufnahme der Adresse und Länge jedes token
4. Verwenden Sie diese zur Zuordnung der Ausgabe-array in der richtigen Größe, einschließlich ein extra Raum für eine NULL sentinel-Wert
5. Zuweisen, kopieren und fügen Sie den Token mit dem start-und Länge
   Informationen - Verwendung memcpy wie es ist schneller als strcpy und wir wissen
   die Längen
6. Kostenlos die token-Adresse und Länge-array
7. Return array von Token

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

Hinweis: malloc überprüfung der Kürze halber weggelassen.

Im Allgemeinen, ich würde nicht geben ein array zurück, der char * Tipps von einem split-Funktion wie diese, da es Orte, die eine Menge Verantwortung auf den Anrufer zu befreien, Sie richtig. Eine Schnittstelle, die ich bevorzuge, ist, damit der Anrufer zu übergeben, eine callback-Funktion und rufen Sie diese für jede Spielfigur, wie ich Sie hier geschildert habe: Split einen String in C.

InformationsquelleAutor Martin Broadhurst

Nicht getestet, wahrscheinlich falsch, aber sollte geben Sie Ihnen einen guten Vorsprung, wie es funktionieren sollte:

*char[] str_split(char* str, char delim) {

    int begin = 0;
    int end = 0;
    int j = 0;
    int i = 0;
    char *buf[NUM];

    while (i < strlen(str)) {

        if(*str == delim) {

            buf[j] = malloc(sizeof(char) * (end-begin));
            strncpy(buf[j], *(str + begin), (end-begin));
            begin = end;
            j++;

        }

        end++;
        i++;

    }

    return buf;

}

InformationsquelleAutor jn1kk

Wenn Sie bereit sind zu verwenden, um eine externe Bibliothek handelt, kann ich nicht empfehlen bstrlib genug. Es dauert ein wenig zusätzliche setup, aber ist einfacher zu bedienen, auf lange Sicht.

Zum Beispiel, teilen Sie die Zeichenfolge unten, man erstellt zunächst ein bstring mit der bfromcstr() nennen. (Ein bstring ist ein wrapper um einen char-buffer).
Als Nächstes split den string an den Kommas, speichern das Ergebnis in einer struct bstrList, die Felder qty und ein array entry, die ein array von bstrings.

bstrlib hat viele weitere Funktionen zu bedienen, die auf bstrings

Easy as pie...

#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], '_'));
  }

}

InformationsquelleAutor SAK

Für: Hassan A. El-Seoudy

Dein ticket geschlossen ist, so kann ich nicht darauf eingehen ^^'.
Aber Sie können versuchen, diese:

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

int     countChar(char *str)
{
  int   count;
  int   i;

  i = 0;
  count = 0;
  while (str[i] != '=') //our delimiter character
    {
      i++;
      count++;
    }

  return (count);
}

void    split(char *str)
{
  int   i;
  int   j;
  int   count;
  int   restCount;
  char  *str1;
  char  *str2;

  i = 0;
  j = 0;
  count = countChar(str) - 1; //we have our str1 lenght, -1 for the ' '
  restCount = (strlen(str) - count) -1; //we have our str2 legnht, -1 for the ' '
  str1 = malloc(sizeof(char) * count);
  str2 = malloc(sizeof(char) * restCount);

  while(i < count)
    {
      str1[i] = str[i++];
    }
  i = i + 2; //to jump directly to the first char of our str2 (no ' = ')
  while (str[i])
    {
      str2[j++] = str[i++];
    }
  printf("str1 = %s, str2 = %s\n", str1, str2);
}

int     main()
{
  char  *str = "Xo = 100k";

  split(str);

  return (0);
}'

InformationsquelleAutor Hugo Lanoix

static int count_token(char *iptr, char delim) {

        int token_count = 0;
        while (*iptr && isspace(*iptr))
            iptr++;
        while (*iptr) {
            if ((*iptr != delim)) {
                token_count++;
                while (*iptr && (*iptr != delim))
                    iptr++;
            }
            else {
                iptr++;
            }
        }
        return token_count;
    }

    static char** split(char* input, int* argc){
        char**  argv;
        int token_count = count_token(input, ' ');
        argv = (char**)malloc(sizeof(char*)*token_count);

        int i = 0;
        char *token = strtok(input, " ");
        while(token) {
            puts(token);
            argv[i] = strdup(token);
            token = strtok(NULL, " ");
            i++;
        }
        assert(i == token_count);
        *argc = token_count;
        return argv;
    }

InformationsquelleAutor Pankaj

Dies ist anderen Ansatz, arbeiten für große Dateien zu.

/******************************************************************************

                            Online C Compiler.
                Code, Compile, Run and Debug C program online.
Write your code in this editor and press "Run" button to compile and execute it.

*******************************************************************************/

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

char* aux_slice(const char* str, char delimiter, const char** pRet);
char **split(const char *str, char delimiter, int *ret_size);



int main()
{
    int count = 0, i = 0;
    char** splits = split(",,, 1,2,3,4,5,6,7,8,9,10, aaaa, a,a a,aa,,a,,,,a,a a,a a,a,,,,,ashajhsas asjas,,a,a,,aa"
    "aaaaaaaaaaa.......,p,p,p,p,p,p,p, this is last,,,,,,,,,,", ',', &count);
    printf("Strings (%d)\n", count); 
    for (i=0 ; i < count; i++) {
        printf("%s\n", splits[i]);
    }
    for(i=0; i < count; i++) {
        free(splits[i]);
    }
    free(splits); 
    return 0;
}




char* aux_slice(const char* str, char delimiter, const char** pRet)
{
    int size = 0, i = 0;
    const char* begin = str;
    char  *ret = NULL;
    int match = 0;

    if (!str) {
        return NULL;
    }

    while (*begin != '\0') {
        if (*begin == delimiter) {
            match++;
            break;
        }
        size++;
        begin++;
    }

    ret = (char*)malloc(sizeof(char) * size);

    if(ret == NULL) {
        return NULL;
    }

    if (match) {
        /* we have a delimiter ??? */
        for(i = 0; str[i] != delimiter; ++i) {
            ret[i] = str[i];
        }

        ret[i] = '\0';

        while (*begin == delimiter) {
            begin++;
        }
        (*pRet) = begin;

    } else {
        /* or we just copy the remaining string.... */
        for(i=0; str[i] != '\0'; ++i) {
            ret[i] = str[i];
        }
        ret[i] = '\0';
        (*pRet) = NULL;
    }

    return ret;
}


char **split(const char *str, char delimiter, int *ret_size)
{
    int diff = 0, splits = 0, i=0;
    const char* begin = str;
    const char* end = &str[strlen(str)-1];
    while (*begin == delimiter) begin++;
    while (*end == delimiter) end--;
    diff = (end - begin)+1;

    while (i < diff) {
        //avoid cases of adjacent delimiters
        //like "str1,str2,,,,,str3
        if (begin[i] == delimiter) {
            while (begin[i] == delimiter) i++;
            splits++;
        }
        i++;
    }
    splits += 1;
    *ret_size = splits;
    char** split_str = (char**)malloc(sizeof(char**)*splits);

    if (split_str == NULL) {
        return NULL;
    }
    for(i=0; i < splits; ++i) {
        split_str[i] = aux_slice(begin, delimiter, &begin);
    }
    return split_str;
}