Mapear um array 2D em um array 1D

Eu quero representar um array 2D com um array 1D. Uma function passará os dois índices (x, y) e o valor a ser armazenado. Esses dois índices representariam um único elemento de um array 1D e o configurariam de acordo. Eu sei que o array 1D precisa ter o tamanho de arrayWidth × arrayHeight, mas não sei como definir cada elemento.

Por exemplo, como distinguir (2,4,3) de (4,2,3)? Eu tentei definir a matriz como x * y, mas 2 * 4 e 4 * 2 resultariam no mesmo ponto na matriz e eu preciso que eles sejam diferentes.

Exemplo: queremos representar um array 2D de tamanho SIZE_X e SIZE_Y. Isso significa que teremos MAXY linhas consecutivas de tamanho MAXX. Portanto, a function set é

 void set_array( int x, int y, int val ) { array[ x * SIZE_Y + y ] = val; } 

O get seria:

 int get_array( int x, int y ) { return array[ x * SIZE_Y + y ]; } 

A fórmula típica para o recálculo de índices de matriz 2D em um índice de matriz 1D é

 index = indexX * arrayWidth + indexY; 

Alternativamente, você pode usar

 index = indexY * arrayHeight + indexX; 

(supondo que arrayWidth é medido ao longo do eixo X e arrayHeight ao longo do eixo Y)

Naturalmente, pode-se encontrar muitas fórmulas diferentes que fornecem mapeamentos únicos alternativos, mas normalmente não é necessário.

Em linguagens C / C ++, matrizes multidimensionais embutidas são armazenadas na memory para que o último índice mude o mais rápido, significando que para uma matriz declarada como

 int xy[10][10]; 

O elemento xy[5][3] é imediatamente seguido por xy[5][4] na memory. Você pode querer seguir essa convenção também, escolhendo uma das duas fórmulas acima, dependendo de qual índice (X ou Y) você considera ser o “último” dos dois.

Como outros disseram C mapas em ordem de linha

  #include  int main(int argc, char **argv) { int i, j, k; int arr[5][3]; int *arr2 = (int*)arr; for (k=0; k<15; k++) { arr2[k] = k; printf("arr[%d] = %2d\n", k, arr2[k]); } for (i=0; i<5; i++) { for (j=0; j< 3; j++) { printf("arr2[%d][%d] = %2d\n", i, j ,arr[i][j]); } } } 

Saída:

 arr[0] = 0 arr[1] = 1 arr[2] = 2 arr[3] = 3 arr[4] = 4 arr[5] = 5 arr[6] = 6 arr[7] = 7 arr[8] = 8 arr[9] = 9 arr[10] = 10 arr[11] = 11 arr[12] = 12 arr[13] = 13 arr[14] = 14 arr2[0][0] = 0 arr2[0][1] = 1 arr2[0][2] = 2 arr2[1][0] = 3 arr2[1][1] = 4 arr2[1][2] = 5 arr2[2][0] = 6 arr2[2][1] = 7 arr2[2][2] = 8 arr2[3][0] = 9 arr2[3][1] = 10 arr2[3][2] = 11 arr2[4][0] = 12 arr2[4][1] = 13 arr2[4][2] = 14 

usando o exemplo principal da linha:

 A(i,j) = a[i + j*ld]; // where ld is the leading dimension // (commonly same as array dimension in i) // matrix like notation using preprocessor hack, allows to hide indexing #define A(i,j) A[(i) + (j)*ld] double *A = ...; size_t ld = ...; A(i,j) = ...; ... = A(j,i); 

É importante armazenar os dados de maneira que possam ser recuperados nos idiomas usados. C-language armazena em ordem de linha maior (toda a primeira linha vem em primeiro lugar, depois toda a segunda linha, …) com cada índice em execução de 0 até a dimensão-1. Portanto, a ordem da matriz x [2] [3] é x [0] [0], x [0] [1], x [0] [2], x [1] [0], x [1] [ 1], x [1] [2]. Portanto, na linguagem C, x [i] [j] é armazenado no mesmo local que uma input de matriz unidimensional x1dim [i * 3 + j]. Se os dados forem armazenados dessa maneira, é fácil recuperá-los na linguagem C.

Fortran e MATLAB são diferentes. Eles armazenam na ordem principal da coluna (toda a primeira coluna vem primeiro, depois toda a segunda linha, …) e todo índice é executado de 1 à sua dimensão. Portanto, a ordem do índice é o reverso de C e todos os índices são 1 maiores. Se você armazenar os dados na ordem da linguagem C, FORTRAN poderá encontrar X_C_idioma [i] [j] usando X_FORTRAN (j + 1, i + 1). Por exemplo, X_C_language [1] [2] é igual a X_FORTRAN (3,2). Em arrays unidimensionais, esse valor de dados está em X1dim_C_language [2 * Cdim2 + 3], que é a mesma posição que X1dim_FORTRAN (2 * Fdim1 + 3 + 1). Lembre-se que Cdim2 = Fdim1 porque a ordem dos índices é invertida.

MATLAB é o mesmo que FORTRAN. Ada é o mesmo que C, exceto que os índices normalmente começam em 1. Qualquer idioma terá os índices em uma dessas ordens C ou FORTRAN e os índices começarão em 0 ou 1 e poderão ser ajustados de acordo para obter os dados armazenados.

Desculpe se essa explicação é confusa, mas acho que é preciso e importante para um programador saber.

Você deve ser capaz de acessar a matriz 2d com um ponteiro simples no lugar. A matriz [x] [y] será organizada no ponteiro como p [0x * largura + 0y] [0x * largura + 1a] … [0x * largura + n-1y] [1x * largura + 0y] etc .