C 语言中 strtok() 如何将字符串拆分为标记？

Question

请向我解释一下strtok()函数的工作原理。手册说它将字符串分成标记。我无法从手册中理解它的实际作用。

我在 str 和 *pch 上添加了监视，以在第一个 while 循环发生时检查其工作情况，str 的内容只是“this”。下面所示的输出是如何打印在屏幕上的？

/* strtok example */
#include <stdio.h>
#include <string.h>

int main ()
{
  char str[] ="- This, a sample string.";
  char * pch;
  printf ("Splitting string \"%s\" into tokens:\n",str);
  pch = strtok (str," ,.-");
  while (pch != NULL)
  {
    printf ("%s\n",pch);
    pch = strtok (NULL, " ,.-");
  }
  return 0;
}

输出：

Splitting string "- This, a sample string." into tokens:
This
a
sample
string

Answer 1

strtok 运行时函数的工作方式如下：

第一次调用 strtok 时，您提供了一个要

char s[] = "this is a string";

在上面的字符串空间中标记的字符串，这似乎是单词之间的一个很好的分隔符，所以让我们使用它：

char* p = strtok(s, " ");

现在发生的情况是搜索 's'直到找到空格字符，返回第一个标记（'this'）并且 p 指向该标记（字符串）

以便获取下一个标记并继续使用相同的字符串 NULL 作为第一个传递
参数，因为 strtok 维护指向先前传递的字符串的静态指针：

p = strtok(NULL," ");

p 现在指向“is”

，依此类推，直到找不到更多空格，然后将最后一个字符串作为最后一个标记“string”返回'。

更方便的是，您可以这样写，而不是打印出所有令牌：

for (char *p = strtok(s," "); p != NULL; p = strtok(NULL, " "))
{
  puts(p);
}

编辑：

如果您想存储从strtok返回的值，您需要将令牌复制到另一个缓冲区例如strdup(p);，因为原始字符串（由strtok内的静态指针指向）在迭代之间被修改以返回令牌。

Answer 2

strtok() 将字符串划分为标记。即从任何一个分隔符开始到下一个分隔符将是您的一个标记。在您的情况下，起始标记将从“-”开始，并以下一个空格“”结束。然后下一个标记将从“ ”开始并以“，”结束。在这里你得到“This”作为输出。类似地，字符串的其余部分被从一个空格到另一个空格分割成标记，最后以“.”结束最后一个标记。

Answer 3

strtok 维护一个静态的内部引用，指向字符串中的下一个可用标记；如果你向它传递一个 NULL 指针，它将从该内部引用开始工作。

这就是 strtok 不可重入的原因；一旦你向它传递一个新的指针，旧的内部引用就会被破坏。

Answer 4

strtok 将标记一个字符串，即将其转换为一系列子字符串。

它通过搜索分隔这些标记（或子字符串）的分隔符来实现这一点。并且您指定分隔符。就您而言，您需要“ ”或“，”或“。”或“-”作为分隔符。

提取这些标记的编程模型是手动 strtok 主字符串和分隔符集。然后重复调用它，每次 strtok 都会返回它找到的下一个标记。直到到达主字符串的末尾，此时返回 null。另一个规则是仅在第一次传递字符串，随后的时间传递 NULL。这是一种告诉 strtok 您是否正在使用新字符串开始新的标记化会话，或者您是否正在从先前的标记化会话中检索标记的方法。请注意，strtok 会记住其标记化会话的状态。因此，它不是可重入的或线程安全的（您应该使用 strtok_r 代替）。另一件需要知道的事情是它实际上修改了原始字符串。它为找到的分隔符写入“\0”。

简而言之，调用 strtok 的一种方法如下：

char str[] = "this, is the string - I want to parse";
char delim[] = " ,-";
char* token;

for (token = strtok(str, delim); token; token = strtok(NULL, delim))
{
    printf("token=%s\n", token);
}

结果：

this
is
the
string
I
want
to
parse

Answer 5

strtok 不会更改参数本身 (str)。它存储该指针（在局部静态变量中）。然后，它可以在后续调用中更改该参数指向，而无需将参数传回。 （并且它可以推进它所保留的指针，但是它需要执行其操作。）

来自 POSIX strtok 页面：

此函数使用静态存储来跟踪调用之间的当前字符串位置。

有一个线程安全变体 (strtok_r) 无法实现这种类型的魔法。

Answer 6

第一次调用它时，您需要向 strtok 提供要标记化的字符串。然后，要获取以下标记，只需将 NULL 赋予该函数，只要它返回非 NULL 指针即可。

strtok 函数记录您在调用它时首次提供的字符串。 （这对于多线程应用程序来说确实很危险）

Answer 7

