C：从分隔源字符串创建字符串数组

Question

在 C（而不是 C++）中将分隔字符串转换为字符串数组的有效方法是什么？例如，我可能有：

char *input = "valgrind --leak-check=yes --track-origins=yes ./a.out"

源字符串始终只有一个空格作为分隔符。我想要一个 malloc'ed 字符串数组 char *myarray[] 这样：

myarray[0]=="valgrind"
myarray[1]=="--leak-check=yes"
...

编辑 我必须假设有任意数量的令牌inputString 所以我不能只将其限制为 10 或其他。

我尝试使用 strtok 和我实现的链接列表尝试一个混乱的解决方案，但 valgrind 抱怨太多，所以我放弃了。

（如果您想知道，这是我正在尝试编写的基本 Unix shell。）

Answer 1

类似这样的事情是怎么回事：

char* string = "valgrind --leak-check=yes --track-origins=yes ./a.out";
char** args = (char**)malloc(MAX_ARGS*sizeof(char*));
memset(args, 0, sizeof(char*)*MAX_ARGS);

char* curToken = strtok(string, " \t");

for (int i = 0; curToken != NULL; ++i)
{
  args[i] = strdup(curToken);
  curToken = strtok(NULL, " \t");
}

Answer 2

如果您一开始就拥有 input 中的所有输入，那么您的令牌永远不会多于 strlen(input)。如果您不允许“”作为令牌，那么您永远不能拥有超过 strlen(input)/2 令牌。因此，除非输入很大，否则您可以安全地编写。

char ** myarray = malloc( (strlen(input)/2) * sizeof(char*) );

int NumActualTokens = 0;
while (char * pToken = get_token_copy(input))
{ 
   myarray[++NumActualTokens] = pToken;
   input = skip_token(input);
}

char ** myarray = (char**) realloc(myarray, NumActualTokens * sizeof(char*));

作为进一步的优化，您可以保留 input 并仅用 \0 替换空格，并将指针放入 input 缓冲区中并放入 myarray[] 中。不需要为每个令牌单独分配内存，除非由于某种原因您需要单独释放它们。

Answer 3

您是否记得为标记字符串结尾的终止 null 分配一个额外的字节？

Answer 4

来自 OSX 上的 strsep(3) 联机帮助页：

   char **ap, *argv[10], *inputstring;

   for (ap = argv; (*ap = strsep(&inputstring, " \t")) != NULL;)
           if (**ap != '\0')
                   if (++ap >= &argv[10])
                           break;

针对任意标记数量进行编辑：

char **ap, **argv, *inputstring;

int arglen = 10;
argv = calloc(arglen, sizeof(char*));
for (ap = argv; (*ap = strsep(&inputstring, " \t")) != NULL;)
    if (**ap != '\0')
        if (++ap >= &argv[arglen])
        {
            arglen += 10;
            argv = realloc(argv, arglen);
            ap = &argv[arglen-10];
        }

或类似的内容。上面的方法可能行不通，但如果行不通，也相差不远了。构建链表比不断调用 realloc 更有效，但这实际上不是重点 - 重点是如何最好地利用 strsep。

Answer 5

看看其他答案，对于 C 初学者来说，由于代码的紧凑，它看起来会很复杂，我想我会把它放在初学者身上，实际解析字符串而不是使用 可能更容易strtok...类似这样：

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

char **parseInput(const char *str, int *nLen);
void resizeptr(char ***, int nLen);

int main(int argc, char **argv){
    int maxLen = 0;
    int i = 0;
    char **ptr = NULL;
    char *str = "valgrind --leak-check=yes --track-origins=yes ./a.out";
    ptr = parseInput(str, &maxLen);
    if (!ptr) printf("Error!\n");
    else{
        for (i = 0; i < maxLen; i++) printf("%s\n", ptr[i]);
    }
    for (i = 0; i < maxLen; i++) free(ptr[i]);
    free(ptr);
    return 0;
}

char **parseInput(const char *str, int *Index){
    char **pStr = NULL;
    char *ptr = (char *)str;
    int charPos = 0, indx = 0;
    while (ptr++ && *ptr){
        if (!isspace(*ptr) && *ptr) charPos++;
        else{
            resizeptr(&ptr, ++indx);
            pStr[indx-1] = (char *)malloc(((charPos+1) * sizeof(char))+1);
            if (!pStr[indx-1]) return NULL;
            strncpy(pStr[indx-1], ptr - (charPos+1), charPos+1);
            pStr[indx-1][charPos+1]='\0';
            charPos = 0;
        }
    }
    if (charPos > 0){
        resizeptr(&pStr, ++indx);
        pStr[indx-1] = (char *)malloc(((charPos+1) * sizeof(char))+1);
        if (!pStr[indx-1]) return NULL;
        strncpy(pStr[indx-1], ptr - (charPos+1), charPos+1);
        pStr[indx-1][charPos+1]='\0';
    }
    *Index = indx;
    return (char **)pStr;
}

void resizeptr(char ***ptr, int nLen){
    if (*(ptr) == (char **)NULL){
        *(ptr) = (char **)malloc(nLen * sizeof(char*));
        if (!*(ptr)) perror("error!");
    }else{
        char **tmp = (char **)realloc(*(ptr),nLen);
        if (!tmp) perror("error!");
        *(ptr) = tmp;
    }
}

我稍微修改了代码以使其更容易。我使用的唯一字符串函数是 strncpy 。当然它有点啰嗦，但它确实动态地重新分配字符串数组，而不是使用硬编码的 MAX_ARGS，这意味着双指针当只有 3 或 4 个就已经占用内存了，这也会使内存使用高效且很小，通过使用 realloc，简单的解析通过使用 isspace 来覆盖，因为它使用指针进行迭代。当遇到空格时，它会重新分配双指针，并malloc偏移量来保存字符串。

请注意如何在 resizeptr 函数中使用三重指针。事实上，我认为这将是一个简单 C 程序、指针、realloc、malloc、按引用传递、基本的绝佳示例。解析字符串的元素...

希望这有帮助，
此致，
汤姆.