Arduino - Arrays multidimensionais

Matrizes com duas dimensões (ou seja, subscritos) geralmente representam tabelas de valores que consistem em informações organizadas em linhas e colunas.

A seguir estão os principais recursos de matrizes multidimensionais -

Para identificar um elemento particular da tabela, devemos especificar dois subscritos.
Por convenção, o primeiro identifica a linha do elemento e o segundo identifica a coluna do elemento.
Arrays que requerem dois subscritos para identificar um elemento específico são chamados de arrays bidimensionais ou arrays 2-D.
Matrizes com duas ou mais dimensões são conhecidas como matrizes multidimensionais e podem ter mais de duas dimensões.

A figura a seguir ilustra uma matriz bidimensional, a. A matriz contém três linhas e quatro colunas, portanto, é uma matriz 3 por 4. Em geral, uma matriz comm linhas e n colunas são chamadas de m-by-n array.

Cada elemento na matriz a é identificado por um nome de elemento do formulário a[i][j]. Aqui, a é o nome da matriz ei e j são os subscritos que identificam exclusivamente cada elemento em a. Observe que os nomes dos elementos na linha 0 têm um primeiro subscrito de 0; os nomes dos elementos na coluna 3 têm um segundo subscrito de 3.

Uma matriz multidimensional pode ser inicializada em sua declaração de forma muito semelhante a uma matriz unidimensional. Por exemplo, uma matriz bidimensionalb com os valores 1 e 2 na linha 0, os elementos e os valores 3 e 4 na linha 1, os elementos podem ser declarados e inicializados da seguinte maneira -

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

Os valores são agrupados por linha entre colchetes. Portanto, 1 e 2 inicializam b [0] [0] e b [0] [1], respectivamente, e 3 e 4 inicializam b [1] [0] e b [1] [1], respectivamente. Se não houver inicializadores suficientes para uma determinada linha, os elementos restantes dessa linha serão inicializados com 0. Portanto, a seguinte declaração inicializa b [0] [0] para 1, b [0] [1] para 0, b [ 1] [0] a 3 e b [1] [1] a 4.

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

Exemplo

Aqui está um exemplo que demonstra a inicialização de matrizes bidimensionais em declarações.

As linhas a – c declaram três arrays, cada um com duas linhas e três colunas.
A declaração de array1 (linha a) fornece seis inicializadores nas duas sub-listas. A primeira sub-lista inicializa a linha 0 da matriz com os valores 1, 2 e 3; a segunda sub-lista inicializa a linha 1 da matriz com os valores 4, 5 e 6.
Se as chaves ao redor de cada sub-lista forem removidas da lista de inicializadores array1, o compilador inicializa os elementos da linha 0 seguidos pelos elementos da linha 1, produzindo o mesmo resultado.
A declaração de array2 (linha b) fornece apenas cinco inicializadores.
Os inicializadores são atribuídos à linha 0 e, em seguida, à linha 1. Quaisquer elementos que não tenham um inicializador explícito são inicializados com zero, portanto, array2 [1] [2] é inicializado com zero.
A declaração de array3 (linha c) fornece três inicializadores em duas sub-listas.
A sub-lista da linha 0 inicializa explicitamente os dois primeiros elementos da linha 0 a 1 e 2; o terceiro elemento é inicializado implicitamente com zero.
A sub-lista da linha 1 inicializa explicitamente o primeiro elemento em 4 e inicializa implicitamente os dois últimos elementos em zero.
O programa chama a função printArray para gerar os elementos de cada array. Observe que o protótipo da função (linhak) especifique o parâmetro const int a[][columns].
Quando uma função recebe uma matriz unidimensional como argumento, os colchetes da matriz ficam vazios na lista de parâmetros da função.
O tamanho da primeira dimensão de uma matriz bidimensional (ou seja, o número de linhas) também não é necessário, mas todos os tamanhos de dimensão subsequentes são necessários. O compilador usa esses tamanhos para determinar os locais na memória de elementos em matrizes multidimensionais.
Todos os elementos da matriz são armazenados consecutivamente na memória, independentemente do número de dimensões. Em uma matriz bidimensional, a linha 0 é armazenada na memória seguida pela linha 1.

Exemplo

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

Resultado

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- Cada linha é uma matriz unidimensional. Para localizar um elemento em uma linha específica, a função deve saber exatamente quantos elementos existem em cada linha, para que possa pular o número adequado de locais de memória ao acessar o array. Assim, ao acessar a [1] [2], a função sabe pular os três elementos da linha 0 na memória para chegar à linha 1. Em seguida, a função acessa o elemento 2 dessa linha. Muitas manipulações de array comuns usamFOR afirmações.

Por exemplo, o seguinte FOR declaração define todos os elementos na linha 2 da matriz a.

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

o FORdeclaração varia apenas o segundo subscrito (ou seja, o subscrito da coluna). O anteriorFOR declaração é equivalente às seguintes declarações de atribuição -

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

Os seguintes Nested FOR declaração determina o total de todos os elementos na matriz a -

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

o FORdeclaração totaliza os elementos da matriz uma linha de cada vez. O exteriorFOR instrução começa definindo a linha (ou seja, o subscrito da linha) para 0. Portanto, os elementos da linha 0 podem ser totalizados pelo interno FOR declaração.

O exterior FORinstrução então incrementa a linha para 1, de modo que os elementos da linha 1 possam ser totalizados. Então, o exteriorFORinstrução incrementa a linha para 2, de modo que os elementos da linha 2 possam ser totalizados. Quando o aninhadoFOR a instrução termina, o total contém a soma de todos os elementos da matriz.

↰ Previous page