Matriz 2d

Pilar Melgar

Una matriz bidimensional (2D) es una matriz de matrices unidimensionales (1D). Los tamaños de 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 pueden representarse como una matriz 2D porque los tamaños de las matrices son diferentes.

Declaración de matriz 2D

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

Tipo de datos es el tipo de datos de los elementos de la matriz.
El nombre de la matriz 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á fila*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 la matriz 2D

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

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^calle subíndice. El compilador C calcula automáticamente el número de filas 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
#Define la fila 3
#Define Col 2
int main ()

int i, j;
int a [fila] [col] =
1,2,
3,4,
5,6
;
printf ("Los elementos sabios de la 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 \ ncolumn elementos sabios 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");

regresar 0;

En el ejemplo1.c, hemos declarado una matriz entera del tamaño 3*2 e inicializados. Para acceder a elementos de matriz, usamos dos para bucle.

Para acceder a la fila, el bucle exterior es para filas y el bucle interno es para columnas.

Para acceder a la columna, el bucle exterior 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 matriz 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 el siguiente:

La memoria de la computadora es una secuencia 1D de bytes. En el lenguaje C, una tienda de matriz 2D en la memoria en orden de la fila. Algunos otros lenguajes de programación (E.gramo., Fortran), se almacena en Orden de columna mayor en la memoria.

Aritmética de puntero 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 una 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^calle Ubicación de la matriz A [5]. A+I es la dirección del i^th Ubicación de la matriz.

Si nos incrementamos a Para 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
#Define la fila 3
#Define Col 2
int main ()

int a [5] = 10,20,30,40,50;
printf ("sizeof (int): %ld \ n \ n", sizeof (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));
regresar 0;

En el ejemplo2.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 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^calle fila.

b+yo es la dirección de i^th fila.

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

Tamaño de una fila de una matriz entera b [3] [4] es: 4 * sizeof (int) = 4 * 4 = 16 bytes

Se puede ver una fila de una matriz 2D 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^calle elemento del 0^th
*B+J es la dirección del j^th elemento del 0^th
*(B+I) es la dirección del 0^th elemento del i^th
*(b+i)+j es la dirección del j^th elemento del 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 + sizeof (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
#Define la 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 ("sizeof (int): %ld \ n", sizeof (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) );
regresar 0;

En el ejemplo3.c, hemos visto que el tamaño de una fila es de 16 en notación decimal. La diferencia entre b+1 yb 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 la matriz 2D
Mapeo de memoria de la matriz 2D
Aritmética de puntero de la 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, consejos y matrices 2-D, por Palash Dey Departamento de Informática y Engg. Instituto Indio de Tecnología Kharagpur

php

Cómo usar la función php str_split

La función php str_split () es una herramienta útil para dividir las cadenas en caracteres individua...

Lorenzo Canales

c agudo

Cómo usar la palabra clave larga en C#

La palabra clave larga en C# puede definir una variable que puede contener un valor entero firmado e...

Pilar Alemán

C ++

Cómo declarar variables en c++?

Para declarar una variable en C ++, debe especificar su tipo de datos y nombre. Además, lea esta guí...

Mariana Cotto