1
00:00:00,850 --> 00:00:01,720
Hola y bienvenidos.

2
00:00:01,780 --> 00:00:05,410
Vamos a ver a continuación un ejemplo de paso por referencia en el lenguaje C.

3
00:00:05,650 --> 00:00:06,400
Están listos?

4
00:00:06,580 --> 00:00:07,030
Vamos.

5
00:00:08,320 --> 00:00:08,500
Bien.

6
00:00:08,500 --> 00:00:11,500
Vamos a limpiar completamente nuestro código para empezar desde cero.

7
00:00:12,160 --> 00:00:18,220
Así que solamente vamos a dejar nuestro método Main y este va a ser el ejemplo de paso por referencia.

8
00:00:19,330 --> 00:00:21,040
Para ello, vamos a definir una función.

9
00:00:21,070 --> 00:00:25,390
La función no va a regresar ningún tipo de información, se va a llamar cambiar valor.

10
00:00:26,140 --> 00:00:31,420
Y el objetivo de esta función es que podamos comprobar si utilizando el concepto de paso por referencia,

11
00:00:31,630 --> 00:00:35,740
podemos modificar desde esta función el valor de la variable más externa.

12
00:00:36,040 --> 00:00:41,410
Así que para ello, el parámetro que vamos a definir ya no va a ser una variable de tipo entero, solamente

13
00:00:41,410 --> 00:00:46,360
una variable simple, sino que vamos a aplicar el concepto de apuntadores precisamente para que podamos

14
00:00:46,360 --> 00:00:50,080
recibir una referencia de memoria y no directamente un valor.

15
00:00:50,380 --> 00:00:52,240
Así que para ello definimos nuestro apuntador.

16
00:00:52,390 --> 00:00:57,220
Recordemos que en primer lugar especificamos el tipo de dato de la variable a la cual queremos apuntar.

17
00:00:57,460 --> 00:01:01,270
Así que ese tipo de dato de la variable que vamos a apuntar va a ser una variable de tipo entero.

18
00:01:01,540 --> 00:01:06,670
Posteriormente, utilizando la sintaxis de apuntadores, definimos nuestra variable de parámetro.

19
00:01:07,030 --> 00:01:12,190
Así que con esta sintaxis, esta variable es un apuntador y utilizando el concepto de referencia.

20
00:01:14,430 --> 00:01:18,330
Podemos modificar el valor de la variable.

21
00:01:19,260 --> 00:01:21,570
La variable que estamos recibiendo de manera más externa.

22
00:01:22,440 --> 00:01:27,690
Entonces utilizamos asterisco y posteriormente la variable de apuntador.

23
00:01:27,960 --> 00:01:30,130
Y vamos a tratar de modificar el valor.

24
00:01:30,180 --> 00:01:32,730
En este caso le asignamos un nuevo valor el valor de twenty.

25
00:01:33,240 --> 00:01:37,440
Y debido a que estamos aplicando el concepto de apuntadores, entonces esto debe de ser posible.

26
00:01:37,620 --> 00:01:40,890
Vamos a poder modificar de esta manera la variable más externa.

27
00:01:41,220 --> 00:01:45,240
Ahora, desde la función principal vamos a definir nuestra variable de argumento.

28
00:01:45,780 --> 00:01:50,310
Le asignamos, por ejemplo, el valor inicial de diez y ahora vamos a mandar a imprimir.

29
00:01:51,620 --> 00:01:53,510
Antes de llamar la función.

30
00:01:54,680 --> 00:01:56,540
Imprimimos el valor de nuestra variable.

31
00:01:56,870 --> 00:02:01,160
La variable de argumento con el valor inicial de diez es un valor de tipo entero.

32
00:02:02,830 --> 00:02:04,720
Almacenado en la variable de argumento.

33
00:02:05,380 --> 00:02:06,910
Posteriormente vamos a mandar a llamar.

34
00:02:06,910 --> 00:02:12,010
Nuestra función cambia el valor para comprobar si de manera interna nuestra función puede realizar un

35
00:02:12,010 --> 00:02:14,200
cambio sobre la variable más externa.

36
00:02:14,350 --> 00:02:19,450
Pero recordemos que de momento no vamos a pasar directamente el valor de la variable, ya que con esta

37
00:02:19,450 --> 00:02:23,120
sintaxis estaríamos pasando una copia del valor de esta variable.

