Arduino - Array multidimensionali

Le matrici con due dimensioni (ossia, pedici) spesso rappresentano tabelle di valori costituite da informazioni disposte in righe e colonne.

Di seguito sono riportate le caratteristiche principali degli array multidimensionali:

• Per identificare un particolare elemento della tabella, dobbiamo specificare due pedici.

• Per convenzione, il primo identifica la riga dell'elemento e il secondo identifica la colonna dell'elemento.

• Gli array che richiedono due pedici per identificare un particolare elemento sono chiamati array bidimensionali o array 2-D.

• Gli array con due o più dimensioni sono noti come array multidimensionali e possono avere più di due dimensioni.

La figura seguente mostra una matrice bidimensionale, a. La matrice contiene tre righe e quattro colonne, quindi è una matrice 3 per 4. In generale, un array conm righe e n colonne è chiamato un file m-by-n array.

Ogni elemento nell'array a è identificato dal nome di un elemento del modulo a[i][j]. Qui, a è il nome dell'array ei e j sono i pedici che identificano in modo univoco ogni elemento in a. Si noti che i nomi degli elementi nella riga 0 hanno tutti il ​​primo pedice 0; i nomi degli elementi nella colonna 3 hanno tutti un secondo pedice di 3.

Un array multidimensionale può essere inizializzato nella sua dichiarazione in modo molto simile a un array unidimensionale. Ad esempio, un array bidimensionaleb con i valori 1 e 2 nella sua riga 0 elementi e i valori 3 e 4 nella sua riga 1 gli elementi possono essere dichiarati e inizializzati come segue:

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

I valori sono raggruppati per riga tra parentesi graffe. Pertanto, 1 e 2 inizializzano b [0] [0] e b [0] [1], rispettivamente, e 3 e 4 inizializzano b [1] [0] eb [1] [1], rispettivamente. Se non ci sono abbastanza inizializzatori per una data riga, gli elementi rimanenti di quella riga vengono inizializzati a 0. Pertanto, la seguente dichiarazione inizializza b [0] [0] su 1, b [0] [1] su 0, b [ 1] da [0] a 3 eb [1] [1] a 4.

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

Esempio

Di seguito è riportato un esempio che mostra l'inizializzazione di array bidimensionali nelle dichiarazioni.

• Le righe a – c dichiarano tre array, ciascuno con due righe e tre colonne.

• La dichiarazione di array1 (riga a) fornisce sei inizializzatori nei due sottoelenchi. Il primo sottoelenco inizializza la riga 0 dell'array sui valori 1, 2 e 3; il secondo sottoelenco inizializza la riga 1 dell'array sui valori 4, 5 e 6.

• Se le parentesi graffe attorno a ogni sottoelenco vengono rimosse dall'elenco degli inizializzatori di matrice1, il compilatore inizializza gli elementi della riga 0 seguiti dagli elementi della riga 1, ottenendo lo stesso risultato.

• La dichiarazione di array2 (line b) fornisce solo cinque inizializzatori.

• Gli inizializzatori sono assegnati alla riga 0, quindi alla riga 1. Tutti gli elementi che non hanno un inizializzatore esplicito vengono inizializzati a zero, quindi array2 [1] [2] viene inizializzato a zero.

• La dichiarazione di array3 (line c) fornisce tre inizializzatori in due sottoelenchi.

• La sottoelenco per la riga 0 inizializza esplicitamente i primi due elementi della riga da 0 a 1 e 2; il terzo elemento è implicitamente inizializzato a zero.

• La sottoelenco per la riga 1 inizializza esplicitamente il primo elemento a 4 e implicitamente inizializza gli ultimi due elementi a zero.

• Il programma chiama la funzione printArray per visualizzare gli elementi di ogni array. Si noti che il prototipo di funzione (linek) specificare il parametro const int a[][columns].

• Quando una funzione riceve un array unidimensionale come argomento, le parentesi dell'array sono vuote nell'elenco dei parametri della funzione.

• La dimensione della prima dimensione di una matrice bidimensionale (cioè il numero di righe) non è richiesta, ma sono richieste tutte le dimensioni delle dimensioni successive. Il compilatore utilizza queste dimensioni per determinare le posizioni in memoria degli elementi negli array multidimensionali.

• Tutti gli elementi dell'array vengono archiviati consecutivamente in memoria, indipendentemente dal numero di dimensioni. In una matrice bidimensionale, la riga 0 viene archiviata in memoria seguita dalla riga 1.

Esempio

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

Risultato

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- Ogni riga è una matrice unidimensionale. Per individuare un elemento in una riga particolare, la funzione deve sapere esattamente quanti elementi ci sono in ogni riga in modo da poter saltare il numero corretto di posizioni di memoria quando si accede all'array. Pertanto, quando si accede a [1] [2], la funzione sa di saltare i tre elementi della riga 0 in memoria per arrivare alla riga 1. Quindi, la funzione accede all'elemento 2 di quella riga. Molte comuni manipolazioni di array usanoFOR dichiarazioni.

Ad esempio, il seguente FOR istruzione imposta tutti gli elementi nella riga 2 dell'array a.

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

Il FORistruzione varia solo il secondo pedice (cioè il pedice della colonna). Il precedenteFOR è equivalente alle seguenti istruzioni di assegnazione:

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

Il seguente Nested FOR L'istruzione determina il totale di tutti gli elementi nell'array a -

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

Il FORl'istruzione somma gli elementi dell'array una riga alla volta. L'esternoFOR inizia impostando la riga (cioè il pedice di riga) a 0. Pertanto, gli elementi della riga 0 possono essere sommati dall'interno FOR dichiarazione.

L'esterno FORquindi incrementa la riga a 1, in modo che gli elementi della riga 1 possano essere sommati. Quindi, l'esternoFORL'istruzione incrementa la riga a 2, in modo che gli elementi della riga 2 possano essere sommati. Quando il file annidatoFOR l'istruzione termina, il totale contiene la somma di tutti gli elementi dell'array.