Arduino: matrices multidimensionales

Las matrices con dos dimensiones (es decir, subíndices) a menudo representan tablas de valores que constan de información organizada en filas y columnas.

Las siguientes son las características clave de las matrices multidimensionales:

Para identificar un elemento de tabla en particular, debemos especificar dos subíndices.
Por convención, el primero identifica la fila del elemento y el segundo identifica la columna del elemento.
Las matrices que requieren dos subíndices para identificar un elemento en particular se denominan matrices bidimensionales o matrices 2-D.
Las matrices con dos o más dimensiones se conocen como matrices multidimensionales y pueden tener más de dos dimensiones.

La siguiente figura ilustra una matriz bidimensional, a. La matriz contiene tres filas y cuatro columnas, por lo que es una matriz de 3 por 4. En general, una matriz conm filas y n columnas se llama un m-by-n array.

Cada elemento de la matriz a se identifica por un nombre de elemento de la forma a[i][j]. Aquí, a es el nombre de la matriz yi y j son los subíndices que identifican de forma única cada elemento en a. Observe que todos los nombres de los elementos en la fila 0 tienen un primer subíndice de 0; todos los nombres de los elementos de la columna 3 tienen un segundo subíndice de 3.

Una matriz multidimensional se puede inicializar en su declaración de forma muy similar a una matriz unidimensional. Por ejemplo, una matriz bidimensionalb con los valores 1 y 2 en sus elementos de la fila 0 y los valores 3 y 4 en sus elementos de la fila 1 podrían declararse e inicializarse de la siguiente manera:

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

Los valores están agrupados por filas entre llaves. Por lo tanto, 1 y 2 inicializan b [0] [0] yb [0] [1], respectivamente, y 3 y 4 inicializan b [1] [0] yb [1] [1], respectivamente. Si no hay suficientes inicializadores para una fila dada, los elementos restantes de esa fila se inicializan a 0. Por lo tanto, la siguiente declaración inicializa b [0] [0] a 1, b [0] [1] a 0, b [ 1] [0] a 3 yb [1] [1] a 4.

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

Ejemplo

A continuación, se muestra un ejemplo que demuestra la inicialización de matrices bidimensionales en declaraciones.

Las líneas a – c declaran tres matrices, cada una con dos filas y tres columnas.
La declaración de array1 (línea a) proporciona seis inicializadores en las dos sublistas. La primera sublista inicializa la fila 0 de la matriz a los valores 1, 2 y 3; la segunda sublista inicializa la fila 1 de la matriz a los valores 4, 5 y 6.
Si las llaves alrededor de cada sublista se eliminan de la lista de inicializadores array1, el compilador inicializa los elementos de la fila 0 seguidos de los elementos de la fila 1, obteniendo el mismo resultado.
La declaración de array2 (línea b) proporciona solo cinco inicializadores.
Los inicializadores se asignan a la fila 0, luego a la fila 1. Todos los elementos que no tienen un inicializador explícito se inicializan a cero, por lo que array2 [1] [2] se inicializa a cero.
La declaración de array3 (línea c) proporciona tres inicializadores en dos sublistas.
La sublista de la fila 0 inicializa explícitamente los dos primeros elementos de la fila 0 en 1 y 2; el tercer elemento se inicializa implícitamente a cero.
La sublista de la fila 1 inicializa explícitamente el primer elemento a 4 e implícitamente inicializa los dos últimos elementos a cero.
El programa llama a la función printArray para generar los elementos de cada matriz. Observe que la función prototipo (líneak) especificar el parámetro const int a[][columns].
Cuando una función recibe una matriz unidimensional como argumento, los corchetes de la matriz están vacíos en la lista de parámetros de la función.
El tamaño de la primera dimensión de una matriz bidimensional (es decir, el número de filas) tampoco es necesario, pero se requieren todos los tamaños de dimensión posteriores. El compilador usa estos tamaños para determinar las ubicaciones en la memoria de elementos en matrices multidimensionales.
Todos los elementos de la matriz se almacenan consecutivamente en la memoria, independientemente del número de dimensiones. En una matriz bidimensional, la fila 0 se almacena en la memoria seguida de la fila 1.

Ejemplo

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 fila es una matriz unidimensional. Para ubicar un elemento en una fila en particular, la función debe saber exactamente cuántos elementos hay en cada fila para que pueda omitir el número adecuado de ubicaciones de memoria al acceder a la matriz. Por lo tanto, al acceder a [1] [2], la función sabe omitir los tres elementos de la fila 0 en la memoria para llegar a la fila 1. Luego, la función accede al elemento 2 de esa fila. Muchas manipulaciones comunes de matrices usanFOR declaraciones.

Por ejemplo, lo siguiente FOR declaración establece todos los elementos en la fila 2 de la matriz a.

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

los FORdeclaración varía sólo el segundo subíndice (es decir, el subíndice de columna). El precedenteFOR declaración es equivalente a las siguientes declaraciones de asignación:

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

El seguimiento Nested FOR declaración determina el total de todos los elementos en la matriz a -

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

los FORdeclaración totaliza los elementos de la matriz una fila a la vez. El exteriorFOR instrucción comienza estableciendo la fila (es decir, el subíndice de la fila) en 0. Por lo tanto, los elementos de la fila 0 pueden ser totalizados por el interior FOR declaración.

El exterior FORa continuación, incrementa la fila a 1, de modo que los elementos de la fila 1 puedan totalizarse. Entonces, el exteriorFORinstrucción incrementa la fila a 2, de modo que los elementos de la fila 2 se pueden sumar. Cuando el anidadoFOR termina, el total contiene la suma de todos los elementos de la matriz.

↰ Previous page