Hola, bienvenidos!
Vamos a ver un ejemplo para poner en práctica el uso de arreglos y funciones en el lenguaje C.
Están listas?
Vamos.
Bien, vamos a quitar todo nuestro código para poner en práctica este ejemplo utilizando arreglos y
funciones.
En primer lugar, vamos a definir nuestra función.
La función va a ser de tipo void, no va a regresar nada, se va a llamar cambiar valor.
Y lo que vamos a hacer desde esta función es intentar cambiar los valores del arreglo a través del parámetro
que vamos a recibir en esta función.
Y el parámetro que vamos a recibir en esta función es un apuntador, así que definimos un apuntador.
El arreglo almacena valores de tipo entero, por lo tanto, también nuestro apuntador apunta a elementos
de tipo entero y entonces, de manera interna vamos a intentar cambiar los valores del arreglo.
Así que cambiamos los valores del arreglo y recordemos que un apuntador de alguna manera también tiene
la sintaxis de un arreglo.
Así que simplemente utilizamos la sintaxis del arreglo para indicar el índice del arreglo que queremos
modificar.
En ese caso, queremos modificar el índice cero y le vamos a cambiar su valor por el valor de cuatro.
Posteriormente vamos a cambiar el segundo elemento del arreglo, es decir, el índice uno.
Le asignamos el valor de cinco.
Y finalmente, el segundo elemento le asignamos el valor de seis.
Ahora, dentro de la función principal, vamos a definir nuestro arreglo.
Definimos nuestra variable llamada arreglo.
Obviamente puede ser cualquier otro nombre y lo vamos a inicializar con los valores de uno, dos y tres
respectivamente.
Así que esos son los valores iniciales de nuestro arreglo.
Y ya posteriormente, cuando mandemos a llamar nuestra función, vamos a intentar cambiar los valores
de cada uno de los elementos del arreglo.
Ahora, antes de mandar a llamar nuestra función, vamos a mandar a imprimir los elementos de nuestro
arreglo.
En este momento no podemos mandar a imprimir directamente el nombre del arreglo solamente, ya que esto
imprimiría la dirección de memoria del primer elemento del arreglo.
Así que necesitamos indicar que elemento del arreglo queremos imprimir.
Así que.
Valores.
Del arreglo vamos a imprimir los valores son tres elementos, los separamos simplemente por un espacio
y posteriormente necesitamos acceder a estos tres elementos.
Aquí voy a hacer un poco más pequeño el nombre del arreglo.
Simplemente le voy a poner arg de argumento para que sea más breve el nombre del arreglo y así podemos
acceder a cada uno de los elementos, así que accedemos al elemento cero.
Posteriormente, separados por coma, accedemos al elemento dos y finalmente al elemento tres.
Pero aquí recordemos que tiene que ser el índice uno y el índice dos.
El elemento dos y el elemento tres tienen el índice uno y el índice dos.
Y posteriormente ya podemos mandar a llamar nuestra función de cambiar valor y le pasamos la variable
de argumento.
Y entonces podemos observar que en este caso no hay necesidad de poner un ampersand, ya que la variable
de argumento debido a que es un arreglo.
Entonces no hay necesidad de agregar esta sintaxis, ya que esta sintaxis al definir un arreglo, esta
variable almacena directamente la referencia de memoria del primer elemento al cual está apuntando este
arreglo y por lo tanto, cuando mandamos a llamar nuestra función, aquí se está pasando la referencia
de memoria del primer elemento de nuestro arreglo.
Así que este apuntador precisamente va a acceder al primer elemento de nuestro arreglo y posteriormente
con la sintaxis de arreglos.
Entonces vamos a poder acceder a cada uno de sus elementos, en este caso para asignarle, por ejemplo,
nuevos valores.
Y podemos saber que tampoco tenemos que utilizar asterisco, ya que la sintaxis de un apuntador es muy
similar al manejo de arreglos.
Y por último, volvemos a imprimir cada uno de los valores simplemente para saber si ya se modificaron.
Así que voy a copiar esta línea y posteriormente volvemos a imprimir los valores del arreglo.
Esto es antes de llamar la función.
Y aquí es después de llamar la función.
Bien, pero antes de ejecutar aquí, voy a agregar un salto de línea para que no se junten estos elementos,
se impriman en líneas diferentes.
Volvemos a ejecutar.
Y entonces podemos observar que la primera vez que se mandan a imprimir los valores de nuestro arreglo,
accedemos a los elementos cero, uno y dos y observamos que se imprimen los valores de uno, dos y tres
con normalidad.
Pero posteriormente, después que pasamos este argumento, este arreglo como referencia, pasamos la
referencia a nuestro método de cambiar valor.
Entonces este apuntador puede acceder a los mismos elementos ya que están apuntando exactamente a la
misma dirección de memoria y con la sintaxis de arreglos.
Entonces, lo que estamos haciendo es que en memoria estamos accediendo exactamente al mismo arreglo
y por lo tanto esto realiza los cambios dentro del mismo arreglo, dentro de la misma dirección de memoria.
Y una vez que termina, entonces volvemos a imprimir y podemos ver que se imprimen ahora los valores
ya modificados.
Los valores de cuatro, cinco y seis se ejecutarán paso a paso en nuestro programa.
En la línea 12 se va a crear nuestro arreglo en memoria.
Así que si se ejecuta esta línea, entonces en memoria se crea un arreglo dentro del método principal.
Se crea un arreglo y cada uno de sus elementos con los índices cero, uno y dos respectivamente.
Estamos inicializando esos valores con los valores de uno, dos y tres y podemos ver que cada elemento
de nuestro arreglo tiene su propia dirección de memoria.
Ahora, si se ejecuta la línea 13, entonces se van a imprimir los valores de uno, dos y tres, ya
que son los valores que tenemos en memoria.
Posteriormente, si se ejecuta la línea 14, entonces se manda a llamar nuestra función de cambiar el
valor.
Así que en memoria sucede lo siguiente se crean, se agrega al stack nuestra función y también se crea
la variable de parámetro.
Y la variable de parámetro se inicializa con el valor que contiene nuestro arreglo.
Recordemos aquí ya no tenemos que pasar el ampersand, ya tenemos la referencia de memoria, ya que
es un arreglo y entonces podemos observar que el arreglo lo que hace es pasar su propia dirección de
memoria para inicializar este apuntador.
Pero podemos observar que la dirección de memoria es solamente la dirección de memoria del primer elemento
del arreglo.
Así que es lo que se pasa a nuestro apuntador, y entonces el apuntador ya tiene la misma dirección
de memoria del primer elemento del arreglo.
No es que tengan las direcciones de memoria de cada elemento del arreglo, sino que solamente tiene
la dirección de memoria del índice cero del arreglo, y entonces, con la sintaxis de arreglos va a
poder acceder a cada uno de estos elementos para poderlos modificar.
Bien, esto es lo que vamos a ver a continuación.
Hasta el momento se está ejecutando la línea tres donde se inicializa nuestro apuntador.
Bien, posteriormente se ejecutará la línea cinco.
Entonces utilizando nuestra variable de apuntador, pero con la sintaxis del arreglo, entonces accedemos
en primer lugar a la dirección de memoria.
Posteriormente accedemos al elemento cero y finalmente modificamos el valor, el contenido de la celda
de este índice cero.
Así que por ello este valor de cuatro se almacena en el índice cero de nuestro arreglo tal como estamos
indicando y ya los demás elementos.
Es exactamente el uso de los arreglos.
Accedemos al índice uno.
Por lo tanto.
Se modifica ahora por el valor de cinco y posteriormente si se llega a ejecutar la línea siete, entonces
podemos observar el índice dos y se modifica ahora por el valor de seis.
Y entonces observamos con esto que la variable de apuntador ya modificó exactamente el mismo arreglo,
los mismos elementos en memoria de la variable más externa, del arreglo más externo.
Y entonces, una vez que termina la ejecución de nuestra función, se va a eliminar de memoria, incluyendo
la variable de apuntador, la variable de parámetro.
Así que si terminamos de ejecutar la función, entonces se quita de memoria.
Regresamos el control a la línea 14.
No hay nada más que procesar ya que esta función regresa.
Un tipo void no regresa nada.
Y por último se ejecuta la línea 15 y al momento de ejecutarse la línea 15.
Entonces podemos comprobar que ahora los elementos que se están mandando a imprimir son precisamente
los últimos elementos, los últimos cambios en el inicio cero.
Tenemos ahora el valor de cuatro en el índice uno, el valor de cinco y finalmente en el índice dos
el valor de seis.
Así que prácticamente aquí estamos aplicando el concepto también de paso por referencia, ya que los
arreglos almacenan por default la referencia de su primer elemento.
Por lo tanto, al momento de mandar a llamar nuestra función, este apuntador está recibiendo la referencia
del primer elemento, como ya hemos analizado bien, y con eso entonces estamos poniendo en práctica
el uso de paso por referencia, combinándolo con el manejo de arreglos.
Bien, pongan en práctica lo que hemos visto, y si aún lo necesitan, pueden ejecutar paso a paso.
Eso es todo por este vídeo y nos vemos en la siguiente lección.
Saludos.