Указание конкретной позиции в 2D-массиве

Question

Каков метод задания позиции в 2D-массиве. Я не имею в виду получение значения через subscriptip, но аналогично 1D массиву, где с помощью указателя можно использовать оператор + и перейти в эту позицию.

Например, если у меня есть массив A размера 4, я могу перейти к третьему элементу на A + 2.

Как бы это сделать, когда у меня есть 2D-массив?

Answer 1

Разъязыванием разговора на один уровень за раз. Для массива 2D и 3D массива:

#include <cstdio> 

int A[2][2]; 

int B[2][2][2]; 

int main() { 
    // Set A[1][1] to 2 
    *(*(A+1) + 1) = 2; 
    printf("%d\n", A[1][1]); 

    // Set B[1][1][1] to 3 
    *(*(*(B+1) + 1) + 1) = 3; 
    printf("%d", B[1][1][1]); 
} 

В общем *(...*(*(array_of_N_dimensions + D1) + D2) ... + DN) обеспечит вам доступ к array_of_N_dimensions[D1][D2]...[DN].

Answer 2

Где A - массив, R - это строка, а C - столбец.

*(A + R) + C 

дает адрес A[R][C]

Answer 3

Да, вы правы. Вы можете получить доступ к элементу, умножив размер строки на размер столбца и добавив индекс столбца.

Предположит, целочисленный массив является arr[NUMBER_OF_ROWS][NUMBER_OF_COLUMNS], то вы можете получить доступ к arr[ROW_INDEX][COLUMN_INDEX] элементу как:

int num = *((int *)arr + ROW_INDEX * NUMBER_OF_COLUMNS + COLUMN_INDEX); 

Answer 4

вопрос неясен, но вот некоторые мысли.

В языке нет многомерных массивов, поддерживаются только одномерные массивы с некоторыми дополнительными гарантиями. То, что обычно называют двумерным массивом, представляет собой массив 1D объектов массива типа данного типа. Дополнительные гарантии - это функции смежности и выравнивания: каждый элемент массива смежна со следующим элементом в массиве, а массив и первый элемент выравниваются.

Массивы имеют тенденцию к распада на указатель на первый элемент, и вы можете использовать арифметику указателей, чтобы перейти к следующему элементу в массиве, который является тем, что позволяет синтаксис A + 2 значение: &A[0] + 2 или указатель, является результатом добавления 2 в первый (нулевой) элемент в массиве. Но распад - это только верхний уровень.

Гарантии, изложенные до того, как вы можете использовать массив, как если бы он был указателем на первый элемент, и этот элемент находится в том же месте, что и сам массив. Применяя это рекурсивно к вложенному массиву, который вы можете получить на следующее:

int array[10][10]; 
// array is an array of 10 arrays of 10 int 
// array[0] is an array of 10 int, the first subarray 
// array[0][0] is an int, the first element of the subarray 
int *p = &array[0][0]; 
int *q = p + 10;   // One beyond the first subarray: pointer to the first 
          // element of the second subarray. 
int *r = p + 10*row + col; // pointer to the col-th element inside the row-th subarray 
          // equivalent to &array[row][col] 

Answer 5

2-мерные массивы хранятся строки после строки в памяти, так что вы можете получить доступ к A[i][j] используя индексA+i*N+j где N является длиной строки.

Answer 6

Вот вам код для самообучения. Надеюсь, это поможет.

#include <iostream> 

int main() 
{ 
    int a[2][2]; 

    a[0][0] = 1; 
    a[0][1] = 2; 
    a[1][0] = 3; 
    a[1][1] = 4; 


    for (int i=0; i < 4; ++i) 
    { 
     std::cout << *(*a+i) << std::endl; 
    } 

    return 0; 
} 

Answer 7

Другие ответы, основываясь на арифметику указателей, технически правильно, но только если вы уверены, что ваш массив выделяется как A [строк] [перевалы]. Это очень часто бывает не так, и даже если вы реализуете свой массив, вы не можете быть уверены, что другой разработчик не будет реорганизовывать его. В тот момент, когда другой разработчик меняет тип A [rows] [cols] на вектор < vector < type>> Ваш код сломается.

Поэтому я бы посоветовал НЕ использовать арифметику указателей по строкам. Если вас беспокоит производительность - не делайте этого: компилятор автоматически использует арифметику указателя для доступа к элементам массива, где это применимо. Что еще более важно, компилятор не будет использовать арифметику указателя, если это не применимо.