1
00:00:01,210 --> 00:00:02,050
Hola y bienvenidos.

2
00:00:02,200 --> 00:00:05,640
Vamos a ver a continuación cómo se copian los arreglos en el lenguaje C.

3
00:00:05,890 --> 00:00:06,700
Están listos?

4
00:00:06,850 --> 00:00:07,300
Vamos.

5
00:00:08,370 --> 00:00:13,800
Bien, ya hemos visto los tipos primitivos como los tipos y los tipos float, etcétera y como trabajan

6
00:00:13,800 --> 00:00:15,490
al momento de copiar sus valores.

7
00:00:15,510 --> 00:00:20,430
Pero también ya sabemos que podemos copiar su dirección de memoria aplicando el concepto de apuntadores.

8
00:00:20,790 --> 00:00:26,040
Ahora vamos a ver esto de manera similar, pero cuando trabajamos con arreglos y vamos a ver que existen

9
00:00:26,040 --> 00:00:31,260
algunas diferencias importantes, ya que los arreglos por default almacenan la dirección de memoria

10
00:00:31,440 --> 00:00:33,780
del primer elemento al cual están apuntando.

11
00:00:33,960 --> 00:00:37,440
Así que de alguna manera los arreglos también son un tipo de apuntador.

12
00:00:37,470 --> 00:00:42,320
Así que vamos a ver las diferencias entre los tipos primitivos, como los tipos int, float, etcétera

13
00:00:42,330 --> 00:00:43,680
y el uso de arreglos.

14
00:00:44,150 --> 00:00:47,640
Bien Por ello, en primer lugar, vamos a definir una variable de tipo arreglo.

15
00:00:47,880 --> 00:00:53,070
Recordemos que la diferencia es que vamos a utilizar corchetes al momento de definir una variable de

16
00:00:53,070 --> 00:00:53,730
tipo arreglo.

17
00:00:54,030 --> 00:00:59,520
Posteriormente, utilizando la sintaxis simplificada para declarar un arreglo entre llaves, agregamos

18
00:00:59,520 --> 00:01:05,800
los valores de 100 y 200 serían los elementos almacenados en los índices cero, el valor de 100 y en

19
00:01:05,840 --> 00:01:08,130
el índice uno el valor de 200.

20
00:01:08,520 --> 00:01:12,710
Ahora vamos a copiar la referencia de esta variable del arreglo uno.

21
00:01:13,080 --> 00:01:15,390
Lo vamos a copiar hacia otro arreglo.

22
00:01:15,660 --> 00:01:19,410
Así que definimos una variable, pero que va a ser un apuntador.

23
00:01:19,590 --> 00:01:24,690
En este caso no es tal cual un arreglo, pero la sintaxis va a ser muy similar al manejo de arreglos.

24
00:01:24,720 --> 00:01:26,730
Vamos a ver a continuación esta sintaxis.

25
00:01:26,910 --> 00:01:30,630
Así que podemos saber que en primer lugar, eso sería definir un apuntador.

26
00:01:30,810 --> 00:01:36,390
Es el tipo de dato de la variable a la cual queremos apuntar posteriormente un asterisco y finalmente

27
00:01:36,390 --> 00:01:37,440
el nombre de la variable.

28
00:01:37,620 --> 00:01:41,370
Pero también vamos a ver que esto nos va a permitir apuntar hacia un arreglo.

29
00:01:41,670 --> 00:01:47,550
Y a diferencia de los tipos primitivos, en este caso, cuando le queremos pasar la referencia de memoria

30
00:01:47,550 --> 00:01:53,130
de una variable de tipo arreglo, no hay necesidad de utilizar ampersand, así que le pasamos directamente

31
00:01:53,130 --> 00:01:55,110
el nombre de la variable de arreglo.

32
00:01:55,260 --> 00:02:00,000
Por ello, hemos comentado que una variable de tipo arreglo se parece a un apuntador, ya que en este

33
00:02:00,000 --> 00:02:05,340
caso el arreglo almacena directamente una dirección de memoria, de manera muy similar al manejo de

34
00:02:05,340 --> 00:02:06,030
apuntadores.

