1
00:00:00,820 --> 00:00:01,670
Hola y bienvenidos.

2
00:00:01,730 --> 00:00:04,930
Vamos a ver a continuación el tema de paso por valor en el lenguaje.

3
00:00:05,320 --> 00:00:06,130
Están listos?

4
00:00:06,220 --> 00:00:06,640
Vamos.

5
00:00:07,620 --> 00:00:11,880
Bien, ya hemos visto cómo se copian los valores cuando trabajamos con variables en el lenguaje.

6
00:00:11,890 --> 00:00:17,130
C Sin embargo, vamos a ver ahora cómo aplicar este mismo concepto, pero cuando trabajamos con funciones.

7
00:00:17,370 --> 00:00:22,740
Así que el concepto de paso por valor es básicamente el mismo concepto que ya hemos estudiado de copia

8
00:00:22,740 --> 00:00:25,560
de valor, pero como hemos comentado, aplicado a funciones.

9
00:00:25,920 --> 00:00:28,080
Así que vamos a definir en primer lugar una función.

10
00:00:28,260 --> 00:00:32,670
Esta función es de tipo void, no regresa nada y se va a llamar Paso por valor.

11
00:00:32,910 --> 00:00:35,070
Vamos a definir un parámetro de tipo entero.

12
00:00:35,310 --> 00:00:37,890
Esto es lo que va a recibir esta función, un valor de tipo entero.

13
00:00:38,340 --> 00:00:42,240
Y entonces, de manera interna realizamos una modificación sobre esta variable.

14
00:00:42,420 --> 00:00:47,780
Y esto lo vamos a hacer así para comprobar si hacemos cambios sobre la variable definida en la función.

15
00:00:47,790 --> 00:00:52,890
Vamos a ver si afecta el argumento que se envió a esta variable, es decir, la variable más externa.

16
00:00:53,270 --> 00:00:57,330
Bien, por lo tanto, esta función solamente lo que hace es recibir una copia de un valor.

17
00:00:57,540 --> 00:01:02,400
Trata de modificarlo y vamos a comprobar si modifica el valor más externo, el valor de la variable

18
00:01:02,400 --> 00:01:03,330
más externa o no.

19
00:01:03,630 --> 00:01:06,000
Por otro lado, tenemos nuestra función principal.

20
00:01:06,210 --> 00:01:08,580
Vamos a definir una variable llamada argumento.

21
00:01:08,820 --> 00:01:14,010
Le asignamos un primer valor, el valor de diez, y posteriormente mandamos a llamar la función de paso

22
00:01:14,010 --> 00:01:19,410
por valor le pasamos como información precisamente esta variable de argumento y entonces esto lo vamos

23
00:01:19,410 --> 00:01:24,450
a realizar para comprobar si se modifica el valor a través de la función o no, Y por último mandamos

24
00:01:24,450 --> 00:01:29,820
a imprimir el valor de la variable de argumento precisamente para saber si se modificó su valor a través

25
00:01:29,820 --> 00:01:31,950
de la función o no se realizó este cambio.

26
00:01:32,280 --> 00:01:37,440
Bien, entonces si ejecutamos lo que va a suceder en memoria es lo siguiente empezamos a ejecutar la

27
00:01:37,440 --> 00:01:43,260
función principal, se crea nuestra variable de argumento y se inicializa con el valor de diez en cierta

28
00:01:43,260 --> 00:01:44,220
dirección de memoria.

29
00:01:44,370 --> 00:01:44,760
Por ejemplo.

30
00:01:44,760 --> 00:01:47,670
En este caso en la dirección de memoria 0X333.

31
00:01:48,030 --> 00:01:52,590
Posteriormente como siguiente paso mandamos a llamar la función de paso por valor.

32
00:01:52,860 --> 00:01:56,010
Esto quiere decir que se pone en pausa la función principal.

33
00:01:56,250 --> 00:02:02,580
Pasamos el control, ahora la función de paso por valor y entonces la variable de parámetro se crea

34
00:02:02,580 --> 00:02:03,270
en memoria.

