Question

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的目的是获取一个字符串和多个令牌，然后将这些令牌放入一个数组中。返回令牌数组。

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] =

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

Answer 1

虽然我认为您可能已经根据注释对大多数问题进行了分类，但让我们看一下一种解决expressions的验证/返回的方法以及一种返回的令牌数以防止受到攻击的方法令牌化过程中的错误，导致发现的错误少于n_tokens。

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

>

您有什么选择？（1）使用strdup为每个令牌动态分配存储，将令牌复制到已分配的新内存，然后将包含令牌的新内存块的起始地址分配给arr[i]，例如< / p>

        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怎么办？

如果在n_tokens中发现少于token_arr，并且您尝试在n_tokens中使用expressions至main()，则可能会调用 Undefined行为。为确保仅使用token_arr中分配给main()的令牌，并在expression中提供这些令牌，请将指针传递给 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)

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

仔细检查一下，如果还有其他问题，请告诉我。

将字符串拆分为令牌并将令牌放入数组-strtok

1 个答案: