将字符串拆分为标记并将标记放入数组 - strtok答案

【问题标题】：Splitting a string into tokens and putting tokens into array - strtok将字符串拆分为标记并将标记放入数组 - strtok
【发布时间】：2018-11-11 05:37:41
【问题描述】：

char** token_arr(char* str, int n_tokens)
{
   char**arr = malloc((n_tokens+1)*sizeof(char*));
   char str2[n_tokens + 1];
   strcpy(str2,str);
   int i = 0;
   char *p = strtok (str2, " ");

   while (p != NULL)
   {
       arr[i] = p;
       //printf("%s\n", arr[i]);
       p = strtok (NULL, " ");
       i++;
   }
 return arr;
}

token_arr 的目的是获取一个字符串和多个token，然后将token放入一个数组中。返回令牌数组。

int main(void) {
  char*str1 = "( 8 + ( 41 - 12 ) )";
  char**expression = token_arr(str1, 9);
  for(int i = 0; i < 9; i++)
    printf("expression[%d] = %c\n", i, *expression2[i]);
 return 0;
}

输出：

expression2[0] = (
expression2[1] = 
expression2[2] = 
expression2[3] = 
expression2[4] = 
expression2[5] = 
expression2[6] = 
expression2[7] = 
expression2[8] =

为什么只打印第一个值？我的代码有什么问题？

【问题讨论】：

您正在分配指针数组，但指针指向函数中的局部变量str2，一旦您返回main()，该变量就超出范围，所以您正在访问已被重用并可能归零的无效数据。您需要在复制字符串文字的位置分配字符串，并且您需要找到一种方法将两个分配的指针都传递回main()，以便准确释放分配的内存。就目前而言，您有“未定义的行为”。这意味着您看到的是有效响应，以及许多其他可能的行为。
除非您使用calloc 或memset 在arr 的末尾保留一个sentinel NULL，否则@987654331 中不需要+1 @。 arr 只是您分配的指针数量。如果您只有n_tokens，则只需要该数量的指针，除非您确保拥有最终指针NULL 以允许使用while 循环进行迭代——但在这种情况下，您需要设置所有指针NULL开始。
您还需要避免写入比您拥有的更多的指针。因此，您需要确保 i 永远不会超过您目前拥有的 n_tokens+1，例如while (i < n_tokens + 1 && p != NULL)。您可以使用strdup 为每个令牌分配，例如arr[i] = strdup (p);。现在arr[n] 的内容将在返回后继续存在。

标签： c arrays output strtok

【解决方案1】：

虽然我认为您可能已经根据 cmets 对大部分问题进行了排序，但让我们看看一种方法来解决 expressions 的验证/返回以及返回令牌数量以防止错误的方法在标记化中导致找到少于n_tokens。

如您所见，当您将str2 声明为token_arr 本地时，它具有自动存储期限，并且仅在其声明的范围内有效。当token_arr 返回时，持有str2 的内存将被释放以供重复使用，并且在main() 中引用该内存的任何尝试都会调用未定义的行为。

你有什么选择？ (1) 使用strdup为每个token动态分配存储，将token复制到分配的新内存中，然后将包含token的新内存块的起始地址分配给arr[i]，例如

        arr[i] = strdup (p);

或 (2) 使用 strlen, malloc & memcpy 手动执行相同的操作，例如

        size_t len = strlen(p);
        arr[i] = malloc (len + 1);
        /* validate - here */
        memcpy (arr[i], p, len + 1);

现在每个arr[i] 都指向一个具有已分配存储持续时间的内存块，该内存块在该块上调用free 或程序结束之前一直有效。

如果发现小于 n_tokens 怎么办？

如果在token_arr 中找到的n_tokens 小于n_tokens，并且您尝试在expressions 中使用expressions 回到main()，您可能会再次调用未定义行为。为了确保您只使用在token_arr 中找到并通过分配给expression 而在main() 中可用的令牌——将指针传递给n_tokens 作为第二个参数并更新它将i 在你之前 return arr; 的值，例如

char **token_arr (const char *str, int *n_tokens)
{
    char **arr = malloc(*n_tokens * sizeof *arr);
    ...
        i++;
    }
    *n_tokens = i;  /* assign i to make tokes assigned available */

    return arr;
}

