在C语言中使用strtok函数

Question

我需要使用strtok读取名字的姓和名并将其分隔。如何将这些名字存储在两个独立的char数组中，以便我可以分别使用它们？

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

int main ()
{
  char str[] ="test string.";
  char * test;
  test = strtok (str," ");
  while (test != NULL)
  {
    printf ("%s\n",test);
    test= strtok (NULL, " ");
  }
  return 0;
}

- shinjuo

---

我可以使用这些来读取字符数组直到一个空格吗？ - shinjuo

不，我的意思是“与strtok一起使用它们”。也就是说，将（由test指向的）标记复制到目标字符串中。 - Kerrek SB

@KerrekSB 尽管使用 strchr 和 strndup 会更快、更灵活（无需破坏输入）。 - sehe

@sehe：没错，有很多种方法可以解决这个问题。看起来楼主已经决定使用strtok了，所以我就跟着用了... - Kerrek SB

@KerrekSB：我仍然添加了一种不需要使用strtok的方法来解决这个问题。这样可以消除与strtok相关的所有问题。 - sehe

Answer 1

这是我对一个相当简单的分词助手的看法，它

• 将结果存储在动态增长的数组中
• 以 null 结尾的数组
• 确保输入字符串的安全性（strtok 修改了输入字符串，在 C99 中是 未定义行为，至少我认为是这样）

为了使代码可重入，使用非标准的 strtok_r。

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

char** tokenize(const char* input)
{
    char* str = strdup(input);
    int count = 0;
    int capacity = 10;
    char** result = malloc(capacity*sizeof(*result));

    char* tok=strtok(str," "); 

    while(1)
    {
        if (count >= capacity)
            result = realloc(result, (capacity*=2)*sizeof(*result));

        result[count++] = tok? strdup(tok) : tok;

        if (!tok) break;

        tok=strtok(NULL," ");
    } 

    free(str);
    return result;
}

int main ()
{
    char** tokens = tokenize("test string.");

    char** it;
    for(it=tokens; it && *it; ++it)
    {
        printf("%s\n", *it);
        free(*it);
    }

    free(tokens);
    return 0;
}

这里是一个无需使用strtok的重新实现版本（使用strpbrk替代）：

char** tokenize(const char* str)
{
    int count = 0;
    int capacity = 10;
    char** result = malloc(capacity*sizeof(*result));

    const char* e=str;

    if (e) do 
    {
        const char* s=e;
        e=strpbrk(s," ");

        if (count >= capacity)
            result = realloc(result, (capacity*=2)*sizeof(*result));

        result[count++] = e? strndup(s, e-s) : strdup(s);
    } while (e && *(++e));

    if (count >= capacity)
        result = realloc(result, (capacity+=1)*sizeof(*result));
    result[count++] = 0;

    return result;
}

- sehe

---

我认为 realloc 这一行应该是 sizeof(*result)，而不是 sizeof(result)，并且第一个参数明显应该是 result 而不是 realloc。 - Arkku

添加了一个不需要使用 strtok 函数的版本（使用 strpbrk 函数而不需要修改输入参数，这样会更高效）。 - sehe

strdup和strndup不是C标准，strtok_r也不是，它只是POSIX。 - user411313

据我所知，strdup 和 strtok_r 都是 IEEE Std 1003.1,2004 Edition 的一部分。很明显，strndup 很好用，但它很容易被封装（或者只需使用 strtok 版本）。 - sehe

char str[] ="test string." 这里的 str 是一个 char[13] 数组，非常安全并且可以被修改。（我不确定您所说的“ char [] 字面量”的意思） - u0b34a0f6ae

@kaizer.se：可能是我混淆了C99和C++03（我主要是C++程序员） - sehe

Answer 2

你需要将它们分别存储吗？将两个指针指向修改后的字符数组将产生两个独立且可用的字符串。

也就是说，我们将其转化为：

char str[] ="test string.";

转化为：

char str[] ="test\0string.";
             ^     ^
             |     |
char *s1 -----     |
char *s2 -----------

.

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

int main ()
{
  char str[] ="test string.";
  char *firstname = strtok(str, " ");
  char *lastname = strtok(NULL, " ");
  if (!lastname)
    lastname = "";
  printf("%s, %s\n", lastname, firstname);
  return 0;
}

- u0b34a0f6ae

Answer 3