35
00:02:06,240 --> 00:02:11,160
Por ello es que no tenemos que utilizar ampersand para asignar la dirección de memoria que almacena

36
00:02:11,160 --> 00:02:16,110
la variable de arreglo y se asigna directamente a esta dirección de memoria a la variable de arreglo.

37
00:02:16,110 --> 00:02:16,410
Dos.

38
00:02:16,840 --> 00:02:22,080
Bien, entonces los tipos de datos hemos comentado que deben ser del mismo tipo tanto la variable de

39
00:02:22,080 --> 00:02:22,610
arreglo dos.

40
00:02:22,620 --> 00:02:26,130
Que es el apuntador y el tipo de dato de la variable de arreglo.

41
00:02:26,700 --> 00:02:31,290
Así que con esto lo que estamos consiguiendo es que tanto la variable de apuntador arreglo dos y la

42
00:02:31,290 --> 00:02:35,670
variable arreglo uno apuntan exactamente a la misma dirección de memoria.

43
00:02:36,060 --> 00:02:41,490
Esto quiere decir que si modificamos alguno de los índices de nuestro arreglo, podemos observar que

44
00:02:41,490 --> 00:02:48,150
la sintaxis es exactamente igual, ya sea con la variable de tipo apuntador o con la variable de tipo

45
00:02:48,150 --> 00:02:48,600
arreglo.

46
00:02:48,900 --> 00:02:54,900
Así que la variable de tipo apuntador simplemente vamos a especificar el índice del elemento que queremos

47
00:02:54,900 --> 00:02:55,670
modificar.

48
00:02:55,680 --> 00:02:59,400
En este caso estamos modificando el valor del índice cero en lugar de 100.

49
00:02:59,400 --> 00:03:01,830
Lo estamos escribiendo por el valor de 500.

50
00:03:02,010 --> 00:03:08,040
Así que un cambio utilizando la variable de arreglo dos modifica también la variable de arreglo uno.

51
00:03:08,040 --> 00:03:11,400
Ya que ambas apuntan exactamente a la misma dirección de memoria.

52
00:03:11,670 --> 00:03:17,490
Y para movernos entre los elementos, entonces ya sabemos que si es un arreglo podemos simplemente especificar

53
00:03:17,490 --> 00:03:22,140
el índice, así que por ello podemos acceder, por ejemplo, en este caso al índice cero.

54
00:03:22,410 --> 00:03:27,870
Utilizando tanto el arreglo, uno iba a mandar a imprimir ahora el nuevo valor, el valor de 500.

55
00:03:28,020 --> 00:03:32,400
Pero también podemos acceder a este mismo valor utilizando la variable de arreglo dos.

56
00:03:32,550 --> 00:03:38,190
Aunque es una variable de tipo apuntador, la sintaxis es exactamente la misma, y si accedemos al mismo

57
00:03:38,190 --> 00:03:44,760
índice, entonces también van a imprimir el valor de 500, ya que en ambos casos las dos variables apuntan

58
00:03:44,760 --> 00:03:50,550
exactamente a la misma dirección de memoria y es el concepto básico del manejo de arreglos.

59
00:03:50,580 --> 00:03:55,020
Y aplicando ahora también el concepto de dirección de memoria combinándolo con apuntadores.

60
00:03:55,170 --> 00:03:59,880
Vamos a ver, por último, cómo trabajar con arreglos y funciones, aplicando precisamente lo que hemos

61
00:03:59,880 --> 00:04:03,030
visto anteriormente, el concepto de paso por referencia.

62
00:04:03,930 --> 00:04:07,650
Así que vamos a ver el tema de paso por referencia con arreglos para ello.

63
00:04:07,650 --> 00:04:10,980
En primer lugar, vamos a definir nuestra función paso por referencia.

64
00:04:11,220 --> 00:04:16,710
El parámetro va a ser una variable de tipo apuntador, así que de manera muy similar a lo que ya revisamos,

65
00:04:16,860 --> 00:04:22,320
esta variable va a poder apuntar a un arreglo sin ningún problema, ya que simplemente va a recibir

