1
00:00:01,220 --> 00:00:02,160
Hola, bienvenidos!

2
00:00:02,210 --> 00:00:06,970
Vamos a ver un ejemplo para poner en práctica el uso de arreglos y funciones en el lenguaje C.

3
00:00:07,190 --> 00:00:08,000
Están listas?

4
00:00:08,030 --> 00:00:08,480
Vamos.

5
00:00:09,940 --> 00:00:15,100
Bien, vamos a quitar todo nuestro código para poner en práctica este ejemplo utilizando arreglos y

6
00:00:15,100 --> 00:00:15,730
funciones.

7
00:00:16,210 --> 00:00:18,430
En primer lugar, vamos a definir nuestra función.

8
00:00:18,820 --> 00:00:23,830
La función va a ser de tipo void, no va a regresar nada, se va a llamar cambiar valor.

9
00:00:24,220 --> 00:00:30,010
Y lo que vamos a hacer desde esta función es intentar cambiar los valores del arreglo a través del parámetro

10
00:00:30,010 --> 00:00:31,540
que vamos a recibir en esta función.

11
00:00:31,840 --> 00:00:37,090
Y el parámetro que vamos a recibir en esta función es un apuntador, así que definimos un apuntador.

12
00:00:37,570 --> 00:00:42,730
El arreglo almacena valores de tipo entero, por lo tanto, también nuestro apuntador apunta a elementos

13
00:00:42,730 --> 00:00:47,770
de tipo entero y entonces, de manera interna vamos a intentar cambiar los valores del arreglo.

14
00:00:49,210 --> 00:00:54,400
Así que cambiamos los valores del arreglo y recordemos que un apuntador de alguna manera también tiene

15
00:00:54,400 --> 00:00:56,020
la sintaxis de un arreglo.

16
00:00:56,260 --> 00:01:02,140
Así que simplemente utilizamos la sintaxis del arreglo para indicar el índice del arreglo que queremos

17
00:01:02,140 --> 00:01:02,740
modificar.

18
00:01:03,010 --> 00:01:08,050
En ese caso, queremos modificar el índice cero y le vamos a cambiar su valor por el valor de cuatro.

19
00:01:08,350 --> 00:01:13,180
Posteriormente vamos a cambiar el segundo elemento del arreglo, es decir, el índice uno.

20
00:01:13,420 --> 00:01:15,010
Le asignamos el valor de cinco.

21
00:01:16,790 --> 00:01:19,550
Y finalmente, el segundo elemento le asignamos el valor de seis.

22
00:01:19,880 --> 00:01:23,840
Ahora, dentro de la función principal, vamos a definir nuestro arreglo.

23
00:01:26,290 --> 00:01:29,200
Definimos nuestra variable llamada arreglo.

24
00:01:30,360 --> 00:01:35,310
Obviamente puede ser cualquier otro nombre y lo vamos a inicializar con los valores de uno, dos y tres

25
00:01:35,310 --> 00:01:36,270
respectivamente.

26
00:01:36,660 --> 00:01:38,900
Así que esos son los valores iniciales de nuestro arreglo.

27
00:01:38,940 --> 00:01:43,470
Y ya posteriormente, cuando mandemos a llamar nuestra función, vamos a intentar cambiar los valores

28
00:01:43,470 --> 00:01:45,570
de cada uno de los elementos del arreglo.

29
00:01:46,290 --> 00:01:50,970
Ahora, antes de mandar a llamar nuestra función, vamos a mandar a imprimir los elementos de nuestro

30
00:01:50,970 --> 00:01:51,390
arreglo.

31
00:01:51,690 --> 00:01:56,670
En este momento no podemos mandar a imprimir directamente el nombre del arreglo solamente, ya que esto

32
00:01:56,670 --> 00:02:00,090
imprimiría la dirección de memoria del primer elemento del arreglo.

33
00:02:00,330 --> 00:02:03,930
Así que necesitamos indicar que elemento del arreglo queremos imprimir.

34
00:02:04,170 --> 00:02:04,620
Así que.

35
00:02:05,070 --> 00:02:05,670
Valores.

