Arduino - Baies multidimensionnelles

Les tableaux à deux dimensions (c'est-à-dire les indices) représentent souvent des tableaux de valeurs constitués d'informations disposées en lignes et en colonnes.

Voici les principales caractéristiques des tableaux multidimensionnels -

• Pour identifier un élément de table particulier, nous devons spécifier deux indices.

• Par convention, le premier identifie la ligne de l'élément et le second identifie la colonne de l'élément.

• Les tableaux qui nécessitent deux indices pour identifier un élément particulier sont appelés tableaux à deux dimensions ou tableaux 2-D.

• Les tableaux à deux dimensions ou plus sont appelés tableaux multidimensionnels et peuvent avoir plus de deux dimensions.

La figure suivante illustre un tableau à deux dimensions, a. Le tableau contient trois lignes et quatre colonnes, il s'agit donc d'un tableau 3 par 4. En général, un tableau avecm lignes et n colonnes s'appelle un m-by-n array.

Chaque élément du tableau a est identifié par un nom d'élément du formulaire a[i][j]. Ici, a est le nom du tableau, eti et j sont les indices qui identifient de manière unique chaque élément de a. Notez que les noms des éléments de la ligne 0 ont tous un premier indice de 0; les noms des éléments de la colonne 3 ont tous un deuxième indice de 3.

Un tableau multidimensionnel peut être initialisé dans sa déclaration un peu comme un tableau unidimensionnel. Par exemple, un tableau à deux dimensionsb avec les valeurs 1 et 2 dans sa ligne 0, les éléments et les valeurs 3 et 4 dans sa ligne 1, les éléments peuvent être déclarés et initialisés comme suit -

int b[ 2 ][ 2 ] = { { 1, 2 }, { 3, 4 } };

Les valeurs sont regroupées par ligne entre accolades. Par conséquent, 1 et 2 initialisent b [0] [0] et b [0] [1], respectivement, et 3 et 4 initialisent b [1] [0] et b [1] [1], respectivement. S'il n'y a pas assez d'initialiseurs pour une ligne donnée, les éléments restants de cette ligne sont initialisés à 0. Ainsi, la déclaration suivante initialise b [0] [0] à 1, b [0] [1] à 0, b [ 1] [0] à 3 et b [1] [1] à 4.

int b[ 2 ][ 2 ] = { { 1 }, { 3, 4 } };

Exemple

Voici un exemple qui illustre l'initialisation de tableaux à deux dimensions dans les déclarations.

• Les lignes a – c déclarent trois tableaux, chacun avec deux lignes et trois colonnes.

• La déclaration de array1 (ligne a) fournit six initialiseurs dans les deux sous-listes. La première sous-liste initialise la ligne 0 du tableau aux valeurs 1, 2 et 3; la deuxième sous-liste initialise la ligne 1 du tableau aux valeurs 4, 5 et 6.

• Si les accolades autour de chaque sous-liste sont supprimées de la liste d'initialisation array1, le compilateur initialise les éléments de la ligne 0 suivis des éléments de la ligne 1, donnant le même résultat.

• La déclaration de array2 (line b) ne fournit que cinq initialiseurs.

• Les initialiseurs sont affectés à la ligne 0, puis à la ligne 1. Tous les éléments qui n'ont pas d'initialiseur explicite sont initialisés à zéro, donc array2 [1] [2] est initialisé à zéro.

• La déclaration de array3 (line c) fournit trois initialiseurs dans deux sous-listes.

• La sous-liste de la ligne 0 initialise explicitement les deux premiers éléments de la ligne 0 à 1 et 2; le troisième élément est implicitement initialisé à zéro.

• La sous-liste de la ligne 1 initialise explicitement le premier élément à 4 et initialise implicitement les deux derniers éléments à zéro.

• Le programme appelle la fonction printArray pour afficher les éléments de chaque tableau. Notez que la fonction prototype (lignek) spécifiez le paramètre const int a[][columns].

• Lorsqu'une fonction reçoit un tableau unidimensionnel comme argument, les crochets du tableau sont vides dans la liste des paramètres de la fonction.

• La taille de la première dimension d'un tableau à deux dimensions (c'est-à-dire le nombre de lignes) n'est pas non plus requise, mais toutes les tailles de dimension suivantes sont requises. Le compilateur utilise ces tailles pour déterminer les emplacements en mémoire des éléments dans les tableaux multidimensionnels.

