我如何通过malloc'；d指针数组的地址，以便我可以更改数组中的指针？

我试图创建以下数据结构：

{}

=动态内存分配

[]

=数组

{[ptr，ptr，ptr]，[ptr，ptr，ptr]，…}

以及内存分配，用于跟踪

ptr

将指向的内存位置的大小：

{[int，int，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, j, 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;
}

---

正如在注释中提到的，您可以使用类型别名（我通常对指针别名表示强烈反对）使其至少可读。大概是这样的：

#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, j, 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;
}

我可能会丢失别名，然后做任何长时间的工作，但是你会有一个混淆比赛的条目，而不是一段合理的代码

---

不带类型别名

包含仅供参考，相同的代码没有别名。在本例中，很明显，为什么它们实际上有助于清晰性（这也是我使用它们的唯一原因）

#包括
#包括
#定义X_尺寸3//我们的固定内部尺寸
void foo（int*（*arr）[X_SIZE]，int（*SIZE）[X_SIZE]，int num_数组）
{
int i，j，k；
对于（i=0；i可以尝试
typedef int INTARR3[3]；
…然后可以使用
sizeof（INTARR3）
等方法来计算具有3个int的数组的大小。@pmg请参见编辑，不起作用。对我有效…
typedef int INTARR3[3]；INTARR3*a=malloc（4*sizeof（INTARR3））；a[0][1]=42；
int**arr[3]
声明一个包含三个元素的数组，每个元素都是指向int的指针。我不知道区别是什么，但我得到了
错误：下标值既不是数组也不是指针，也不是向量arr[I][j][k]=i*j*k；
你说你强烈反对使用此方法。你更喜欢做什么？最终我需要3个指针的动态决定倍数，只使用：
int**arr=malloc（sizeof（*int）*X_SIZE*num是否更好
？@CSStudent7782实际上是我强烈反对在typedef中隐藏指针类型。它们很少（如果有的话）增加清晰度，而是经常隐藏它。在这种情况下，指针类型不是别名，而是数组类型，因此，我会给它一个通行证。但是当你看到像
typedef int*intp；
这样的东西时，你会发现它最终只会使代码更难阅读和管理，而不是更容易。
#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, j, 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], 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[])
{
    static const int N = 10;

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

    foo(arr, sizes, N);

    int i, j, 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;
}