Matriz 2D

Una matriz bidimensional (2D) es una matriz de matrices unidimensionales (1D). Los tamaños de la matriz 1D son iguales. La matriz 2D también se llama matriz con filas y columnas.

Veamos el siguiente ejemplo:

Estas 3 matrices 1D se pueden representar como una matriz 2D de la siguiente manera:

Veamos otro ejemplo:

Estas 3 matrices 1D no se pueden representar como una matriz 2D porque los tamaños de las matrices son diferentes.

Declaración de matriz 2D

tipo de datos nombre-matriz[FILA] [COLUMNA]

Tipo de datos es el tipo de datos de los elementos de la matriz.
Array-name es el nombre de la matriz.
Dos subíndices representan el número de filas y columnas de la matriz. El número total de elementos de la matriz será ROW * COL.

int a [2] [3];

Usando el código C anterior, podemos declarar un entero formación, a de tamaño 2 * 3 (2 filas y 3 columnas).

char b [3] [2];

Usando el código C anterior, podemos declarar un personaje formación, B de tamaño 2 * 3 (3 filas y 2 columnas).

Inicialización de matriz 2D

Podemos inicializar durante la declaración de las siguientes formas:

int a [3] [2] = 1,2,3,4,5,6;
int a [] [2] = 1,2,3,4,5,6;
int a [3] [2] = 1, 2, 3, 4, 5, 6;
int a [] [2] = 1, 2, 3, 4, 5, 6;

Tenga en cuenta que en 2 y 4 no hemos mencionado el 1^{S t} subíndice. El compilador de C calcula automáticamente el número de filas a partir del número de elementos. Pero el 2^{Dakota del Norte} se debe especificar el subíndice. Las siguientes inicializaciones no son válidas:

int a [3] [] = 1,2,3,4,5,6;
int a [] [] = 1,2,3,4,5,6;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
dieciséis
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

//Ejemplo 1.C
#incluir
#definir FILA 3
#define COL 2
int main ()

