Matriz de matrices en C ++

Una matriz de matrices, también conocida como una matriz bidimensional, es una estructura de datos en C ++ que le permite almacenar múltiples matrices de datos en un formato de cuadrícula. A diferencia de una matriz unidimensional, que almacena los datos en una sola fila, una matriz bidimensional puede almacenar los datos en múltiples filas y columnas. Cada elemento en la matriz es en sí mismo una matriz, con un número fijo de elementos que corresponde al número de columnas en la matriz.

Las matrices bidimensionales pueden ser útiles para almacenar datos que tienen múltiples dimensiones o que se organizan en una tabla o cuadrícula. Por ejemplo, puede usar una matriz bidimensional para almacenar las calificaciones para un grupo de estudiantes, y cada fila representa un estudiante diferente y cada columna que representa una tarea o examen diferente.

Declaración de matriz multidimensional en C++

Para declarar una matriz de matrices en C ++, debe usar la siguiente sintaxis:

En esta sintaxis, Data_Type se refiere al tipo de datos que se almacena en la matriz. El array_name es el nombre de la matriz. Los num_rows son el número de filas en la matriz. Y num_cols son el número de columnas en la matriz.

Diferentes formas de declarar las matrices multidimensionales en C++

Utilizamos una matriz de tipo entero para que podamos comprender fácilmente el funcionamiento de las matrices en C ++ y cómo colocamos los datos en filas y columnas de matriz. El programa que sigue declara una matriz de matrices enteras. Crea una matriz de 3 × 3 de la cuadrícula de nombre que es un tipo entero:

Int Grid [3] [3];

Como aprendimos en la sintaxis anterior, 3 × 3 significa que hay 3 filas y 3 columnas en la matriz. Por ejemplo: queremos asignar el valor que es 25 al elemento en la segunda fila y la tercera columna de la matriz de la cuadrícula.

cuadrícula [1] [2] = 25;

Esto establece el valor del elemento en la segunda fila y la tercera columna que tiene un índice basado en cero de 1 y 2, respectivamente, a 25. También puede inicializar una variedad de matrices cuando lo declara. Por ejemplo, el siguiente código declara e inicializa una cuadrícula de caracteres 2 × 2:

Char Board [2] [2] = 'x', 'o',
'BUEY';

Esto crea una matriz de 2 × 2 de "tablero" que contiene los caracteres con los valores "X", "O", "O" y "X". Para iterar sobre una variedad de matrices, utilizaremos los bucles.

Ejemplo 1: Demostrando una matriz multidimensional de tipo entero

Aquí está el primer ejemplo simple de matrices multidimensionales en C++. En este ejemplo, primero incluimos los archivos de encabezado básicos que son útiles para obtener la entrada e imprimir la salida en la ventana de la consola de usuario. Luego, iniciamos la función Main () para que podamos demostrar fácilmente el funcionamiento de matrices multidimensionales.

Primero, inicializamos una matriz de tipo INT del nombre de "cuadrícula" que contiene 3 filas y 3 columnas en él. Luego, almacenamos algunos datos en la cuadrícula. Para obtener los datos de la matriz de la cuadrícula, utilizamos un bucle for-bucle que funcione iterativamente para imprimir todos los datos de la cuadrícula en la pantalla de salida.

#incluir
#incluir
usando el espacio de nombres STD;
int main ()

Int Grid [3] [3] = 1, 4, 7,
2, 5, 8,
3, 6, 9;
para (int i = 0; i < 3; ++i)

para (int j = 0; j < 3; ++j)

cout << grid[i][j] << " ";

cout << endl;

Este código imprime la siguiente salida:

Ejemplo 2: Demostrando el arreglo de asientos de una sala de cine a través de matrices multidimensionales en C++

Aquí hay otro ejemplo de una variedad de matrices en C++. Supongamos que queremos almacenar el arreglo de asientos de una sala de cine donde cada asiento puede estar vacío u ocupado. Podemos usar una matriz bidimensional para almacenar estos datos, con cada fila que representa una fila diferente de asientos y cada columna que representa un asiento diferente en esa fila. Declaramos una matriz bidimensional llamada "asiento" con 5 filas y 10 columnas.

Cada fila se representa una fila separada de asientos, y cada columna representa un asiento diferente dentro de esa fila. Inicializamos la matriz con algunos datos de muestra donde 0 representa un asiento vacío y 1 representa un asiento ocupado. Para acceder a un asiento específico, podemos usar el índice de fila y columna de ese asiento.

Por ejemplo, para verificar si el asiento en la tercera fila y la quinta columna están vacías, usamos la declaración if-else. Por ejemplo: los asientos [2] representa la tercera fila de la matriz que contiene la disposición de los asientos para la tercera fila de asientos. Asiento [2] [4] representa el quinto elemento de la tercera fila, que es el asiento en la tercera fila y la quinta columna.

Luego, utilizamos el bucle for-bucle que itera repetidamente sobre los artículos de la matriz y lleva a cabo las operaciones necesarias en cada asiento.

#incluir
#incluir
usando el espacio de nombres STD;
int main ()

int asiento [5] [10] = 0, 0, 0, 1, 1, 1, 1, 0, 0, 0,
0, 1, 1, 1, 1, 1, 1, 1, 1, 0,
0, 1, 1, 0, 0, 0, 0, 1, 1, 0,
1, 1, 0, 0, 0, 0, 0, 0, 1, 1,
1, 1, 0, 0, 0, 0, 0, 0, 1, 1;
int seatstatus = asiento [2] [4];
if (seatStatus == 0)
cout << "Seat is empty" << endl;
demás
cout << "Seat is occupied" << endl;

int
para (int i = 0; i < 5; i++)
para (int j = 0; j < 10; j++)
if (asiento [i] [j] == 1)
asientos ocupados ++;



cout << "There are " << occupiedSeats << " occupied seats." << endl;

En esta ilustración, el bucle interno y el bucle exterior iteran alternativamente sobre cada fila en la matriz. La declaración if (asiento [i] [j] == 1) dentro de la verificación del bucle interno si el asiento actual está ocupado. Si es así, incrementa el mostrador de asiento ocupado. Al final de los bucles, el programa genera el número total de asientos ocupados. Aquí está la salida que se genera compilando el programa anterior:

Conclusión

Aprendimos que una matriz de matrices es una estructura de datos que contiene múltiples matrices dentro de una sola matriz, lo que permite la representación de datos en una estructura de matriz. También aprendimos cómo crear estructuras de datos más complejas, como tablas o cubos de datos. Si bien pueden ser poderosos, trabajar con matrices de matrices también puede ser más complejo y requerir una buena comprensión de la sintaxis y los métodos. Es por eso que implementamos múltiples ejemplos para que podamos entender fácilmente los conceptos.