Вызов двумерного массива

Использовать:

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

Однако каждый раз, когда я ссылаюсь на own[i][j], я получаю сообщение об ошибке, говорящее о том, что значение с индексом не является ни массивом, ни указателем, ни вектором.

Это верно. own[i] эквивалентно *(own + i), имеющему тип int. Вы не можете применить оператор нижнего индекса к int.

Обратите внимание, что ваш код пытается создать не двумерный массив, а скорее массив указателей. Если это действительно то, что вам нужно, то own должен иметь тип int **, и вы должны соответствующим образом настроить первый вызов calloc(). Если вам действительно нужно динамическое выделение 2D-массива, то это будет:

int (*own)[3];

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

Обратите внимание, что тогда нет необходимости выделять (или освобождать) строки отдельно.

Однако обратите внимание, что если вам никогда не нужно перераспределять own до того, как он выйдет за рамки, если вы можете предположить, по крайней мере, компилятор C99, и если mem_size никогда не будет слишком большим, вы можете сделать это еще проще через массив переменной длины:

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

В этом случае вообще не требуется явного динамического выделения или освобождения, а инициализатор можно опустить, если он не нужен. (Я включаю инициализатор, потому что calloc() выполняет эквивалентную инициализацию выделенного пространства.) «Слишком большой» следует интерпретировать по отношению к массиву, выделенному в стеке.

Поскольку 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 ) );

Неправильный тип для двумерного массива - многие хорошо указывали.

Другое предлагаемое решение.

При распределении используйте 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]= (собственный + 2 y +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;
    }
}