调用一个二维数组

Question

为了制作二维数组，我目前使用的是：

int * own;

own = (int *)calloc(mem_size, sizeof(int));

for (i=0;i<mem_size;i++){
    own[i] = (int *)calloc(3, sizeof(int));
}

然而，每次我引用own[i][j]时，我都会得到一个错误，指出下标值既不是数组也不是指针也不是向量。

Answer 1

使用：

int ** own; // int**, not int*
own = calloc(mem_size, sizeof(int*)); //int*, not int
                                      // And remove the explicit cast.

Answer 2

因为 own 被声明为具有类型 int *

int * own;

那么 own[i] 是一个 int 类型的标量对象，您不能对其应用下标运算符。

你可以这样写

int ( *own )[3] = calloc( mem_size, 3 * sizeof( int ) );

另一种方式如下

int **own = malloc( mem_size * sizeof( int * ) );

for ( i = 0; i < mem_size; i++ ) own[i] = calloc( 3, sizeof( int ) );

Answer 3

However, every time I reference own[i][j], I get an error saying that the subscripted value is neither array nor pointer nor vector.

没错。 own[i] 等同于 *(own + i)，其类型为 int。您不能将下标运算符应用于 int.

请注意，您的代码似乎试图创建的不是二维数组，而是指针数组。如果这确实是您想要的，那么 own 应该具有类型 int **，并且您应该相应地调整第一个 calloc() 调用。但是，如果你真的想要动态分配一个二维数组，那么那就是：

int (*own)[3];

own = calloc(mem_size, sizeof(*own));

请注意，此时无需单独分配（或释放）行。

然而，还请注意，如果您不需要在超出范围之前重新分配 own，如果您可以假设至少有一个 C99 编译器，并且如果 mem_size 将永远不要太大然后你可以通过可变长度数组更容易地做到这一点：

int own[mem_size][3] = {{0}};

在那种情况下根本不需要显式动态分配或释放，如果不需要，可以省略初始化程序。（我包括初始化器，因为 calloc() 执行分配的 space 的等效初始化。）"Too large" 应该根据在堆栈上分配的数组来解释。

Answer 4

二维数组的类型错误 - 许多人都指出了这一点。

不同的建议解决方案。

分配时，使用 sizeof 变量而不是 sizeof 类型。不太可能出错 - 更容易维护。

//int * own;
int **own;

own = calloc(row_count, sizeof *own);
for (i=0; i<row_count; i++){
  own[i] = calloc(column_count, sizeof *(own[i]));
}

Answer 5

int *own = calloc(100, sizeof(int));

构建数组内存中的二维数组是这样的=>

所以可以用这样的公式来访问

*(own + rows*y +x)

这种数组的使用非常简单和开放，比如我们从内存中取100个单元格，我们可以把它做成一个大小为100整除的数组。
比如100户，可以提供这样大小的数组=>
[1][100]= (自己+1y +x)
[2][50]= (自己+2y +x)
[4][25]= (自己+4y +x)
[5][20]= (自己+5y +x)
[10][10] = (自己 + 10y +x)
对不起，如果我说得不对，因为我会说波斯语而且我不太懂英语

示例：

int *aPtr = calloc(100, sizeof(int));
for(int y=0;y<4;y++){
    for(int x=0;x<25;x++){
        *(own + 25*y +x) = 1;
    }
}

调用一个二维数组

Calloc a Two-Dimensional Array

c

arrays

calloc