• Tous les éléments du tableau sont stockés consécutivement en mémoire, quel que soit le nombre de dimensions. Dans un tableau à deux dimensions, la ligne 0 est stockée en mémoire suivie de la ligne 1.

Exemple

void printArray ( const int [][ 3 ] ); // prototype
const int rows = 2;
const int columns = 3;
int array1[ rows ][ columns ] = { { 1, 2, 3 }, { 4, 5, 6 } };
int array2[ rows ][ columns ] = { 1, 2, 3, 4, 5 };
int array3[ rows ][ columns ] = { { 1, 2 }, { 4 } };

void setup () {

}
void loop () {
   Serial.print ("Values in array1 by row are: ") ;
   Serial.print (“\r” ) ;
   printArray(array1) ;
   Serial.print ("Values in array2 by row are: ") ;
   Serial.print (“\r” ) ;
   printArray(array2) ;
   Serial.print ("Values in array3 by row are: ") ;
   Serial.print (“\r” ) ;
   printArray(array3) ;
}

// output array with two rows and three columns

void printArray( const int a[][ columns ] ) {
   // loop through array's rows
   for ( int i = 0; i < rows; ++i ) {
      // loop through columns of current row
      for ( int j = 0; j < columns; ++j )
      Serial.print (a[ i ][ j ] );
      Serial.print (“\r” ) ; // start new line of output
   } 
// end outer for
} 

// end function printArray

Résultat

Values in array1 by row are:
1 2 3
4 5 6
Values in array2 by row are:
1 2 3
4 5 0
Values in array3 by row are:
1 2 0
4 0 0

Note- Chaque ligne est un tableau unidimensionnel. Pour localiser un élément dans une ligne particulière, la fonction doit savoir exactement combien d'éléments se trouvent dans chaque ligne afin de pouvoir ignorer le nombre approprié d'emplacements de mémoire lors de l'accès au tableau. Ainsi, en accédant à un [1] [2], la fonction sait sauter les trois éléments de la ligne 0 en mémoire pour arriver à la ligne 1. Ensuite, la fonction accède à l'élément 2 de cette ligne. De nombreuses manipulations de tableaux courantes utilisentFOR déclarations.

Par exemple, ce qui suit FOR L'instruction définit tous les éléments de la ligne 2 du tableau a.

for ( int column = 0; column < 4; ++column )
   a[ 2 ][ column ] = 0;

le FORl'instruction ne varie que le deuxième indice (c'est-à-dire l'indice de colonne). Le précédentFOR instruction équivaut aux instructions d'affectation suivantes -

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

Le suivant Nested FOR L'instruction détermine le total de tous les éléments du tableau a -

total = 0;
for ( int row = 0; row < 3; ++row )
for ( int column = 0; column < 4; ++column )
total += a[ row ][ column ];

le FORL'instruction totalise les éléments du tableau une ligne à la fois. L'extérieurFOR L'instruction commence par définir la ligne (c'est-à-dire l'indice de ligne) à 0. Par conséquent, les éléments de la ligne 0 peuvent être totalisés par le FOR déclaration.

L'extérieur FORL'instruction incrémente ensuite la ligne à 1, de sorte que les éléments de la ligne 1 puissent être totalisés. Puis, l'extérieurFORL'instruction incrémente la ligne à 2, de sorte que les éléments de la ligne 2 puissent être totalisés. Lorsque le imbriquéFOR se termine, le total contient la somme de tous les éléments du tableau.