36
00:02:07,090 --> 00:02:13,630
Del arreglo vamos a imprimir los valores son tres elementos, los separamos simplemente por un espacio

37
00:02:14,020 --> 00:02:16,750
y posteriormente necesitamos acceder a estos tres elementos.

38
00:02:17,170 --> 00:02:19,480
Aquí voy a hacer un poco más pequeño el nombre del arreglo.

39
00:02:19,960 --> 00:02:25,930
Simplemente le voy a poner arg de argumento para que sea más breve el nombre del arreglo y así podemos

40
00:02:25,930 --> 00:02:30,250
acceder a cada uno de los elementos, así que accedemos al elemento cero.

41
00:02:30,550 --> 00:02:36,520
Posteriormente, separados por coma, accedemos al elemento dos y finalmente al elemento tres.

42
00:02:37,510 --> 00:02:41,290
Pero aquí recordemos que tiene que ser el índice uno y el índice dos.

43
00:02:41,470 --> 00:02:45,070
El elemento dos y el elemento tres tienen el índice uno y el índice dos.

44
00:02:45,670 --> 00:02:50,140
Y posteriormente ya podemos mandar a llamar nuestra función de cambiar valor y le pasamos la variable

45
00:02:50,140 --> 00:02:50,830
de argumento.

46
00:02:51,310 --> 00:02:56,950
Y entonces podemos observar que en este caso no hay necesidad de poner un ampersand, ya que la variable

47
00:02:56,950 --> 00:02:59,260
de argumento debido a que es un arreglo.

48
00:02:59,560 --> 00:03:04,570
Entonces no hay necesidad de agregar esta sintaxis, ya que esta sintaxis al definir un arreglo, esta

49
00:03:04,570 --> 00:03:10,120
variable almacena directamente la referencia de memoria del primer elemento al cual está apuntando este

50
00:03:10,120 --> 00:03:15,400
arreglo y por lo tanto, cuando mandamos a llamar nuestra función, aquí se está pasando la referencia

51
00:03:15,400 --> 00:03:17,980
de memoria del primer elemento de nuestro arreglo.

52
00:03:18,190 --> 00:03:22,690
Así que este apuntador precisamente va a acceder al primer elemento de nuestro arreglo y posteriormente

53
00:03:22,690 --> 00:03:24,430
con la sintaxis de arreglos.

54
00:03:24,550 --> 00:03:28,900
Entonces vamos a poder acceder a cada uno de sus elementos, en este caso para asignarle, por ejemplo,

55
00:03:28,900 --> 00:03:29,650
nuevos valores.

56
00:03:29,890 --> 00:03:34,720
Y podemos saber que tampoco tenemos que utilizar asterisco, ya que la sintaxis de un apuntador es muy

57
00:03:34,720 --> 00:03:36,220
similar al manejo de arreglos.

58
00:03:36,910 --> 00:03:41,710
Y por último, volvemos a imprimir cada uno de los valores simplemente para saber si ya se modificaron.

59
00:03:41,890 --> 00:03:46,270
Así que voy a copiar esta línea y posteriormente volvemos a imprimir los valores del arreglo.

60
00:03:47,240 --> 00:03:50,090
Esto es antes de llamar la función.

61
00:03:50,450 --> 00:03:52,550
Y aquí es después de llamar la función.

62
00:03:53,040 --> 00:03:57,650
Bien, pero antes de ejecutar aquí, voy a agregar un salto de línea para que no se junten estos elementos,

63
00:03:57,650 --> 00:03:59,000
se impriman en líneas diferentes.

64
00:03:59,240 --> 00:04:00,350
Volvemos a ejecutar.

65
00:04:01,510 --> 00:04:05,200
Y entonces podemos observar que la primera vez que se mandan a imprimir los valores de nuestro arreglo,

66
00:04:05,200 --> 00:04:10,840
accedemos a los elementos cero, uno y dos y observamos que se imprimen los valores de uno, dos y tres

67
00:04:10,840 --> 00:04:11,740
con normalidad.