strtok 修改其输入字符串。它在其中放置空字符（'\0'），以便它将返回原始字符串的位作为标记。事实上strtok并不分配内存。如果将字符串绘制为一系列框，您可能会更好地理解它。

Answer 8

要了解 strtok() 的工作原理，首先需要知道什么是静态变量< /a> 是。 这个链接解释得很好......

strtok( 操作的关键) 保留连续调用之间最后一个分隔符的位置（这就是为什么 strtok() 继续解析使用 调用它时传递给它的原始字符串。连续调用中的空指针）。

看看我自己的 strtok() 实现，称为 zStrtok()，它的功能与由 strtok() 提供

char *zStrtok(char *str, const char *delim) {
    static char *static_str=0;      /* var to store last address */
    int index=0, strlength=0;           /* integers for indexes */
    int found = 0;                  /* check if delim is found */

    /* delimiter cannot be NULL
    * if no more char left, return NULL as well
    */
    if (delim==0 || (str == 0 && static_str == 0))
        return 0;

    if (str == 0)
        str = static_str;

    /* get length of string */
    while(str[strlength])
        strlength++;

    /* find the first occurance of delim */
    for (index=0;index<strlength;index++)
        if (str[index]==delim[0]) {
            found=1;
            break;
        }

    /* if delim is not contained in str, return str */
    if (!found) {
        static_str = 0;
        return str;
    }

    /* check for consecutive delimiters
    *if first char is delim, return delim
    */
    if (str[0]==delim[0]) {
        static_str = (str + 1);
        return (char *)delim;
    }

    /* terminate the string
    * this assignmetn requires char[], so str has to
    * be char[] rather than *char
    */
    str[index] = '\0';

    /* save the rest of the string */
    if ((str + index + 1)!=0)
        static_str = (str + index + 1);
    else
        static_str = 0;

        return str;
}

，这里是一个示例用法

  Example Usage
      char str[] = "A,B,,,C";
      printf("1 %s\n",zStrtok(s,","));
      printf("2 %s\n",zStrtok(NULL,","));
      printf("3 %s\n",zStrtok(NULL,","));
      printf("4 %s\n",zStrtok(NULL,","));
      printf("5 %s\n",zStrtok(NULL,","));
      printf("6 %s\n",zStrtok(NULL,","));

  Example Output
      1 A
      2 B
      3 ,
      4 ,
      5 C
      6 (null)

代码来自字符串处理库我在Github上维护，名为zString。看一下代码，甚至贡献一下:)
https://github.com/fnoyanisi/zString

Answer 9

这就是我实现 strtok 的方法，不是很好，但经过 2 小时的工作终于成功了。它确实支持多个分隔符。

#include "stdafx.h"
#include <iostream>
using namespace std;

char* mystrtok(char str[],char filter[]) 
{
    if(filter == NULL) {
        return str;
    }
    static char *ptr = str;
    static int flag = 0;
    if(flag == 1) {
        return NULL;
    }
    char* ptrReturn = ptr;
    for(int j = 0; ptr != '\0'; j++) {
        for(int i=0 ; filter[i] != '\0' ; i++) {
            if(ptr[j] == '\0') {
                flag = 1;
                return ptrReturn;
            }
            if( ptr[j] == filter[i]) {
                ptr[j] = '\0';
                ptr+=j+1;
                return ptrReturn;
            }
        }
    }
    return NULL;
}

int _tmain(int argc, _TCHAR* argv[])
{
    char str[200] = "This,is my,string.test";
    char *ppt = mystrtok(str,", .");
    while(ppt != NULL ) {
        cout<< ppt << endl;
        ppt = mystrtok(NULL,", ."); 
    }
    return 0;
}

Answer 10

对于那些仍然很难理解这个 strtok() 函数的人，请看一下这个 pythontutor 示例，它是可视化 C（或 C++、Python ...）代码的绝佳工具。

如果链接损坏，请粘贴：

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

int main()
{
    char s[] = "Hello, my name is? Matthew! Hey.";
    char* p;
    for (char *p = strtok(s," ,?!."); p != NULL; p = strtok(NULL, " ,?!.")) {
      puts(p);
    }
    return 0;
}

致谢人员转到 Anders K.

Answer 11

这是我的实现，它使用哈希表作为分隔符，这意味着它是 O(n) 而不是 O(n^2) （这里是代码链接）：

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

#define DICT_LEN 256

int *create_delim_dict(char *delim)
{
    int *d = (int*)malloc(sizeof(int)*DICT_LEN);
    memset((void*)d, 0, sizeof(int)*DICT_LEN);

    int i;
    for(i=0; i< strlen(delim); i++) {
        d[delim[i]] = 1;
    }
    return d;
}



