用多个空格在C中断开字符串

Question

Ok, so my code currently splits a single string like this: "hello world" into:

hello
world

But when I have multiple spaces in between, before or after within the string, my code doesn't behave. It takes that space and counts it as a word/number to be analyzed. For example, if I put in two spaces in between hello and world my code would produce:

hello
(a space character)
world

The space is actually counted as a word/token.

int counter = 0;
int index = strcur->current_index;
char *string = strcur->myString;

char token_buffer = string[index];

while(strcur->current_index <= strcur->end_index)
{
    counter = 0;
    token_buffer = string[counter+index];
    while(!is_delimiter(token_buffer) && (index+counter)<=strcur->end_index)//delimiters are: '\0','\n','\r',' '
    {
        counter++;
        token_buffer = string[index+counter];
    }

    char *output_token = malloc(counter+1);
    strncpy(output_token,string+index,counter);
    printf("%s \n", output_token);
    TKProcessing(output_token);

    //update information
    counter++;    
    strcur->current_index += counter;
    index += counter;
}

I can see the problem area in my loop, but I'm a bit stumped as to how to fix this. Any help would be must appreciated.

Answer 1

From a coding stand point, if you wanted to know how to do this without a library as an exercise, what's happening is your loop breaks after you run into the first delimeter. Then when you loop to the second delimeter, you don't enter the second while loop and print a new line again. You can put

//update information
while(is_delimiter(token_buffer) && (index+counter)<=strcur->end_index)
{
    counter++;
    token_buffer = string[index+counter];
}

Answer 2

Use the standard C library function strtok().

Rather than redevelop such a standard function.

Here's the related related manual page .

Can use as following in your case:

#include <string.h>
char *token;    

token = strtok (string, " \r\n");
// do something with your first token
while (token != NULL)
{
  // do something with subsequents tokens
  token = strtok (NULL, " \r\n");
}

As you can observe, each subsequent call to strtok using the same arguments will send you back a char* adressing to the next token.

In the case you're working on a threaded program, you might use strtok_r() C function.

First call to it should be the same as strtok(), but subsequent calls are done passing NULL as the first argument. :

#include <string.h>
char *token;
char *saveptr;

token = strtok_r(string, " \r\n", &saveptr)
// do something with your first token
while (token != NULL)
{
   // do something with subsequents tokens
   token = strtok_r(NULL, " \r\n", &saveptr)
}

Answer 3

Just put the process token logic into a if(counter > 0){...} , which makes malloc happen only when there was a real token. like this

if(counter > 0){ // it means has a real word, not delimeters 
   char *output_token = malloc(counter+1);
   strncpy(output_token,string+index,counter);
   printf("%s \n", output_token);
   TKProcessing(output_token);
}