现在n_tokens 回到main() 仅包含实际找到并分配给arr[i] 并分配给token_arr 中的令牌数。

验证每个分配

验证对malloc, calloc, realloc, strdup 或任何其他为您分配内存的函数的调用至关重要。分配可以而且确实会失败。当它发生时，它会通过返回NULL 而不是包含新内存块起始地址的指针来让您知道。检查每个分配。

总而言之，您可以执行以下操作：

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

char **token_arr (const char *str, int *n_tokens)
{
    char **arr = malloc(*n_tokens * sizeof *arr);
    char str2 [strlen(str) + 1];
    int i = 0;

    if (!arr) { /* validate every allocation */
        perror ("malloc-n_tokens");
        return NULL;
    }

    strcpy (str2, str);

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

    while (i < *n_tokens && p != NULL) {    /* check used pointers */
        arr[i] = strdup (p);
        if (!arr[i]) {  /* strdup allocates -> you must validate */
            perror ("strdup-arr[i]");
            if (i)          /* if tokens stored, break an return */
                break;
            else {          /* if no tokes stored, free pointers */
                free (arr);
                return NULL;
            }
        }
        p = strtok (NULL, " ");
        i++;
    }
    *n_tokens = i;  /* assign i to make tokes assigned available */

    return arr;
}

int main (void) {

    char *str1 = "( 8 + ( 41 - 12 ) )";
    int n_tokens = 9;
    char **expression = token_arr (str1, &n_tokens);

    if (expression) {       /* validate token_arr succeeded */
        for (int i = 0; i < n_tokens; i++) { /* n_tokens times */
            printf ("expression[%d] = %s\n", i, expression[i]);
            free (expression[i]);   /* free mem allocated by strdup */
        }
        free (expression);
    }

    return 0;
}

（注意：在使用返回之前同样检查token_arr的返回）

使用/输出示例

$ ./bin/token_arr
expression[0] = (
expression[1] = 8
expression[2] = +
expression[3] = (
expression[4] = 41
expression[5] = -
expression[6] = 12
expression[7] = )
expression[8] = )

内存使用/错误检查

在您编写的任何动态分配内存的代码中，对于分配的任何内存块，您都有 2 个职责：(1)始终保留指向起始地址的指针内存块，因此，(2) 当不再需要它时可以释放。

您必须使用内存错误检查程序来确保您不会尝试访问内存或写入超出/超出分配块的边界，尝试读取或基于未初始化的值进行条件跳转，最后，以确认您释放了已分配的所有内存。

对于 Linux，valgrind 是正常的选择。每个平台都有类似的内存检查器。它们都易于使用，只需通过它运行您的程序即可。

$ valgrind ./bin/token_arr
==8420== Memcheck, a memory error detector
==8420== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==8420== Using Valgrind-3.12.0 and LibVEX; rerun with -h for copyright info
==8420== Command: ./bin/token_arr
==8420==
expression[0] = (
expression[1] = 8
expression[2] = +
expression[3] = (
expression[4] = 41
expression[5] = -
expression[6] = 12
expression[7] = )
expression[8] = )
==8420==
==8420== HEAP SUMMARY:
==8420==     in use at exit: 0 bytes in 0 blocks
==8420==   total heap usage: 10 allocs, 10 frees, 92 bytes allocated
==8420==
==8420== All heap blocks were freed -- no leaks are possible
==8420==
==8420== For counts of detected and suppressed errors, rerun with: -v
==8420== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

始终确认您已释放已分配的所有内存并且没有内存错误。

查看一下，如果您还有其他问题，请告诉我。

【讨论】：