35
00:02:03,450 --> 00:02:07,050
Recordemos que es una variable local al método de paso por valor.

36
00:02:07,050 --> 00:02:09,450
Por lo tanto son variables distintas en memoria.

37
00:02:09,720 --> 00:02:12,840
Y aquí es donde aplica precisamente el concepto de paso por valor.

38
00:02:12,840 --> 00:02:17,640
Ya sabemos cómo realizar copia de valores, entonces aquí prácticamente es exactamente el mismo concepto

39
00:02:17,760 --> 00:02:19,140
pero aplicado a funciones.

40
00:02:19,260 --> 00:02:24,750
Así que en este caso el argumento va a realizar una copia de su valor hacia la variable de parámetro.

41
00:02:25,080 --> 00:02:29,940
Ambas variables son distintas en memoria y entonces solamente se realiza una copia de la variable de

42
00:02:29,940 --> 00:02:35,160
argumento a la variable de parámetro, pero la variable de parámetro se encuentra en diferente posición

43
00:02:35,160 --> 00:02:35,700
de memoria.

44
00:02:35,910 --> 00:02:40,980
Por lo tanto, la variable de parámetro se inicializa con una copia del valor de la variable de argumento

45
00:02:41,220 --> 00:02:47,190
y así la variable de parámetro se encuentra, por ejemplo en la dirección de memoria 0X4 y su valor

46
00:02:47,190 --> 00:02:52,560
inicial es el valor de diez, así que la barrera de parámetro solamente recibe una copia de la variable

47
00:02:52,560 --> 00:02:53,250
de argumento.

48
00:02:53,520 --> 00:02:58,650
Y si continuamos la ejecución de nuestra función de paso por valor, se va a modificar el valor de la

49
00:02:58,650 --> 00:02:59,580
variable de parámetro.

50
00:02:59,580 --> 00:03:00,420
Así que en memoria.

51
00:03:00,630 --> 00:03:04,170
Ahora en lugar de tener el valor de diez, se modifica por el valor de twenty.

52
00:03:04,320 --> 00:03:09,000
Pero podemos observar que como son diferentes variables en memoria, el cambio realizado por la variable

53
00:03:09,000 --> 00:03:14,610
de parámetro no afecta en nada a la variable de argumento, ya que son dos variables distintas y entonces

54
00:03:14,610 --> 00:03:19,920
la modificación en la variable de parámetro no afecta para nada la variable más externa, la variable

55
00:03:19,920 --> 00:03:20,730
de argumento.

56
00:03:20,730 --> 00:03:25,170
Así que por ello a este concepto se le conoce como paso por valor, ya que solamente estamos pasando

57
00:03:25,170 --> 00:03:30,930
una copia del valor y las modificaciones de manera interna dentro de la función no afectan a la variable

58
00:03:30,930 --> 00:03:31,710
más externa.

59
00:03:31,920 --> 00:03:37,260
Bien, pues obviamente termina de ejecutarse la función de paso por valor, regresa el control a la

60
00:03:37,260 --> 00:03:42,780
función principal y entonces por último vamos a mandar a imprimir la variable de argumento simplemente

61
00:03:42,780 --> 00:03:47,940
para comprobar que se imprime el valor de diez, ya que la variable de parámetro se destruye una vez

62
00:03:47,940 --> 00:03:51,060
que termina de ejecutarse la función de paso por valor y entonces.

63
00:03:51,060 --> 00:03:56,940
En conclusión, los cambios realizados en la función no afectan a la variable externa, es decir, a

64
00:03:56,940 --> 00:04:02,640
la variable de argumento solo se recibe una copia y por lo tanto en memoria son variables distintas,

65
00:04:02,640 --> 00:04:03,900
como lo podemos comprobar.

66
00:04:04,320 --> 00:04:08,190
Bien, vamos a detener hasta aquí y en el siguiente vídeo vamos a realizar este ejemplo para que todo

67
00:04:08,190 --> 00:04:10,730
quede completamente claro, así que continuamos.

68
00:04:10,770 --> 00:04:11,370
Saludos.
