创建指向char指针的指针的笛卡尔乘积的困难

作为输入，我有一个指向char指针的指针，其中包含：

{"ab", "cd"}

作为输出，我需要创建以下笛卡尔积：

{"abab", "abcd", "cdab", "cdcd"}

我创建了一个函数，它接收“ab，cd”和一个指向char指针的指针，该指针用于保存结果集。尽管函数内部的一切似乎都正常工作，但一旦退出，我的输出仍然为空。我想我在连接过程中做错了什么，但我不确定是什么

我的代码是这样的：

#include <stdio.h>

void Permute(char**, int, char**);

main() {
    // my input
    int words = 2;
    char **input;
    input = malloc(sizeof(char*) * words);
    input[0] = "ab";
    input[1] = "cd";

    // compute how much memory we need
    char **output;
    output = malloc(sizeof(char*) * (words * 2));

    // start permutation
    Permute(input, words, output);

    // show output
    int i = 0;
    for(i = 0; i < (words * 2); ++i) {
        // should print: {abcd, abab, cdab, cdcd} 
        // but nothing gets printed
        printf("%s\n", output[i]); 
    }
    free(input);
    free(output);
}

void Permute(char **input, int words, char **output){
    int i = 0, j = 0, k = 0;
    char str[5];
    for(i = 0; i < words; ++i) {
        for(j = 0; j < words; ++j) {
            strcpy (str, input[i]);
            strcat (str, input[j]);
            output[k] = str;
            // at this point concatenation is printed correctly
            printf("%s\n", output[k]); correctly
            ++k;
        }
    }
}

#包括
无效排列（字符**，整数，字符**）；
main（）{
//我的意见
int字=2；
字符**输入；
输入=malloc（sizeof（char*）*字）；
输入[0]=“ab”；
输入[1]=“cd”；
//计算我们需要多少内存
字符**输出；
输出=malloc（sizeof（char*）*（words*2））；
//开始排列
排列（输入、文字、输出）；
//显示输出
int i=0；
对于（i=0；i<（单词*2）；++i）{
//应打印：{abcd、abab、cdab、cdcd}
//但是什么也没印出来
printf（“%s\n”，输出[i]）；
}
免费（输入）；
自由（输出）；
}
无效排列（字符**输入，整型字，字符**输出）{
int i=0，j=0，k=0；
char-str[5]；
对于（i=0；i

编辑 感谢Goz的评论，我更新了我的功能。现在，分配一个指向char的指针，指向连接，然后存储在输出[k]中。这样，激活功能时不会丢失任何数据：

void Permute(char **input, int words, char **output){
    int i = 0, j = 0, k = 0;
    char *p;
    for(i = 0; i < words; ++i) {
        for(j = 0; j < words; ++j) {
            p = malloc(sizeof(char*) * 5);
            strcpy(p, input[i]);
            strcat (p, input[j]);
            output[k] = p;
            printf("%d %s \n", k, output[k]); 
            ++k;
        }
    }
}

void排列（字符**输入，整型字，字符**输出）{
int i=0，j=0，k=0；
char*p；
对于（i=0；i

编辑 保存结果的缓冲区在传递给Permute函数之前得到分配：

    // compute how much memory we need
    // allocate space for 4 pointers to char
    char **output = malloc(sizeof(char*) * 4); 
    int i = 0;
    // pre-allocate space for every pointer 
    for(i = 0; i < 4; i++)
       output[i] = malloc( sizeof( char ) * 5 ); 

//计算我们需要多少内存
//为4个指向char的指针分配空间
char**output=malloc（sizeof（char*）*4）；
int i=0；
//为每个指针预先分配空间
对于（i=0；i<4；i++）
输出[i]=malloc（sizeof（char）*5）；

编辑 清除指向char指针的指针之前，请释放char指针指向的所有内存：

    // free memory
    for(i = 0; i < 4; i++ )
       free( output[i] );
    free(output);

    for(i = 0; i < 2; i++ )
       free(input[i]);
    free(input);

//释放内存
对于（i=0；i<4；i++）
自由（输出[i]）；
自由（输出）；
对于（i=0；i<2；i++）
自由（输入[i]）；
免费（输入）；
charstr[5]位于堆栈上，退出Permute后将丢失<代码>输出[k]
一旦退出Permute，将指向一个未定义的位置。
有几个问题。首先分配一个char*。然后将其分配给一个字符**，并期望它具有二维性。没有。您需要malloc一组char*指针（4*不管您的指针大小是什么…，即sizeof（char*）），然后为每个指针malloc 5个字节

此外，在Permute中，您将使用指向str的指针覆盖指针值（在函数外部不存在）。您应该将str的内容压缩到输出[k]

对评论的回答是：是的，这会起作用，但是在进入循环之前分配缓冲区是明智的

即

char**ptr=malloc（sizeof（char*）*4）；
对于（int i=0；i++；i<4）
{
ptr[i]=malloc（sizeof（char）*4）；//sizeof（char）==1，但这是一个好习惯。
}

然后，如前所述，将临时数组strcpy到相关的char*数组中

此外，请记住，当您释放内存时，您需要执行与上述循环相反的操作。ie解除锁定4个单独的数组，然后解除锁定指针数组。即：

for( int i = 0; i++; i < 4 )
{
   free( ptr[i] );
}
free( ptr );

for（int i=0；i++；i<4）
{
自由（ptr[i]）；
}
免费（ptr）；

即调用malloc的所有5个场合都会遇到相应的免费服务。如果先释放ptr阵列，则无法保证内存有效。因此，存储在该数组中的4个指针可能不再有效。所以首先释放它们，然后释放指针数组

output = malloc(sizeof(char*) * (words * 2));

好的，您创建了
输出[0]
，
输出[1]
。。。但他们的价值观是什么

输出[0]
是一个
字符*
。。。它指向哪里

并且不能将Permute（
str
）中的局部变量的地址复制到
输出
。一旦函数返回，该对象就不再存在。
我试图将串联直接压缩到输出[k]中，但它似乎也不起作用。我用这个修改更新了我的问题。你能详细解释一下“然后你把它分配给一个字符**，并期望它有2维。它没有。”。也许是一段代码。非常感谢。我再次更新我的答案。现在，分配一个指向char的指针，我能够读取函数外部的输出。这是正确的处理方法吗？好的！但我如何才能正确地将连接的结果传递给我的输出指针呢？这真是可悲，他们在学校教如何处理c字符串：
input[0]=“ab”
@Donotalo：您能指出这段代码的错误并解释在这种特定情况下处理字符串的正确方法吗？这不是任何一所学校提出的，而是我试图解决的问题。非常感谢。哦，作业标签让我觉得它是在学校教的。在C语言中，没有类似字符串的数据类型可以用来播放int、float、char等。。。；a=10但不能执行
char*a*a=“文本”output = malloc(sizeof(char*) * (words * 2));