int i, j;
int a [FILA] [COL] =
1,2,
3,4,
5,6
;
printf ("Los elementos en fila de la matriz a son: \ n");
para (i = 0; i
printf ("Fila% d:", i);
para (j = 0; j
printf ("% d", a [i] [j]);

printf ("\ n");

printf ("\ n \ nColumna Los elementos de la matriz a son: \ n");
para (i = 0; i
printf ("Columna% d:", i);
para (j = 0; j
printf ("% d", a [j] [i]);

printf ("\ n");

return 0;

En Example1.c, hemos declarado una matriz de enteros de tamaño 3 * 2 e inicializado. Para acceder a los elementos de la matriz, usamos dos for loop.

Para acceder a las filas, el bucle externo es para filas y el bucle interno es para columnas.

Para acceder a las columnas, el bucle externo es para columnas y el bucle interno es para filas.

Tenga en cuenta que cuando declaramos una matriz 2D, usamos un [2] [3], que significa 2 filas y 3 columnas. La indexación de matrices comienza desde 0. Para acceder a los 2^{Dakota del Norte} fila y 3^rd columna, tenemos que usar la notación a [1] [2].

Mapeo de memoria de una matriz 2D

La vista lógica de una matriz a [3] [2] puede ser como sigue:

La memoria de la computadora es una secuencia de bytes 1D. En lenguaje C, una matriz 2D se almacena en la memoria en orden de fila principal. Algunos otros lenguajes de programación (e.gramo., FORTRAN), se almacena en orden de columna principal en la memoria.

Aritmética de punteros de una matriz 2D

Para comprender la aritmética del puntero de la matriz 2D, primero, eche un vistazo a la matriz 1D.

Considere una matriz 1D:

En matriz 1D, a es una constante, y su valor es la dirección del 0^th ubicación de la matriz a [5]. Valor de a + 1 es la dirección del 1^{S t} ubicación de la matriz a [5]. a + i es la dirección del I^th ubicación de la matriz.

Si incrementamos a en 1, se incrementa por el tamaño del tipo de datos.

a [1] es equivalente a * (a + 1)

a [2] es equivalente a * (a + 2)

ai] es equivalente a * (a + i)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
dieciséis
17
18
19
20
21

// Ejemplo2.C
#incluir
#definir FILA 3
#define COL 2
int main ()

int a [5] = 10,20,30,40,50;
printf ("tamaño de (int):% ld \ n \ n", tamaño de (int));
printf ("a:% p \ n", a);
printf ("a + 1:% p \ n", a + 1);
printf ("a + 2:% p \ n \ n", a + 2);
printf ("a [1]:% d, * (a + 1):% d \ n", a [1], * (a + 1));
printf ("a [2]:% d, * (a + 2):% d \ n", a [1], * (a + 1));
printf ("a [3]:% d, * (a + 3):% d \ n", a [1], * (a + 1));
return 0;

En Example2.c, la dirección de memoria se muestra en hexadecimal. La diferencia entre a y a + 1 es 4, que es el tamaño de un número entero en bytes.

Ahora, considere una matriz 2D:

B es un puntero de tipo: int [] [4] o int (*) [4]

int [] [4] es una fila de 4 enteros. Si incrementamos b en 1, se incrementa por el tamaño de la fila.

B es la dirección del 0^th fila.

b + 1 es la dirección del 1^{S t} fila.

b + yo es la direccion de I^th fila.

El tamaño de una fila es: (Número de columna * tamaño de (tipo de datos)) bytes

El tamaño de una fila de una matriz de enteros b [3] [4] es: 4 * tamaño de (int) = 4 * 4 = 16 bytes

Una fila de una matriz 2D puede verse como una matriz 1D. B es la dirección del 0^th fila. Entonces, obtenemos lo siguiente

* b + 1 es la dirección del 1^{S t} elemento de la 0^th
* b + j es la dirección del j^th elemento de la 0^th
* (b + i) es la dirección del 0^th elemento de la I^th
* (b + i) + j es la dirección del j^th elemento de la I^th
b [0] [0] es equivalente a ** b
b [0] [1] es equivalente a * (* b + 1)
b [1] [0] es equivalente a * (* (b + 1))
b [1] [1] es equivalente a * (* (b + 1) +1)
b [i] [j] es equivalente a * (* (b + i) + j)

Dirección de b [i] [j]: b + sizeof (tipo de datos) * (Número de columna * i + j)

Considere una matriz 2D: int b [3] [4]

La dirección de b [2] [1] es : b + tamaño de (int) * (4 * 2 + 1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
dieciséis
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// Ejemplo3.C
#incluir
#definir FILA 3
#define COL 4
int main ()

int i, j;
int b [FILA] [COL] =
10,20,30,40,
50,60,70,80,
90,100,110,120
;
printf ("tamaño de (int):% ld \ n", tamaño de (int));
printf ("Tamaño de una fila:% ld \ n", COL * sizeof (int));
printf ("b:% p \ n", b);
printf ("b + 1:% p \ n", b + 1);
printf ("b + 2:% p \ n", b + 2);
printf ("* b:% p \ n", * b);
printf ("* b + 1:% p \ n", * b + 1);
printf ("* b + 2:% p \ n", * b + 2);
printf ("b [0] [0]:% d ** b:% d \ n", b [0] [0], ** b);
printf ("b [0] [1]:% d * (* b + 1):% d \ n", b [0] [1], * (* b + 1));
printf ("b [0] [2]:% d * (* b + 2):% d \ n", b [0] [2], * (* b + 2));
printf ("b [1] [0]:% d * (* (b + 1)):% d \ n", b [1] [0], * (* (b + 1)));
printf ("b [1] [1]:% d * (* (b + 1) +1):% d \ n", b [1] [1], * (* (b + 1) +1) );
return 0;

En Example3.c, hemos visto que el tamaño de una fila es 16 en notación decimal. La diferencia entre b + 1 y b es 10 en hexadecimal. 10 en hexadecimal es equivalente a 16 en decimal.

Conclusión

Entonces, en este artículo, hemos aprendido sobre

Declaración de matriz 2D
Inicialización de matriz 2D
Mapeo de memoria de matriz 2D
Aritmética de puntero de matriz 2D

Ahora podemos usar una matriz 2D en nuestro programa C sin ninguna duda,

Referencias

El crédito por algunas ideas en este trabajo se inspiró en el curso, Punteros y matrices 2-D, del Departamento de Ciencias de la Computación y Engg de Palash Dey. Instituto Indio de Tecnología Kharagpur