38
00:02:23,140 --> 00:02:28,150
Pero debido a que estamos aplicando el concepto de apuntadores, entonces necesitamos pasar la dirección

39
00:02:28,150 --> 00:02:31,090
de memoria y no directamente el valor de esta variable.

40
00:02:31,390 --> 00:02:36,490
Por ello, ya sabemos que tenemos que anteponer el símbolo de ampersand para que con esta sintaxis pasemos

41
00:02:36,490 --> 00:02:42,040
entonces la dirección de memoria a nuestra variable de apuntador y con esto se inicializa correctamente

42
00:02:42,040 --> 00:02:44,050
nuestra variable de apuntador de parámetro.

43
00:02:44,410 --> 00:02:51,100
Y por último, una vez que termina de ejecutarse esa función, vamos a comprobar el valor después de

44
00:02:51,100 --> 00:02:52,390
llamar la función.

45
00:02:55,400 --> 00:02:55,570
Bien.

46
00:02:55,610 --> 00:02:59,930
Así que volvemos a imprimir nuestra variable del argumento simplemente para comprobar si se realizó

47
00:02:59,930 --> 00:03:03,260
un cambio o no, pero antes de ejecutar, agregamos un salto de línea.

48
00:03:03,920 --> 00:03:09,200
Y ahora vamos a ejecutar y podemos llevar entonces que antes de llamar la función, tenemos el valor

49
00:03:09,200 --> 00:03:10,910
de then en nuestra variable de argumento.

50
00:03:11,030 --> 00:03:15,980
Pero una vez que se manda a llamar nuestra función de manera interna utilizando el concepto de apuntadores,

51
00:03:16,160 --> 00:03:21,520
entonces estamos modificando el valor de la variable más externa, ya que estamos apuntando exactamente

52
00:03:21,540 --> 00:03:22,760
la misma dirección de memoria.

53
00:03:22,910 --> 00:03:27,740
Por lo tanto, cualquier cambio realizado de manera interna, entonces también va a afectar a la variable

54
00:03:27,740 --> 00:03:28,400
más externa.

55
00:03:28,580 --> 00:03:33,680
Por lo tanto, en la línea 13, cuando volvemos a imprimir el valor de la variable de argumento, ahora

56
00:03:33,710 --> 00:03:34,940
vemos el valor de 20.

57
00:03:35,240 --> 00:03:37,970
Aunque esta variable de parámetro en este momento ya se destruyó.

58
00:03:38,150 --> 00:03:40,100
Podemos comprobar que el apuntador.

59
00:03:40,100 --> 00:03:45,860
Si puedo realizar un cambio sobre la misma dirección de memoria de la variable de argumento y vamos

60
00:03:45,860 --> 00:03:46,760
a ver nuestra animación.

61
00:03:46,760 --> 00:03:52,070
Si ejecutamos paso a paso este ejercicio, entonces tendríamos lo siguiente En primer lugar, al ejecutar

62
00:03:52,070 --> 00:03:57,290
nuestra función principal en la línea diez, se crea nuestra variable de argumento con el valor inicial

63
00:03:57,290 --> 00:04:02,210
de diez en cierta dirección de memoria, y esta variable se creó en cierta dirección de memoria.

64
00:04:02,710 --> 00:04:08,830
Bien, posteriormente en la línea 11 se manda a imprimir antes de mandar a llamar la función y se imprimiría

65
00:04:08,840 --> 00:04:10,220
el valor inicial de diez.

66
00:04:10,400 --> 00:04:15,080
Ya que hasta este momento el valor de la variable de argumento tiene precisamente el valor de diez.

67
00:04:15,740 --> 00:04:21,260
Posteriormente, en la línea 12 se manda a llamar nuestra función de cambiar valor, así que en memoria

68
00:04:21,260 --> 00:04:26,600
se agrega a nuestra pila la llamada de la función cambia el valor y también se crean nuestras variables

69
00:04:26,600 --> 00:04:27,830
que son los parámetros.

70
00:04:27,830 --> 00:04:33,170
Pero recordemos que esta variable de parámetro a su vez es un apuntador hacia una variable de tipo entero,

71
00:04:33,440 --> 00:04:38,420
ya que la variable más externa, en este caso la variable de argumento es una variable de tipo entero.

72
00:04:38,600 --> 00:04:43,340
Por lo tanto, el tipo de dato del apuntador debe coincidir, ya que vamos a apuntar a una variable