那么使用 strcpy 呢：

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

#define MAX_NAMES 2

int main ()
{
  char str[] ="test string.";
  char *names[MAX_NAMES] = { 0 };
  char *test;
  int i = 0;

  test = strtok (str," ");
  while (test != NULL && i < MAX_NAMES)
  {
    names[i] = malloc(strlen(test)+1);
    strcpy(names[i++], test);
    test = strtok (NULL, " ");
  }

  for(i=0; i<MAX_NAMES; ++i)
  {
    if(names[i])
    {
      puts(names[i]);
      free(names[i]);
      names[i] = 0;
    }
  }
  return 0;
}

这段代码包含很多杂乱的内容来维护一个完整的程序并清理它的资源，但主要的目的是使用 strcpy 将每个标记复制到它自己的字符串中。

- Christian Rau

Answer 4

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


char** split(const char *str, const char *delimiter, size_t *len){
    char *text, *p, *first, **array;
    int c;
    char** ret;

    *len = 0;
    text=strdup(str);
    if(text==NULL) return NULL;
    for(c=0,p=text;NULL!=(p=strtok(p, delimiter));p=NULL, c++)//count item
        if(c==0) first=p; //first token top

    ret=(char**)malloc(sizeof(char*)*c+1);//+1 for NULL
    if(ret==NULL){
        free(text);
        return NULL;
    }
    strcpy(text, str+(first-text));//skip until top token
    array=ret;

    for(p=text;NULL!=(p=strtok(p, delimiter));p=NULL){
        *array++=p;
    }
    *array=NULL;
    *len=c;
    return ret;
}

void free4split(char** sa){
    char **array=sa;

    if(sa!=NULL){
        free(array[0]);//for text
        free(sa);      //for array
    }
}

int main(void){
    char str[] ="test string.";
    char **words;
    size_t len=0;
    int i;

    words = split(str, " \t\r\n,.", &len);

/*
    for(char **wk = words; *wk ;wk++){
        printf("%s\n", *wk);
    }
*/
    for(i = 0;i<len;++i){
        printf("%s\n", words[i]);
    }
    free4split(words);
    return 0;
}
/* result:
test
string
*/

- BLUEPIXY

Answer 5

将来自 strtok 的结果复制到一个新的缓冲区中，使用一个函数，比如说。

/*
 * Returns a copy of s in freshly allocated memory.
 * Exits the process if memory allocation fails.
 */
char *xstrdup(char const *s)
{
    char *p = malloc(strlen(s) + 1);
    if (p == NULL) {
        perror("memory allocation failed");
        exit(1);
    }
    strcpy(p, s);
    return p;
}

不要忘记在使用完返回值后调用free。

- Fred Foo

Answer 6

在我看来，你根本不需要（也可能不想）使用strtok（就是说，“对于这个问题或其他大部分问题都不需要”）。我认为我会使用类似以下的代码：

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

static char *make_str(char const *begin, char const *end) { 
    size_t len = end-begin;
    char *ret = malloc(len+1);
    if (ret != NULL) {
        memcpy(ret, begin, len);
        ret[len]='\0';
    }
    return ret;
}

size_t tokenize(char *tokens[], size_t max, char const *input, char const *delims) { 
    int i;
    char const *start=input, *end=start;

    for (i=0; *start && i<max; i++) {
        for ( ;NULL!=strchr(delims, *start); ++start)
            ;
        for (end=start; *end && NULL==strchr(delims, *end); ++end)
            ;
        tokens[i] = make_str(start, end);
        start = end+1;
    }
    return i;
}

#ifdef TEST

#define MAX_TOKENS 10

int main() { 
    char *tokens[MAX_TOKENS];
    int i;
    size_t num = tokenize(tokens, MAX_TOKENS, "This is a longer input string ", " ");
    for (i=0; i<num; i++) {
        printf("|%s|\n", tokens[i]);
        free(tokens[i]);
    }
    return 0;
}

#endif

- Jerry Coffin

Answer 7

你也可以像这样做。

    int main ()
    {
    char str[] ="test string.";

    char * temp1;
    char * temp2; 

    temp1 = strtok (str," ");

    temp2 = strchr(str, ' '); 
    if (temp2 != NULL)
        temp2++;

    printf ("Splitted string :%s, %s\n" , temp1 , temp2);
    return 
    }

- Thulasi