在C语言中连接双指针字符数组

关于如何在C中连接字符数组有很多问题，但我想知道的与此不同。我想知道如何在C中连接“双指针”字符数组

比如说,

const char *array1[] = {"aa", "bb"};
const char *array2[] = {"cc", "dd", "ee"};

我想得到新的char双指针数组，如下所示：

char **new_array = {"aa", "bb", "cc", "dd", "ee"};
// this code actually doesn't work, though

我想知道实现这一点最简单、最快的方法

编辑：事实上，我计划在下面创建一个程序

int main(int argc, char **argv) {
    pid_t pid;
    char **args = {"sh", "-c"} + argv; // this code doesn't work
    posix_spawn(&pid, "/bin/sh", NULL, NULL, (char* const*)args, NULL);
}

---

这个程序只在“sh-c”之后传递参数。

当然，只需为此分配一个缓冲区即可

#define _GNU_SOURCE 1
#include <stdio.h>
#include <strings.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int main()
{
    #define ARRAY_SIZE(x)  (sizeof(x) / sizeof(x[0]))
    const char * const array1[] = {"aa", "bb"};
    const size_t array1_size = ARRAY_SIZE(array1);
    const char * const array2[] = {"cc", "dd", "ee"};
    const size_t array2_size = ARRAY_SIZE(array2);
    const size_t concat_len = array1_size + array2_size;

    const char ** const concat = malloc(concat_len * sizeof(*concat));
    assert(concat != NULL);
    for (size_t i = 0; i < concat_len; ++i) {
        consr char *string_to_copy = i < array1_size ? array1[i] : array2[i - array1_size];
        concat[i] = strdup(string_to_copy);
        assert(concat[i] != NULL);
    }

    for (size_t i = 0; i < concat_len; ++i) {
        printf("concat[%zu] = (%zu) '%s'\n", i, strlen(concat[i]), concat[i]);
    }

    for (size_t i = 0; i < concat_len; ++i) {
        free(concat[i]);
    }
    free(concat);

    return 0;
}

