变换1D char数组到2D char数组而不分配存储器

Question

我有一个字符串，例如：

char* cmd = "a bcd ef hijk lmmopq";

该字符串由通过空间分割的段，段的数目是不固定的。

直观地说，我可以通过动态地分配存储器中，例如一个二维字符的字符串：

char** argv = malloc(); 
char* argv[0] = malloc(); 
... 
char* argv[i] = malloc(); 

但我可以将原始阵列至2d类似下面字符数组，以避免存储器分配？

char* argv[] = {"a", "bcd", "ef", "hijk", "lmmopq"}; 

Answer 1

从我的评论继续，你可以记号化你的字符串，例如strtok并将指向单个单词的指针分配给指针指向字符的指针。例如：

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

#define MAX 10 

int main (void) { 

    char *cmd = (char[]){"a bcd ef hijk lmmopq"},  /* compound literal */ 
    // char cmd[] = "a bcd ef hijk lmmopq"; /* otherwise declare as array */ 
     *arr[MAX] = {NULL}, 
     *delim = " \n"; 
    size_t n = 0; 

    for (char *p = strtok (cmd, delim); n < MAX && p; p = strtok (NULL, delim)) 
     arr[n++] = p; 

    for (int i = 0; i < (int)n; i++) 
     printf ("arr[%d]: %s\n", i, arr[i]); 

    return 0; 
} 

*示例使用/输出**

$./bin/str2ptp 
arr[0]: a 
arr[1]: bcd 
arr[2]: ef 
arr[3]: hijk 
arr[4]: lmmopq 

注：你不能传递一个字符串文字到strtok为strtok修改字符串。可以使用指向数组的指针，也可以声明并初始化为一个正常的char[]数组。

---

动态未知数量的单词

如果你不知道你是否能阅读二十字或2000个字，你可以很容易地通过动态地分配指针块地处理这种情况的分配指针，那么如果再次达到先前的最大分配，则再次进行。这是一个简单的过程，例如

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

#define MAX 10 
#define MAXB 4096 

int main (void) { 

    char cmd[MAXB] = "", /* buffer of 4096 chars to hold each line input */ 
     **arr = calloc (MAX, sizeof *arr), 
     *delim = " \n"; 
    size_t n = 0, max = MAX; 

    while (fgets (cmd, MAXB, stdin)) { /* read each line of input on stdin */ 

     size_t len = strlen (cmd); /* get line length */ 
     if (cmd[len - 1] == '\n') /* test for trailing '\n' */ 
      cmd[--len] = 0;   /* overwrite with nul-byte */ 

     for (char *p = strtok (cmd, delim); p; p = strtok (NULL, delim)) { 
      arr[n++] = p; 

      if (n == max) { /* realloc arr by MAX if n == MAX */ 
       void *tmp = realloc (arr, (max + MAX) * sizeof *arr); 
       if (!tmp) { 
        fprintf (stderr, "error: memory exhausted.\n"); 
        break; 
       } 
       arr = tmp; /* zero new pointers (optional) */ 
       memset (arr + max, 0, MAX * sizeof *arr); 
       max += MAX; /* update current max iteration */ 
      } 
     } 
     for (int i = 0; i < (int)n; i++) 
      printf ("arr[%2d]: %s\n", i, arr[i]); 
    } 

    free (arr); /* don't forget, if you allocate it -> you free it. */ 

    return 0; 
} 

上面总是验证您的分配，例如， if (!arr) { /* handle error */ }为简洁起见，其从arr的初始分配中省略。

示例使用/输入

$ echo "A quick brown fox jumps over the lazy dog while the dog watched" | \ 
./bin/strtop2pdyn 
arr[ 0]: A 
arr[ 1]: quick 
arr[ 2]: brown 
arr[ 3]: fox 
arr[ 4]: jumps 
arr[ 5]: over 
arr[ 6]: the 
arr[ 7]: lazy 
arr[ 8]: dog 
arr[ 9]: while 
arr[10]: the 
arr[11]: dog 
arr[12]: watched 

Answer 2

正如另一个答案指出，strtok可以用来使分隔符（空格）与空终结取代分裂的就地字符串。

要知道会有多少个字符串，您必须遍历字符串两次。对于第一次迭代，发明一些快速&简单的函数，不改变字符串，像这样：

size_t count_spaces (const char* src) 
{ 
    size_t spaces=0; 
    for(; *src != '\0'; src++) 
    { 
    if(*src == ' ') 
    { 
     spaces++; 
    } 
    } 
    return spaces; 
} 

然后为第二次迭代，使用strtok。完整示例：

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

size_t count_spaces (const char* src) 
{ 
    size_t spaces=0; 
    for(; *src != '\0'; src++) 
    { 
    if(*src == ' ') 
    { 
     spaces++; 
    } 
    } 
    return spaces; 
} 

void tokenize (char* restrict src, 
       size_t dst_size, 
       char* restrict dst [dst_size]) 
{ 
    size_t i; 
    char* ptr = strtok(src, " "); 
    for(i=0; i<dst_size && ptr != NULL; i++) 
    { 
    dst[i] = ptr; 
    ptr = strtok(NULL, " "); 
    } 
} 

int main (void) 
{ 
    char str [] = "a bcd ef hijk lmmopq"; 
    size_t size = count_spaces(str) + 1; 
    char* ptr_arr [size]; 

    tokenize(str, size, ptr_arr); 

    for(size_t i=0; i<size; i++) 
    { 
    puts(ptr_arr[i]); 
    } 
}