68
00:04:11,920 --> 00:04:18,160
Pero posteriormente, después que pasamos este argumento, este arreglo como referencia, pasamos la

69
00:04:18,160 --> 00:04:20,470
referencia a nuestro método de cambiar valor.

70
00:04:20,620 --> 00:04:25,750
Entonces este apuntador puede acceder a los mismos elementos ya que están apuntando exactamente a la

71
00:04:25,750 --> 00:04:28,510
misma dirección de memoria y con la sintaxis de arreglos.

72
00:04:28,630 --> 00:04:32,830
Entonces, lo que estamos haciendo es que en memoria estamos accediendo exactamente al mismo arreglo

73
00:04:33,130 --> 00:04:37,690
y por lo tanto esto realiza los cambios dentro del mismo arreglo, dentro de la misma dirección de memoria.

74
00:04:37,960 --> 00:04:42,760
Y una vez que termina, entonces volvemos a imprimir y podemos ver que se imprimen ahora los valores

75
00:04:42,760 --> 00:04:43,780
ya modificados.

76
00:04:43,780 --> 00:04:48,310
Los valores de cuatro, cinco y seis se ejecutarán paso a paso en nuestro programa.

77
00:04:48,310 --> 00:04:51,340
En la línea 12 se va a crear nuestro arreglo en memoria.

78
00:04:51,520 --> 00:04:56,830
Así que si se ejecuta esta línea, entonces en memoria se crea un arreglo dentro del método principal.

79
00:04:56,830 --> 00:05:02,170
Se crea un arreglo y cada uno de sus elementos con los índices cero, uno y dos respectivamente.

80
00:05:02,440 --> 00:05:07,900
Estamos inicializando esos valores con los valores de uno, dos y tres y podemos ver que cada elemento

81
00:05:07,900 --> 00:05:10,570
de nuestro arreglo tiene su propia dirección de memoria.

82
00:05:10,690 --> 00:05:16,090
Ahora, si se ejecuta la línea 13, entonces se van a imprimir los valores de uno, dos y tres, ya

83
00:05:16,090 --> 00:05:17,800
que son los valores que tenemos en memoria.

84
00:05:18,370 --> 00:05:23,470
Posteriormente, si se ejecuta la línea 14, entonces se manda a llamar nuestra función de cambiar el

85
00:05:23,470 --> 00:05:23,860
valor.

86
00:05:24,070 --> 00:05:30,100
Así que en memoria sucede lo siguiente se crean, se agrega al stack nuestra función y también se crea

87
00:05:30,100 --> 00:05:31,480
la variable de parámetro.

88
00:05:32,980 --> 00:05:37,180
Y la variable de parámetro se inicializa con el valor que contiene nuestro arreglo.

89
00:05:37,360 --> 00:05:41,470
Recordemos aquí ya no tenemos que pasar el ampersand, ya tenemos la referencia de memoria, ya que

90
00:05:41,470 --> 00:05:46,390
es un arreglo y entonces podemos observar que el arreglo lo que hace es pasar su propia dirección de

91
00:05:46,390 --> 00:05:48,850
memoria para inicializar este apuntador.

92
00:05:48,850 --> 00:05:53,710
Pero podemos observar que la dirección de memoria es solamente la dirección de memoria del primer elemento

93
00:05:53,710 --> 00:05:54,310
del arreglo.

94
00:05:54,550 --> 00:05:58,990
Así que es lo que se pasa a nuestro apuntador, y entonces el apuntador ya tiene la misma dirección

95
00:05:58,990 --> 00:06:01,390
de memoria del primer elemento del arreglo.

96
00:06:01,450 --> 00:06:05,680
No es que tengan las direcciones de memoria de cada elemento del arreglo, sino que solamente tiene

97
00:06:05,680 --> 00:06:11,050
la dirección de memoria del índice cero del arreglo, y entonces, con la sintaxis de arreglos va a

98
00:06:11,050 --> 00:06:14,050
poder acceder a cada uno de estos elementos para poderlos modificar.

99
00:06:14,370 --> 00:06:16,060
Bien, esto es lo que vamos a ver a continuación.

