但是，每次引用own [i][j]时，都会出现一个错误，指出下标值既不是数组，也不是指针或向量。
是的，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()对所分配的空间执行等效的初始化。）"太大"应该解释为与堆栈上正在分配的数组有关。

用途：

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

因为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 ) );

2-D阵列的类型错误-许多人都指出了这一点。
不同的建议解决方案。
分配时，使用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]));
}

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

要在内存中构建一个2D数组，如下所示=〉

所以可以用这样一个公式来计算

*(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;
    }
}