如何在 function 中初始化可变长度矩阵，然后在不使用 malloc 或 C 中的 calloc 的情况下返回相同的矩阵

Question

我想问的问题是，我如何不仅初始化 function 内的可变长度矩阵，而且如何从同一个 function 返回它。

我已经找到了可行的解决方案，但它们并不是我想要的。

为了更形象化我的要求是展示我的解决方案或解决问题的尝试。

我的第一个想法是如果我创建一个指针数组

#include <stdio.h>


int main(){
  int value = 12;
  int value1 = 32;
  int *mat[2] = 
  {
    &value,
    &value1
  };
  printf("%d",mat[0][1]);
}

这可行，但显然非常有限，甚至不是矩阵； 因为里面的指针只是指向一个值而不是一个数组，它更像是一个值数组，只是有额外的步骤

所以相反，我想如果我做类似的事情但是通过使每个索引本身成为一个数组来解决 arrays 的问题。

#include <stdio.h>

int **mfoo(int x, int y){
  int **matrix;
    int *arry[y];
    int arry1[x];
      for(int i=y;i<y;i++){
        
        arry[i] = arry1;
      }
  matrix = arry;
return matrix;
}
int main(){
  int **mat = mfoo(5,5);
  mat[0][3] = 5;
  printf("%d",mat[0][3]);
  return 0;
}

这显然不起作用，因为arry[x]的第一个索引的地址被分配给矩阵中的每个索引，使得矩阵的每个索引都是完全相同的数组。

正如预测的那样，它适用于像mat[0][3]这样的 mat 的第一个索引但是如果我尝试索引 mat mat[1][3]的第二个索引，它将结束分段错误，这对我来说似乎很奇怪，因为它应该只需将自己引用到同一个数组，因为 mat[0] 和 mat[1] 应该是相同的地址，因为它们都指向 &arry1[0]？

我的下一个想法是我唯一开始工作的想法，我现在将在 function 中展示它，我将字符串解析为 arguments

char * pipe_arguments(char *str, int j){
  int _j=0; 
  int _i=0;
  char *argument_ptr;
  char arr[20][200];
  for(int i=0; i<j; i++){
    if(str[i] > 32 && str[i] < 127){
      arr[_i][_j] = str[i];
      _j++;
    }
    else if(str[i] == 32){
      _i++;
    }
  }
argument_ptr = arr[0];
//"echo -o A_String" -- should see three parameters 
return argument_ptr;
}

int main(){
  char str[] = "echo -f filename.txt -o stdout";
  char *ptr;
  ptr = pipe_arguments(str, sizeof(str));
  for(int j=0;j<20;j++){
    for(int i=0;i<200;i++){  
      printf("%c",*ptr++);
    }
  printf("\n");
  }
}

这工作得很好，除了一些非常随机的字符外，几乎可以打印出我想要的东西

此 function 的 output 的示例是

echo
-f
filename.txt
-o
stdout�y�~���
�Pk�y�~p`j`jp>�>`�>�
?p
p�y�~�y�~`�p`�
A�y�~�p�y�~/�j�Unnert/usr/li���y�~�y�~��Gļy�~��h�y�~�J�y�~Z�~y�~=�y�~�
��F7@�y�~p�y�~�j�U�P�F7�P��qZ�_qZ�_%�aD��
�j�Up�y�~`�y�~��y�~�
p�y�~ ���p�y�~�
@�h�y�~�y�~�y�~�y�~@8
@IH�V�y�~�
s~y�~�}y�~8S�y�~�~��h�y�~��y�~�y�~�y�~�y�~
�V�y�~��t~y�~x}y�~8S�y�~�~�~��~��y�~�y�~�ﵽ��y�~(�@�y�~�y�~��y�~@�y�~
�y�~�t~y�~���y�~���SP�y�~�U�y�~�y�~(U�y�~`�jɽy�~��y�~0�y�~
�j�U�SP�y�~|�c;̸U�y�~�jɽy�~�y�~`�y�~0N�y�~��~}y�~��y�~�h�y�~�p�y�~���
////////////////�����usr/lib/i386-lin��y�~��y�~@�y�~@�y�~}~�0�y�~0�y�~
� �y�~ �y�~
��T�y�~�y���y�~��y�~�Ѣ�y�~@�y�~P�y�~Y�y�~�y�~H�y�~0@j�Up
�Z�y�~�'P�#�y�~@�y�~�y�~�@p�y%2@j�U0�A@
|wn]@�y�~��j�U��y�~ �?8�y�~�"�y�~b`�!�
�`2@j�U!�y�~`�y�~`�y�~�f-`�y�~h
�j�U���y�~`�y�~�

您可以看到它解析字符串并将每个字符串放入一个索引中，但在开始吐出随机乱码之后。

这与手头的问题无关，但如果回答为什么它也会这样做，将不胜感激？

无论如何，这个解决方案使用线性指针和使用指针算法通过数组的索引来工作。

仍然感觉有些事情没有解决它不是我想要的，我觉得应该有一个不使用 malloc 或 calloc 的解决方案。 我并不是说自己制作这些函数然后使用它们，我的意思是感觉就像有一种方法可以得到一个双指针，例如使用mat[4][10]来索引矩阵。

Answer 1

您不能这样做（请参阅https://en.cppreference.com/w/c/language/scope ）：

char* func()
{
    char arr[1][2]; //local scope
    return &arr[0]; //error, the array will no longer exist (out of scope)
}

如果您不想在 function 中分配 memory，那么您必须提供另一个存储作为参数，例如：

char** func(char **matrix, size_t rows, size_t cols /* ,other args */)
{
    /* do something */
    return matrix;
}

int main()
{
    char matrix[20][200];
    func(matrix, 20, 200);
    return 0;
}

还有另一种可能的解决方案，但仅适用于较小的数据类型（以避免不必要的复制和堆栈使用），例如：

struct matrix {
    char data[2][2];
};

struct matrix func(char a, char b, char c, char d)
{
    struct matrix m = { .data = {{a, b}, {c, d}} }; //initialize matrix
    return m; //return on stack
}

int main()
{
    struct matrix m = func('a', 'b', 'c', 'd');
    printf(
        "%c %c %c %c\n", 
        m.data[0][0], 
        m.data[0][1], 
        m.data[1][0], 
        m.data[1][1]
    );
    
    return 0;
}

只要数据类型（ struct ）是完整的（因此它的大小在编译时是已知的），从 function 返回这样的struct应该没有问题（我不知道这种struct的最大大小的限制）。