73
00:04:43,340 --> 00:04:49,400
precisamente de tipo entero y como siguiente paso se inicializa la variable de parámetro.

74
00:04:49,700 --> 00:04:56,000
Entonces podemos observar en animación que el valor almacenado en nuestra variable de apuntador es el

75
00:04:56,000 --> 00:04:59,180
valor de la dirección de memoria de la variable de argumento.

76
00:04:59,540 --> 00:05:05,150
Por lo tanto, esta variable de parámetro apunta a la dirección de memoria de la variable de argumento.

77
00:05:05,750 --> 00:05:07,370
Esto sucede en la línea cuatro.

78
00:05:07,640 --> 00:05:13,460
Y ahora, si continuamos en la línea seis, entonces a partir de la variable de parámetro que está apuntando

79
00:05:13,460 --> 00:05:18,170
a la misma dirección de memoria de la variable de argumento, vamos a realizar un cambio en lugar de

80
00:05:18,170 --> 00:05:18,450
diez.

81
00:05:18,470 --> 00:05:20,150
Ahora vamos a ver el valor de 20.

82
00:05:20,630 --> 00:05:25,940
Así que podemos observar que aplicando el concepto de referencia, en primer lugar, vemos el valor

83
00:05:25,940 --> 00:05:27,080
de la variable de parámetro.

84
00:05:27,320 --> 00:05:33,140
Vamos a esa dirección de memoria y debido a que estamos aplicando el asterisco, entonces ahora sí modificamos

85
00:05:33,170 --> 00:05:35,840
el valor almacenado en esta dirección de memoria.

86
00:05:36,200 --> 00:05:40,310
Por lo tanto, se pierde el valor de then y se sobrescribe ahora por el valor de 20.

87
00:05:40,880 --> 00:05:45,440
Ahora, como siguiente paso, se va a terminar de ejecutar la función cambia el valor, así que en memoria

88
00:05:45,440 --> 00:05:50,420
se destruye la llamada de esta función y también se destruye la variable de apuntador.

89
00:05:50,720 --> 00:05:56,840
Pero debido a que ya realizamos un cambio sobre la dirección de memoria con esa terminación, entonces

90
00:05:56,840 --> 00:06:01,850
esta variable de argumento sigue accediendo a esta dirección de memoria y por lo tanto se va a mandar

91
00:06:01,850 --> 00:06:03,440
a imprimir ahora el valor de Twenty.

92
00:06:03,800 --> 00:06:05,390
Así que regresamos a la línea 12.

93
00:06:05,660 --> 00:06:10,070
Ya no hay nada más que procesar aquí, ya que la función es de tipo void y entonces continuamos con

94
00:06:10,070 --> 00:06:10,820
la línea 13.

95
00:06:11,150 --> 00:06:16,310
Así que en este momento se manda a imprimir el valor de la variable de argumento y podemos observar

96
00:06:16,310 --> 00:06:20,420
que el último valor que tiene esta variable es precisamente el valor de 20.

97
00:06:20,690 --> 00:06:25,490
Ya la variable de apuntador dentro de la función hizo la tarea respectiva de modificar este valor y

98
00:06:25,490 --> 00:06:28,790
entonces por ello ese cuando volvemos a mandar imprimir el valor de esta variable.

99
00:06:29,000 --> 00:06:32,330
El último valor que tiene la variable de argumento es el valor de twenty.

100
00:06:32,630 --> 00:06:37,910
Y con esto estamos poniendo en práctica el concepto de paso por referencia, ya que realmente aquí cuando

101
00:06:37,910 --> 00:06:43,010
mandamos a llamar nuestra función de cambiar valor, estamos pasando la referencia de la variable y

102
00:06:43,010 --> 00:06:47,840
de manera interna si podemos realizar cambios a esta variable, siempre y cuando estemos aplicando en

103
00:06:47,840 --> 00:06:49,790
este caso el uso de apuntadores.

104
00:06:50,420 --> 00:06:53,180
Bien, ese es el concepto de paso por referencia, póngala en práctica.

105
00:06:53,360 --> 00:06:56,480
Y también si todavía tuvieran alguna duda, lo pueden ejecutar paso a paso.

106
00:06:56,750 --> 00:06:59,540
Eso es todo por este video y continuamos en la siguiente lección.

107
00:06:59,750 --> 00:07:00,290
Saludos.
