Hola y bienvenidos.
Vamos a ver a continuación cómo se copian los arreglos en el lenguaje C.
Están listos?
Vamos.
Bien, ya hemos visto los tipos primitivos como los tipos y los tipos float, etcétera y como trabajan
al momento de copiar sus valores.
Pero también ya sabemos que podemos copiar su dirección de memoria aplicando el concepto de apuntadores.
Ahora vamos a ver esto de manera similar, pero cuando trabajamos con arreglos y vamos a ver que existen
algunas diferencias importantes, ya que los arreglos por default almacenan la dirección de memoria
del primer elemento al cual están apuntando.
Así que de alguna manera los arreglos también son un tipo de apuntador.
Así que vamos a ver las diferencias entre los tipos primitivos, como los tipos int, float, etcétera
y el uso de arreglos.
Bien Por ello, en primer lugar, vamos a definir una variable de tipo arreglo.
Recordemos que la diferencia es que vamos a utilizar corchetes al momento de definir una variable de
tipo arreglo.
Posteriormente, utilizando la sintaxis simplificada para declarar un arreglo entre llaves, agregamos
los valores de 100 y 200 serían los elementos almacenados en los índices cero, el valor de 100 y en
el índice uno el valor de 200.
Ahora vamos a copiar la referencia de esta variable del arreglo uno.
Lo vamos a copiar hacia otro arreglo.
Así que definimos una variable, pero que va a ser un apuntador.
En este caso no es tal cual un arreglo, pero la sintaxis va a ser muy similar al manejo de arreglos.
Vamos a ver a continuación esta sintaxis.
Así que podemos saber que en primer lugar, eso sería definir un apuntador.
Es el tipo de dato de la variable a la cual queremos apuntar posteriormente un asterisco y finalmente
el nombre de la variable.
Pero también vamos a ver que esto nos va a permitir apuntar hacia un arreglo.
Y a diferencia de los tipos primitivos, en este caso, cuando le queremos pasar la referencia de memoria
de una variable de tipo arreglo, no hay necesidad de utilizar ampersand, así que le pasamos directamente
el nombre de la variable de arreglo.
Por ello, hemos comentado que una variable de tipo arreglo se parece a un apuntador, ya que en este
caso el arreglo almacena directamente una dirección de memoria, de manera muy similar al manejo de
apuntadores.
Por ello es que no tenemos que utilizar ampersand para asignar la dirección de memoria que almacena
la variable de arreglo y se asigna directamente a esta dirección de memoria a la variable de arreglo.
Dos.
Bien, entonces los tipos de datos hemos comentado que deben ser del mismo tipo tanto la variable de
arreglo dos.
Que es el apuntador y el tipo de dato de la variable de arreglo.
Así que con esto lo que estamos consiguiendo es que tanto la variable de apuntador arreglo dos y la
variable arreglo uno apuntan exactamente a la misma dirección de memoria.
Esto quiere decir que si modificamos alguno de los índices de nuestro arreglo, podemos observar que
la sintaxis es exactamente igual, ya sea con la variable de tipo apuntador o con la variable de tipo
arreglo.
Así que la variable de tipo apuntador simplemente vamos a especificar el índice del elemento que queremos
modificar.
En este caso estamos modificando el valor del índice cero en lugar de 100.
Lo estamos escribiendo por el valor de 500.
Así que un cambio utilizando la variable de arreglo dos modifica también la variable de arreglo uno.
Ya que ambas apuntan exactamente a la misma dirección de memoria.
Y para movernos entre los elementos, entonces ya sabemos que si es un arreglo podemos simplemente especificar
el índice, así que por ello podemos acceder, por ejemplo, en este caso al índice cero.
Utilizando tanto el arreglo, uno iba a mandar a imprimir ahora el nuevo valor, el valor de 500.
Pero también podemos acceder a este mismo valor utilizando la variable de arreglo dos.
Aunque es una variable de tipo apuntador, la sintaxis es exactamente la misma, y si accedemos al mismo
índice, entonces también van a imprimir el valor de 500, ya que en ambos casos las dos variables apuntan
exactamente a la misma dirección de memoria y es el concepto básico del manejo de arreglos.
Y aplicando ahora también el concepto de dirección de memoria combinándolo con apuntadores.
Vamos a ver, por último, cómo trabajar con arreglos y funciones, aplicando precisamente lo que hemos
visto anteriormente, el concepto de paso por referencia.
Así que vamos a ver el tema de paso por referencia con arreglos para ello.
En primer lugar, vamos a definir nuestra función paso por referencia.
El parámetro va a ser una variable de tipo apuntador, así que de manera muy similar a lo que ya revisamos,
esta variable va a poder apuntar a un arreglo sin ningún problema, ya que simplemente va a recibir
una dirección de memoria y de manera interna.
Esta función lo que va a intentar realizar es acceder a los índices de nuestro arreglo para modificar
sus valores.
Así que en este caso vamos a modificar tanto el índice cero.
Ahora le vamos a actualizar su valor por el valor de 500 y también al índice uno de ese arreglo le vamos
a modificar su valor ahora por el valor de 600.
Así que esta función va a intentar realizar estos cambios sobre el arreglo que vamos a pasar como referencia.
Bien, y posteriormente en la función principal vamos a definir un arreglo.
En este caso la variable se llama argumento, pero es un arreglo con los valores de 100 y 200 respectivamente
en el inicio cero y en el índice uno.
Posteriormente mandamos a llamar nuestra función de paso referencia y le pasamos el argumento en este
caso.
Debido a que es un arreglo, no requiere utilizar el ampersand, Así que esa es una de las diferencias
importantes cuando trabajamos con arreglos.
Los arreglos por default lo que almacenan es una dirección de memoria.
Por ello es que no se requiere utilizar el ampersand.
A diferencia de los tipos primitivos, donde ya sabemos que si tenemos que utilizar ampersand para pasar
correctamente una dirección de memoria, bien.
Así que una vez que pasamos la referencia.
Entonces.
Por último.
Vamos a intentar acceder a los elementos al índice cero para comprobar que la función sí pudo realizar
los cambios.
Por ello, en este caso, a través de la variable de arreglo más externa, accedemos al índice cero
y obtenemos el nuevo valor de 500.
Y si queremos acceder al C1, también accedemos al nuevo valor de 600.
Si llegáramos a ejecutar nuestra función en memoria, sucede lo siguiente Tenemos nuestra variable de
argumento que se crea en memoria.
Pero recordemos que en este caso son dos índices los que estamos utilizando.
Por ello es que la variable de argumento apunta a la dirección de memoria del primer elemento de nuestro
arreglo.
No es que almacene todas las direcciones de memoria, sino que solamente almacena una dirección de memoria
del primer elemento de nuestro arreglo, y entonces se almacenan los valores de 100 y 200 según la inicialización
de nuestro arreglo.
Posteriormente mandamos a llamar nuestra función de paso por referencia y se va a inicializar nuestra
variable de apuntador.
Así que la variable de apuntador ahora apunta a la dirección de memoria de la variable de argumento.
Pero recordemos que esta variable de argumento lo que almacena es la dirección de memoria del primer
elemento de nuestro arreglo.
Por ello, la variable de parámetro almacena la dirección de memoria 0X333 y para poder acceder a sus
elementos, entonces tenemos que utilizar los índices.
Por ello, cuando se empieza a ejecutar nuestra función para poder acceder al primer índice, accedemos
al primer índice, al índice de cero.
Y entonces, con la sintaxis que estamos utilizando, modificamos el valor de 100 al valor de 500.
En este caso podemos observar que no hay necesidad de utilizar el asterisco, ya que aunque es un apuntador,
estamos utilizando la sintaxis de arreglos.
Por lo tanto aquí ya no tenemos que poner asterisco, sino simplemente especificar el índice al cual
queremos acceder y como siguiente paso en la siguiente línea modificamos el índice uno y por lo tanto
el valor en lugar de 200.
Ahora ya tenemos el valor de 600.
Se termina de ejecutar esta función.
Regresamos el control a la función principal y ahora cuando mandamos a imprimir utilizando la variable
de argumento, el arreglo de argumento se manda imprimir con el índice cero el valor de 500, ya que
es el valor almacenado en esta dirección de memoria.
Y si queremos mandar a imprimir el índice uno, entonces ahora se imprime el valor de 600, ya que tenemos
los índices cero y el índice uno utilizando la sintaxis de arreglos.
Y en conclusión, los arreglos se pasan por default por referencia, así que no se requiere utilizar
ampersand para pasar la referencia de memoria de un arreglo.
Y también cuando queremos acceder a los elementos de un arreglo, pero que estamos trabajando con apuntadores,
no requerimos utilizar asterisco.
Es decir, que no tenemos que aplicar el concepto de referencia, ya que por default las variables de
tipo apuntador que a su vez apuntan a un arreglo.
Entonces no requiere utilizar asterisco.
Simplemente utilizamos la sintaxis de arreglos y con esto ya estamos accediendo a los elementos, a
los índices de nuestro arreglo.
Bien, vamos a detener hasta aquí y en el siguiente vídeo vamos a realizar este ejercicio para que todo
quede completamente claro.
Así que continuamos.
Saludos.