66
00:04:22,320 --> 00:04:24,840
una dirección de memoria y de manera interna.

67
00:04:25,080 --> 00:04:31,170
Esta función lo que va a intentar realizar es acceder a los índices de nuestro arreglo para modificar

68
00:04:31,170 --> 00:04:31,950
sus valores.

69
00:04:32,130 --> 00:04:34,710
Así que en este caso vamos a modificar tanto el índice cero.

70
00:04:34,980 --> 00:04:40,380
Ahora le vamos a actualizar su valor por el valor de 500 y también al índice uno de ese arreglo le vamos

71
00:04:40,380 --> 00:04:43,080
a modificar su valor ahora por el valor de 600.

72
00:04:43,320 --> 00:04:48,810
Así que esta función va a intentar realizar estos cambios sobre el arreglo que vamos a pasar como referencia.

73
00:04:49,320 --> 00:04:53,220
Bien, y posteriormente en la función principal vamos a definir un arreglo.

74
00:04:53,460 --> 00:04:59,280
En este caso la variable se llama argumento, pero es un arreglo con los valores de 100 y 200 respectivamente

75
00:04:59,490 --> 00:05:01,590
en el inicio cero y en el índice uno.

76
00:05:01,950 --> 00:05:07,670
Posteriormente mandamos a llamar nuestra función de paso referencia y le pasamos el argumento en este

77
00:05:07,670 --> 00:05:07,770
caso.

78
00:05:08,090 --> 00:05:12,920
Debido a que es un arreglo, no requiere utilizar el ampersand, Así que esa es una de las diferencias

79
00:05:12,920 --> 00:05:15,010
importantes cuando trabajamos con arreglos.

80
00:05:15,080 --> 00:05:18,790
Los arreglos por default lo que almacenan es una dirección de memoria.

81
00:05:18,800 --> 00:05:20,960
Por ello es que no se requiere utilizar el ampersand.

82
00:05:21,200 --> 00:05:26,180
A diferencia de los tipos primitivos, donde ya sabemos que si tenemos que utilizar ampersand para pasar

83
00:05:26,180 --> 00:05:28,670
correctamente una dirección de memoria, bien.

84
00:05:28,820 --> 00:05:30,740
Así que una vez que pasamos la referencia.

85
00:05:31,010 --> 00:05:31,460
Entonces.

86
00:05:31,460 --> 00:05:32,150
Por último.

87
00:05:32,150 --> 00:05:38,210
Vamos a intentar acceder a los elementos al índice cero para comprobar que la función sí pudo realizar

88
00:05:38,210 --> 00:05:38,870
los cambios.

89
00:05:39,020 --> 00:05:44,090
Por ello, en este caso, a través de la variable de arreglo más externa, accedemos al índice cero

90
00:05:44,090 --> 00:05:46,220
y obtenemos el nuevo valor de 500.

91
00:05:46,520 --> 00:05:51,050
Y si queremos acceder al C1, también accedemos al nuevo valor de 600.

92
00:05:51,440 --> 00:05:56,540
Si llegáramos a ejecutar nuestra función en memoria, sucede lo siguiente Tenemos nuestra variable de

93
00:05:56,540 --> 00:05:58,130
argumento que se crea en memoria.

94
00:05:58,340 --> 00:06:02,480
Pero recordemos que en este caso son dos índices los que estamos utilizando.

95
00:06:02,750 --> 00:06:07,820
Por ello es que la variable de argumento apunta a la dirección de memoria del primer elemento de nuestro

96
00:06:07,820 --> 00:06:08,240
arreglo.

97
00:06:08,420 --> 00:06:13,400
No es que almacene todas las direcciones de memoria, sino que solamente almacena una dirección de memoria

98
00:06:13,400 --> 00:06:19,520
del primer elemento de nuestro arreglo, y entonces se almacenan los valores de 100 y 200 según la inicialización

99
00:06:19,520 --> 00:06:20,360
de nuestro arreglo.

100
00:06:20,690 --> 00:06:25,910
Posteriormente mandamos a llamar nuestra función de paso por referencia y se va a inicializar nuestra

