Mapper un tableau 2D sur un tableau 1D

Je veux représenter un tableau 2D avec un tableau 1D. Une fonction transmettra les deux indices (x, y) et la valeur à stocker. Ces deux indices représenteraient un seul élément d’un tableau 1D et le définiraient en conséquence. Je sais que le tableau 1D doit avoir la taille de arrayWidth × arrayHeight, mais je ne sais pas comment définir chaque élément.

Par exemple, comment distinguer (2,4,3) de (4,2,3)? J’ai essayé de définir le tableau comme x * y, mais 2 * 4 et 4 * 2 se traduiraient par le même endroit dans le tableau et j’ai besoin qu’ils soient différents.

Vous devez décider si les éléments du tableau seront stockés dans l’ordre des lignes ou dans l’ordre des colonnes, puis être cohérents à ce sujet. http://en.wikipedia.org/wiki/Row-major_order

Le langage C utilise l’ordre des lignes pour les tableaux multidimensionnels

Pour simuler cela avec un tableau à une seule dimension, vous multipliez l’index de la ligne par la largeur et ajoutez l’index de la colonne:

int array[width * height]; int SetElement(int row, int col, int value) { array[width * row + col] = value; } 

Exemple: nous voulons représenter un tableau 2D de taille SIZE_X et SIZE_Y. Cela signifie que nous aurons des lignes MAXY consécutives de taille MAXX. La fonction set est donc

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

Le get serait:

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

La formule typique pour le recalcul des indices de tableaux 2D en index de tableau 1D est

 index = indexX * arrayWidth + indexY; 

Sinon, vous pouvez utiliser

 index = indexY * arrayHeight + indexX; 

(en supposant que arrayWidth est mesurée le long de l’axe X, et arrayHeight long de l’axe Y)

Bien sûr, on peut proposer de nombreuses formules différentes qui fournissent des correspondances uniques alternatives, mais normalement, il n’y a pas besoin de le faire.

Dans les langages C / C ++, les tableaux multidimensionnels intégrés sont stockés en mémoire afin que le dernier index change le plus rapidement, ce qui signifie que pour un tableau déclaré comme

 int xy[10][10]; 

l’élément xy[5][3] est immédiatement suivi de xy[5][4] en mémoire. Vous pouvez également suivre cette convention en choisissant l’une des deux formules ci-dessus, en fonction de l’index (X ou Y) que vous considérez comme le “dernier” des deux.

Comme d’autres l’ont dit, les cartes C dans l’ordre des lignes

  #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]); } } } 

Sortie:

 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 

en utilisant l’exemple majeur de ligne:

 A(i,j) = a[i + j*ld]; // where ld is the leading dimension // (commonly same as array dimension in i) // masortingx 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); 

Il est important de stocker les données de manière à pouvoir les récupérer dans les langues utilisées. Le langage C est stocké dans l’ordre des lignes principales (toute la première ligne vient en premier, puis toute la deuxième ligne, …) avec chaque index exécuté de 0 à sa dimension-1. Donc, l’ordre du tableau x [2] [3] est x [0] [0], x [0] [1], x [0] [2], x [1] [0], x [1] [ 1], x [1] [2]. Donc, en langage C, x [i] [j] est stocké au même endroit qu’une entrée de tableau à une dimension x1dim [i * 3 + j]. Si les données sont stockées de cette façon, il est facile de les récupérer en langage C.

Fortran et MATLAB sont différents. Ils stockent en ordre majeur (toute la première colonne vient en premier, puis toute la deuxième ligne, …) et chaque index va de 1 à sa dimension. L’ordre des indices est donc l’inverse de C et tous les indices sont supérieurs. Si vous stockez les données dans l’ordre du langage C, FORTRAN peut trouver X_C_language [i] [j] en utilisant X_FORTRAN (j + 1, i + 1). Par exemple, X_C_language [1] [2] est égal à X_FORTRAN (3,2). Dans les tableaux à une dimension, cette valeur de données est à X1dim_C_language [2 * Cdim2 + 3], qui est la même position que X1dim_FORTRAN (2 * Fdim1 + 3 + 1). Rappelez-vous que Cdim2 = Fdim1 car l’ordre des index est inversé.

MATLAB est le même que FORTRAN. Ada est le même que C sauf que les index commencent normalement à 1. N’importe quelle langue aura les index dans l’une de ces commandes C ou FORTRAN et les index commenceront à 0 ou 1 et pourront être ajustés en conséquence pour obtenir les données stockées.

Désolé si cette explication est déroutante, mais je pense que c’est exact et important pour un programmeur de savoir.

Vous devriez pouvoir accéder au tableau 2D avec un simple pointeur en place. Le tableau [x] [y] sera disposé dans le pointeur sous la forme p [0x * width + 0y] [0x * width + 1y] … [0x * width + n-1y] [1x * largeur + 0y] etc. .