#定义源代码1
#包括
#包括
#包括
#包括
#包括
int main（）
{
#定义数组大小（x）（sizeof（x）/sizeof（x[0]））
常量字符*常量数组1[]={“aa”，“bb”}；
常量大小\u t数组1\u大小=数组大小（数组1）；
常量字符*常量数组2[]={“cc”、“dd”、“ee”}；
常量大小\u t数组2\u大小=数组大小（数组2）；
常数大小=阵列1大小+阵列2大小；
常量字符**常量concat=malloc（concat_len*sizeof（*concat））；
断言（concat！=NULL）；
对于（尺寸i=0；i

---

但我们应该可以做得更好。

当然，只需为此分配一个缓冲区即可

#define _GNU_SOURCE 1
#include <stdio.h>
#include <strings.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int main()
{
    #define ARRAY_SIZE(x)  (sizeof(x) / sizeof(x[0]))
    const char * const array1[] = {"aa", "bb"};
    const size_t array1_size = ARRAY_SIZE(array1);
    const char * const array2[] = {"cc", "dd", "ee"};
    const size_t array2_size = ARRAY_SIZE(array2);
    const size_t concat_len = array1_size + array2_size;

    const char ** const concat = malloc(concat_len * sizeof(*concat));
    assert(concat != NULL);
    for (size_t i = 0; i < concat_len; ++i) {
        consr char *string_to_copy = i < array1_size ? array1[i] : array2[i - array1_size];
        concat[i] = strdup(string_to_copy);
        assert(concat[i] != NULL);
    }

    for (size_t i = 0; i < concat_len; ++i) {
        printf("concat[%zu] = (%zu) '%s'\n", i, strlen(concat[i]), concat[i]);
    }

    for (size_t i = 0; i < concat_len; ++i) {
        free(concat[i]);
    }
    free(concat);

    return 0;
}

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

void main()
{
    const char *array1[] = {"aa", "bb"};
    const char *array2[] = {"cc", "dd", "ee"};


    int arraySize1 = (sizeof(array1)/sizeof(char*));
    int arraySize2 = (sizeof(array2)/sizeof(char*));
    char **resultArr = (char **)malloc(sizeof(char *)*(arraySize1+arraySize2));
    int i =0;

   /* copy array1*/
    for(i=0;i<arraySize1;i++)
   {
      resultArr[i] = malloc(strlen(array1[i]) +1);
      strcpy(resultArr[i], array1[i]);
   }

   /*copy array2*/
   for(i=0;i<arraySize2;i++)
   {
      resultArr[arraySize1+i] = malloc(strlen(array2[i])+1);
      strcpy(resultArr[arraySize1+i], array2[i]);
   }

    /*print resulting array*/
     for(i=0;i<arraySize1+arraySize2;i++)
     {
        printf("%s ", *(resultArr+i));
     }
 }

#定义源代码1
#包括
#包括
#包括
#包括
#包括
int main（）
{
#定义数组大小（x）（sizeof（x）/sizeof（x[0]））
常量字符*常量数组1[]={“aa”，“bb”}；
常量大小\u t数组1\u大小=数组大小（数组1）；
常量字符*常量数组2[]={“cc”、“dd”、“ee”}；
常量大小\u t数组2\u大小=数组大小（数组2）；
常数大小=阵列1大小+阵列2大小；
常量字符**常量concat=malloc（concat_len*sizeof（*concat））；
断言（concat！=NULL）；
对于（尺寸i=0；i

但我们应该能够做得更好。

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

void main()
{
    const char *array1[] = {"aa", "bb"};
    const char *array2[] = {"cc", "dd", "ee"};


    int arraySize1 = (sizeof(array1)/sizeof(char*));
    int arraySize2 = (sizeof(array2)/sizeof(char*));
    char **resultArr = (char **)malloc(sizeof(char *)*(arraySize1+arraySize2));
    int i =0;

   /* copy array1*/
    for(i=0;i<arraySize1;i++)
   {
      resultArr[i] = malloc(strlen(array1[i]) +1);
      strcpy(resultArr[i], array1[i]);
   }

   /*copy array2*/
   for(i=0;i<arraySize2;i++)
   {
      resultArr[arraySize1+i] = malloc(strlen(array2[i])+1);
      strcpy(resultArr[arraySize1+i], array2[i]);
   }

    /*print resulting array*/
     for(i=0;i<arraySize1+arraySize2;i++)
     {
        printf("%s ", *(resultArr+i));
     }
 }

#包括
#包括
void main（）
{
常量字符*数组1[]={“aa”，“bb”}；
const char*array2[]={“cc”、“dd”、“ee”}；
int-arraySize1=（sizeof（array1）/sizeof（char*）；
int-arraySize2=（sizeof（array2）/sizeof（char*）；
char**resultArr=（char**）malloc（sizeof（char*）*（arraySize1+arraySize2））；
int i=0；
/*复制阵列1*/
对于（i=0；i
#包括
#包括
#包括
void main（）
{
常量字符*数组1[]={“aa”，“bb”}；
const char*array2[]={“cc”、“dd”、“ee”}；
int-arraySize1=（sizeof（array1）/sizeof（char*）；
int-arraySize2=（sizeof（array2）/sizeof（char*）；
char**resultArr=（char**）malloc（sizeof（char*）*（arraySize1+arraySize2））；
int i=0；
/*复制阵列1*/
对于（i=0；我想我需要一些上下文。这些是运行时字符串吗？如果不是，你有最快的方法。只需编写它。没有像
strcat
这样的标准函数用于组合泛型数组。你需要手动操作。我已经添加了详细上下文。我想在原始参数（argv**）之前添加“sh”和“-c”参数。只需创建一个指针数组。让前两个指针指向字符串文本，其余指针指向argv中的每个项。我想我们需要一些上下文。这些运行时字符串是吗？如果不是，你有最快的方法。只需编写它。没有像
strcat
这样的标准函数用于组合泛型数组。你需要手动操作。我已经添加了d细节上下文。我想在原始参数（argv**）之前添加“sh”和“-c”参数。只需创建一个指针数组。让前两个指针指向字符串文本，其余指针指向argv中的每个项。
malloc（sizeof（array1[I]）
？如果你用一些长度合适的字符串初始化，程序就会崩溃。
sizeof（array1[i]）
是指针的大小，而不是字符串的长度。是的，我知道了，那是打字错误。
malloc（sizeof（array1[i]）
？如果你用一些长度合适的字符串初始化，程序就会崩溃。
sizeof（array1[i]）（array1[i]）
是指针的大小，而不是字符串的长度。是的，我知道了，这是打字错误。它成功了！如果没有更好的答案，这是暂时的答案。谢谢。它成功了！如果没有更好的答案，这是暂时的答案。谢谢。