101
00:06:25,910 --> 00:06:27,440
variable de apuntador.

102
00:06:27,680 --> 00:06:33,200
Así que la variable de apuntador ahora apunta a la dirección de memoria de la variable de argumento.

103
00:06:33,320 --> 00:06:38,330
Pero recordemos que esta variable de argumento lo que almacena es la dirección de memoria del primer

104
00:06:38,330 --> 00:06:39,680
elemento de nuestro arreglo.

105
00:06:39,860 --> 00:06:45,980
Por ello, la variable de parámetro almacena la dirección de memoria 0X333 y para poder acceder a sus

106
00:06:45,980 --> 00:06:48,860
elementos, entonces tenemos que utilizar los índices.

107
00:06:49,010 --> 00:06:54,530
Por ello, cuando se empieza a ejecutar nuestra función para poder acceder al primer índice, accedemos

108
00:06:54,530 --> 00:06:56,210
al primer índice, al índice de cero.

109
00:06:56,420 --> 00:07:02,150
Y entonces, con la sintaxis que estamos utilizando, modificamos el valor de 100 al valor de 500.

110
00:07:02,420 --> 00:07:08,240
En este caso podemos observar que no hay necesidad de utilizar el asterisco, ya que aunque es un apuntador,

111
00:07:08,240 --> 00:07:10,900
estamos utilizando la sintaxis de arreglos.

112
00:07:10,910 --> 00:07:15,950
Por lo tanto aquí ya no tenemos que poner asterisco, sino simplemente especificar el índice al cual

113
00:07:15,950 --> 00:07:22,220
queremos acceder y como siguiente paso en la siguiente línea modificamos el índice uno y por lo tanto

114
00:07:22,220 --> 00:07:23,720
el valor en lugar de 200.

115
00:07:23,870 --> 00:07:26,060
Ahora ya tenemos el valor de 600.

116
00:07:26,360 --> 00:07:28,130
Se termina de ejecutar esta función.

117
00:07:28,310 --> 00:07:33,650
Regresamos el control a la función principal y ahora cuando mandamos a imprimir utilizando la variable

118
00:07:33,650 --> 00:07:38,900
de argumento, el arreglo de argumento se manda imprimir con el índice cero el valor de 500, ya que

119
00:07:38,900 --> 00:07:41,150
es el valor almacenado en esta dirección de memoria.

120
00:07:41,480 --> 00:07:47,420
Y si queremos mandar a imprimir el índice uno, entonces ahora se imprime el valor de 600, ya que tenemos

121
00:07:47,420 --> 00:07:51,710
los índices cero y el índice uno utilizando la sintaxis de arreglos.

122
00:07:52,010 --> 00:07:57,530
Y en conclusión, los arreglos se pasan por default por referencia, así que no se requiere utilizar

123
00:07:57,530 --> 00:08:00,860
ampersand para pasar la referencia de memoria de un arreglo.

124
00:08:01,220 --> 00:08:06,740
Y también cuando queremos acceder a los elementos de un arreglo, pero que estamos trabajando con apuntadores,

125
00:08:06,740 --> 00:08:08,630
no requerimos utilizar asterisco.

126
00:08:08,900 --> 00:08:13,820
Es decir, que no tenemos que aplicar el concepto de referencia, ya que por default las variables de

127
00:08:13,820 --> 00:08:16,730
tipo apuntador que a su vez apuntan a un arreglo.

128
00:08:16,940 --> 00:08:19,310
Entonces no requiere utilizar asterisco.

129
00:08:19,550 --> 00:08:24,530
Simplemente utilizamos la sintaxis de arreglos y con esto ya estamos accediendo a los elementos, a

130
00:08:24,530 --> 00:08:26,090
los índices de nuestro arreglo.

131
00:08:26,550 --> 00:08:30,530
Bien, vamos a detener hasta aquí y en el siguiente vídeo vamos a realizar este ejercicio para que todo

132
00:08:30,530 --> 00:08:31,790
quede completamente claro.

133
00:08:31,970 --> 00:08:33,110
Así que continuamos.

134
00:08:33,140 --> 00:08:33,770
Saludos.