char *my_strtok(char *str, char *delim)
{

    static char *last, *to_free;
    int *deli_dict = create_delim_dict(delim);

    if(!deli_dict) {
        /*this check if we allocate and fail the second time with entering this function */
        if(to_free) {
            free(to_free);
        }
        return NULL;
    }

    if(str) {
        last = (char*)malloc(strlen(str)+1);
        if(!last) {
            free(deli_dict);
            return NULL;
        }
        to_free = last;
        strcpy(last, str);
    }

    while(deli_dict[*last] && *last != '\0') {
        last++;
    }
    str = last;
    if(*last == '\0') {
        free(deli_dict);
        free(to_free);
        deli_dict = NULL;
        to_free = NULL;
        return NULL;
    }
    while (*last != '\0' && !deli_dict[*last]) {
        last++;
    }

    *last = '\0';
    last++;

    free(deli_dict);
    return str;
}

int main()
{
    char * str = "- This, a sample string.";
    char *del = " ,.-";
    char *s = my_strtok(str, del);
    while(s) {
        printf("%s\n", s);
        s = my_strtok(NULL, del);
    }
    return 0;
}

Answer 12

strtok() 将指针存储在静态变量中，因此在第二次调用时，当我们传递 null 时，strtok() 从静态变量中获取指针。

如果您提供相同的字符串名称，它将再次从头开始。

此外，strtok() 具有破坏性，即它会更改原始字符串。因此，请确保您始终拥有一份原件的副本。

使用 strtok() 的另一个问题是，由于它将地址存储在静态变量中，因此在多线程编程中多次调用 strtok() 会导致错误。为此，请使用 strtok_r()。

Answer 13

strtok 将第二个参数中的字符替换为 NULL，并且 NULL 字符也是字符串的结尾。

http://www.cplusplus.com/reference/clibrary/cstring/strtok/

Answer 14

您可以扫描字符数组来查找标记，如果发现它只是打印新行，否则打印字符。

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

int main()
{
    char *s;
    s = malloc(1024 * sizeof(char));
    scanf("%[^\n]", s);
    s = realloc(s, strlen(s) + 1);
    int len = strlen(s);
    char delim =' ';
    for(int i = 0; i < len; i++) {
        if(s[i] == delim) {
            printf("\n");
        }
        else {
            printf("%c", s[i]);
        }
    }
    free(s);
    return 0;
}

Answer 15

所以，这是一个代码片段，可以帮助更好地理解这个主题。

打印标记

任务：给定一个句子 s，在新行中打印该句子的每个单词。

char *s;
s = malloc(1024 * sizeof(char));
scanf("%[^\n]", s);
s = realloc(s, strlen(s) + 1);
//logic to print the tokens of the sentence.
for (char *p = strtok(s," "); p != NULL; p = strtok(NULL, " "))
{
    printf("%s\n",p);
}

输入： 怎么样

结果：

How
is
that

解释： 所以这里使用了“strtok()”函数，它是使用 for 循环迭代以在单独的行中打印标记。

该函数将采用“字符串”和“断点”作为参数，并在这些断点处中断字符串并形成标记。现在，这些令牌存储在“p”中并进一步用于打印。

Answer 16

strtok 将给定字符串中的分隔符替换为 '\0' NULL 字符

CODE

#include<iostream>
#include<cstring>

int main()
{
    char s[]="30/4/2021";     
    std::cout<<(void*)s<<"\n";    // 0x70fdf0
    
    char *p1=(char*)0x70fdf0;
    std::cout<<p1<<"\n";
    
    char *p2=strtok(s,"/");
    std::cout<<(void*)p2<<"\n";
    std::cout<<p2<<"\n";
    
    char *p3=(char*)0x70fdf0;
    std::cout<<p3<<"\n";
    
    for(int i=0;i<=9;i++)
    {
        std::cout<<*p1;
        p1++;
    }
    
}

OUTPUT

0x70fdf0       // 1. address of string s
30/4/2021      // 2. print string s through ptr p1 
0x70fdf0       // 3. this address is return by strtok to ptr p2
30             // 4. print string which pointed by p2
30             // 5. again assign address of string s to ptr p3 try to print string
30 4/2021      // 6. print characters of string s one by one using loop

在标记化之前string

我将 string s 的地址分配给某个 ptr(p1) 并尝试通过该 ptr 打印字符串并打印整个字符串。

标记化后

strtok 将字符串 s 的地址返回到 ptr(p2) ，但是当我尝试通过 ptr 打印字符串时，它只打印“30”，但没有打印整个字符串。因此可以肯定，strtok 不仅返回地址，而且还在存在分隔符的位置放置了“\0”字符。

交叉检查

1.

再次将字符串 s 的地址分配给某个 ptr (p3) 并尝试打印字符串，它在标记字符串更新时打印“30”分隔符处为“\0”。

2.

请参阅通过循环逐个字符打印字符串，第一个分隔符被 '\0' 替换，因此它打印空格而不是 ''