如何传递指针数组的malloc地址，以便可以更改数组中的指针？

如何解决如何传递指针数组的malloc地址，以便可以更改数组中的指针？

我正在尝试创建以下数据结构：

{} =动态内存分配

[] =数组

{[ptr,ptr,ptr],[ptr,...}

和用于跟踪ptr指向的内存位置大小的内存分配：

{[int,int,int],[int,...}

，然后将此数据结构传递到函数中，以便从函数内部更改内部ptr和int的值。

我希望这样的事情能起作用：

void foo(int **arr[3],int *sizes[3],int num_arrays)
{
  int i,j,k;
  for(i=0; i<num_arrays; i++)
  {
    for(j=0; j<3; j++)
    {
      sizes[i][j] = 1 + (i * j);
      arr[i][j] = malloc(sizeof(int) * sizes[i][j]);
      for(k=0; k<sizes[i][j]; k++)
      {
        arr[i][j][k] = i * j * k;
      }
    }
  }
}

int main(int argc,char *argv[])
{
  int **arr[3] = malloc(sizeof(*(int[3])) * 10); //line 33
  int *sizes[3] = malloc(sizeof(int[3]) * 10); //line 34
  foo(arr,sizes,10);

  int i,k;
  for(i=0; i<10; i++)
  {
    for(j=0; j<3; j++)
    {
      for(k=0; k<sizes[i][j]; k++)
      {
        printf("%d ",arr[i][j][k]);
      }
      printf("\n");
    }
    printf("\n");
  }
  return 0;
}

不幸的是，这会导致编译器错误：

main.c: In function ‘main’:
main.c:33:41: error: expected expression before ‘)’ token
   int **arr[3] = malloc(sizeof(*(int[3])) * 10);
                                         ^
main.c:34:19: error: invalid initializer
   int *sizes[3] = malloc(sizeof(int[3]) * 10);

解决方法

如注释中所述，您可以使用类型别名（通常我会故意反对使用指针别名），以使其至少可读。像这样：

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

#define X_SIZE 3                 // our fixed internal size
typedef int INTARRX[X_SIZE];     // array of int
typedef int *INTPTRX[X_SIZE];    // array of pointer to int.

void foo(INTPTRX arr[],INTARRX sizes[],int num_arrays)
{
    int i,j,k;
    for (i = 0; i<num_arrays; i++)
    {
        for (j = 0; j<X_SIZE; j++)
        {
            sizes[i][j] = 1 + (i * j);
            arr[i][j] = malloc(sizeof(int) * sizes[i][j]);
            for (k = 0; k<sizes[i][j]; k++)
            {
                arr[i][j][k] = i * j * k;
            }
        }
    }
}

int main(int argc,char *argv[])
{
    INTARRX *sizes = calloc(10,sizeof *sizes);
    INTPTRX *arr = calloc(10,sizeof *arr);

    foo(arr,sizes,10);

    int i,k;
    for (i = 0; i<10; i++)
    {
        for (j = 0; j<3; j++)
        {
            for (k = 0; k<sizes[i][j]; k++)
            {
                printf("%d ",arr[i][j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
    return 0;
}

输出

0
0
0

0
0 1
0 2 4

0
0 2 4
0 4 8 12 16

0
0 3 6 9
0 6 12 18 24 30 36

0
0 4 8 12 16
0 8 16 24 32 40 48 56 64

0
0 5 10 15 20 25
0 10 20 30 40 50 60 70 80 90 100

0
0 6 12 18 24 30 36
0 12 24 36 48 60 72 84 96 108 120 132 144

0
0 7 14 21 28 35 42 49
0 14 28 42 56 70 84 98 112 126 140 154 168 182 196

0
0 8 16 24 32 40 48 56 64
0 16 32 48 64 80 96 112 128 144 160 176 192 208 224 240 256

0
0 9 18 27 36 45 54 63 72 81
0 18 36 54 72 90 108 126 144 162 180 198 216 234 252 270 288 306 324

我可能会失去别名，只能做所有事情，但是您将获得一场混淆竞赛的入场券，而不是一段合理的代码。

---

没有类型别名

仅包括参考，没有别名的相同代码。很明显，在这种情况下，为什么它们实际上有助于提高清晰度（这也是我使用它们的唯一原因）。

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

#define X_SIZE 3            // our fixed internal size

void foo(int *(*arr)[X_SIZE],int (*sizes)[X_SIZE],char *argv[])
{
    static const int N = 10;

    int (*sizes)[X_SIZE] = calloc(N,sizeof *sizes);
    int *(*arr)[X_SIZE] = calloc(N,N);

    int i,k;
    for (i = 0; i<N; i++)
    {
        for (j = 0; j<X_SIZE; j++)
        {
            for (k = 0; k<sizes[i][j]; k++)
            {
                printf("%d ",arr[i][j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
    return 0;
}