100
00:06:16,420 --> 00:06:20,260
Hasta el momento se está ejecutando la línea tres donde se inicializa nuestro apuntador.

101
00:06:20,470 --> 00:06:22,900
Bien, posteriormente se ejecutará la línea cinco.

102
00:06:23,170 --> 00:06:29,110
Entonces utilizando nuestra variable de apuntador, pero con la sintaxis del arreglo, entonces accedemos

103
00:06:29,170 --> 00:06:30,880
en primer lugar a la dirección de memoria.

104
00:06:31,060 --> 00:06:36,700
Posteriormente accedemos al elemento cero y finalmente modificamos el valor, el contenido de la celda

105
00:06:36,910 --> 00:06:38,110
de este índice cero.

106
00:06:38,410 --> 00:06:44,020
Así que por ello este valor de cuatro se almacena en el índice cero de nuestro arreglo tal como estamos

107
00:06:44,020 --> 00:06:46,000
indicando y ya los demás elementos.

108
00:06:46,000 --> 00:06:47,680
Es exactamente el uso de los arreglos.

109
00:06:48,010 --> 00:06:49,420
Accedemos al índice uno.

110
00:06:49,570 --> 00:06:50,020
Por lo tanto.

111
00:06:50,020 --> 00:06:55,510
Se modifica ahora por el valor de cinco y posteriormente si se llega a ejecutar la línea siete, entonces

112
00:06:55,840 --> 00:06:59,800
podemos observar el índice dos y se modifica ahora por el valor de seis.

113
00:07:00,100 --> 00:07:04,660
Y entonces observamos con esto que la variable de apuntador ya modificó exactamente el mismo arreglo,

114
00:07:04,840 --> 00:07:09,340
los mismos elementos en memoria de la variable más externa, del arreglo más externo.

115
00:07:09,700 --> 00:07:14,200
Y entonces, una vez que termina la ejecución de nuestra función, se va a eliminar de memoria, incluyendo

116
00:07:14,200 --> 00:07:16,810
la variable de apuntador, la variable de parámetro.

117
00:07:17,110 --> 00:07:21,280
Así que si terminamos de ejecutar la función, entonces se quita de memoria.

118
00:07:21,550 --> 00:07:23,740
Regresamos el control a la línea 14.

119
00:07:23,740 --> 00:07:26,190
No hay nada más que procesar ya que esta función regresa.

120
00:07:26,200 --> 00:07:27,580
Un tipo void no regresa nada.

121
00:07:27,910 --> 00:07:32,230
Y por último se ejecuta la línea 15 y al momento de ejecutarse la línea 15.

122
00:07:32,500 --> 00:07:37,000
Entonces podemos comprobar que ahora los elementos que se están mandando a imprimir son precisamente

123
00:07:37,000 --> 00:07:40,060
los últimos elementos, los últimos cambios en el inicio cero.

124
00:07:40,060 --> 00:07:46,180
Tenemos ahora el valor de cuatro en el índice uno, el valor de cinco y finalmente en el índice dos

125
00:07:46,180 --> 00:07:47,080
el valor de seis.

126
00:07:47,980 --> 00:07:52,750
Así que prácticamente aquí estamos aplicando el concepto también de paso por referencia, ya que los

127
00:07:52,750 --> 00:07:56,430
arreglos almacenan por default la referencia de su primer elemento.

128
00:07:56,440 --> 00:08:01,120
Por lo tanto, al momento de mandar a llamar nuestra función, este apuntador está recibiendo la referencia

129
00:08:01,120 --> 00:08:06,040
del primer elemento, como ya hemos analizado bien, y con eso entonces estamos poniendo en práctica

130
00:08:06,040 --> 00:08:09,460
el uso de paso por referencia, combinándolo con el manejo de arreglos.

131
00:08:09,670 --> 00:08:13,960
Bien, pongan en práctica lo que hemos visto, y si aún lo necesitan, pueden ejecutar paso a paso.

132
00:08:14,170 --> 00:08:16,510
Eso es todo por este vídeo y nos vemos en la siguiente lección.

133
00:08:16,660 --> 00:08:17,200
Saludos.
