Hola y bienvenidos.
Vamos a empezar a trabajar con las matrices en el lenguaje C.
Están listos?
Vamos.
Bien.
Vamos a abrir nuestro IDE de ya y vamos entonces a trabajar con el concepto de matrices.
Así que vamos a definir una matriz.
En este caso la matriz.
Como hemos comentado, vamos a especificar en primer lugar el tipo de dato, posteriormente el identificador
y abrimos un par de corchetes.
En el primer corchete vamos a especificar la cantidad de renglones que va a tener nuestra matriz.
En este caso son dos renglones y posteriormente la cantidad de columnas que va a tener nuestra matriz.
Con eso solamente estamos definiendo nuestra matriz.
Sin embargo, en este caso voy a crear algunas constantes para especificar estos valores y no poner
estos valores directamente en la definición de la matriz.
Así que voy a hacer lo siguiente Voy a definir dos constantes.
Una constante.
En primer lugar para especificar la cantidad de renglones.
Y otra constante para especificar la cantidad de columnas.
Esto no es necesario realizarlo, simplemente es para que tengamos un poco más de orden y claridad de
nuestro código.
Así que aquí vamos a especificar la constante de renglones.
Y aquí la constante de columnas.
De esta forma es más claro que estamos definiendo una matriz de cierta cantidad de renglones por cierta
cantidad de columnas.
Pero bien podríamos especificar directamente los renglones y las columnas como lo vimos anteriormente.
Bien, entonces en memoria tenemos lo siguiente podemos visualizar nuestra animación.
Recordemos que esta ventana no es parte del IDE, es una animación que nosotros le estamos agregando
simplemente para que todo quede más claro.
Entonces definimos nuestra constante de renglones con el valor de dos y de columnas con el valor de
tres, y entonces se crea en memoria una matriz.
Podemos observar que a final de cuentas es un arreglo, pero de dos dimensiones.
Así que este es el primer renglón y ese es el segundo renglón.
Esta es la primera columna.
Segunda y tercera columna.
Por lo tanto, es una matriz de dos renglones por tres columnas.
Así que hasta aquí únicamente hemos definido la matriz.
Se ha reservado espacio de memoria para cada uno de los elementos que vamos a trabajar con nuestra matriz.
Posteriormente vamos a modificar.
Los valores de la matriz.
Para ello vamos a utilizar el nombre de nuestra matriz y posteriormente especificamos el renglón y la
columna que deseamos modificar.
Así que de igual manera, utilizando corchetes, podemos especificar tanto el renglón en primer lugar
y posteriormente en la columna que queremos modificar.
En este caso vamos a modificar el renglón cero, columna cero y al primer elemento le vamos a asignar
el valor de 100.
Pueden asignar cualquier valor de tipo entero, pero simplemente para que tengamos un orden y que todo
este ejemplo quede más claro.
Y entonces en nuestra animación podemos observar que si lo ejecutamos en memoria se asignaría el valor
de 100 a los índices de renglón cero, columna cero en el orden que estamos mencionando.
Posteriormente, si queremos modificar otro elemento de igual manera no tiene que ser en el orden en
que se crea nuestra matriz, pero nosotros vamos a seguir ese orden simplemente para que todo quede
más claro.
Así que vamos a modificar el renglón cero, columna uno y le asignamos, por ejemplo, el valor de 200.
Y si actualizamos nuestra animación, entonces tenemos el valor de 200.
En el renglón cero, columna uno son exactamente los mismos índices que estamos indicando.
Bien.
Posteriormente en el renglon cero columna dos especificamos el valor de 300, así que se actualiza este
valor también en nuestra animación.
Y ahora vamos con el segundo renglón.
Todos estos elementos son el primer renglón, es decir, el renglón cero.
Ahora sí vamos con el segundo renglón, entonces es el renglón uno, ya que recordemos que los índices
comienzan en cero y la columna se vuelve a iniciar.
Así que en este caso es renglón uno, pero la columna es cero y le asignamos, por ejemplo, el valor
de 400.
Y si actualizamos nuestra animación, entonces en el renglón uno, columna cero asignamos el valor de
400.
Estamos modificando el valor basura por el valor de 400 y así continuamos con los demás elementos.
Ahora, para el renglón uno, columna uno, le asignamos el valor de 500, así que en nuestra animación
tendríamos en memoria lo siguiente En el renglón uno, columna uno asignamos el valor de 500.
Y por último, para el renglón uno, columna dos le asignamos el valor de 600.
Así que en nuestra animación este sería el último elemento de nuestra matriz.
El renglón uno, columna dos.
Así que hasta aquí estamos modificando los valores de nuestra matriz.
Y por último, vamos a leer.
Los valores de la matriz, vamos a acceder solamente a algunos de estos valores.
Cabe mencionar que simplemente para leer la información simplemente podemos utilizar el identificador
y posteriormente agregar los índices.
Con eso prácticamente ya estamos leyendo y recuperando la información de los índices que estamos especificando.
Así que en este caso el valor de 100 es lo que estamos accediendo con esta sintaxis.
Es decir, que no tenemos que utilizar la función printf para leer la información de una matriz.
Simplemente si utilizamos este método es para que lo podamos visualizar en consola, pero para leer
la información realmente simplemente con el nombre del identificador de la matriz y con los índices
de renglón y columna estamos accediendo a este valor.
Es decir, que en este punto ya lo estamos leyendo y entonces aquí lo podríamos asignar a cualquier
otra variable, por ejemplo, el valor uno de nuestra matriz.
Y entonces con esto ya estamos recuperando la información, el valor de 100 y se está asignando a la
variable de valor uno.
Pero para no realizar esto, esa sería otra forma de recuperar la información.
Entonces vamos a acceder directamente, vamos a mandar a imprimir directamente el valor, en este caso
del índice con renglón cero y columna cero.
Así que en este caso esto lo que va a regresar es el valor de 100.
Bien, pero vamos a ejecutarlo para comprobarlo.
Y entonces podemos ver que estamos recuperando el valor de 100.
Así que realmente la función simplemente la estamos utilizando para que podamos observar y visualizar
el valor que estamos recuperando.
Pero ya sabemos que no es necesario simplemente con utilizar el nombre de la variable y posteriormente
de los índices respectivos recuperamos ya el valor que estemos indicando.
Bien, y ahora vamos a mandar imprimir otro elemento, por ejemplo, el último elemento de nuestra matriz.
Que está almacenado en el índice uno, renglón uno y columna dos.
Así que esto es lo que va a recuperar.
Es el valor de 600.
Vamos a dar un salto de línea en primer lugar para que no se impriman en la misma línea.
Vamos a ejecutar y entonces podemos observar que se imprime el último valor, el valor de 600.
En primer lugar, con esta sintaxis estamos recuperando este valor.
El valor del renglón cero, columna cero se recupera el valor de 100 y por ello ese valor que se manda
a imprimir.
Y con la segunda línea estamos indicando el índice uno.
Columna dos.
Así que este es el valor que estamos recuperando, el valor de 600 y es el valor que se manda a imprimir.
Bien.
Así que, básicamente, esas son las funciones básicas para trabajar con matrices.
En primer lugar, la definición o declaración.
Posteriormente modificamos los elementos de la matriz aclarando que no necesitamos modificar todos los
elementos.
Ya sabemos que los elementos que no inicializamos van a contener el valor basura.
Y por último leemos los valores de la matriz.
También De igual manera, solamente podríamos leer los valores que necesitemos.
No tenemos que leer todos los valores de la matriz, así que esas son las operaciones básicas de una
matriz.
Pongo en la práctica y nos vemos en el siguiente video.
Saludos.