1
00:00:01,060 --> 00:00:01,920
Hola y bienvenidos.

2
00:00:01,960 --> 00:00:05,440
Vamos a ver a continuación el ejemplo de paso por valor en el lenguaje C.

3
00:00:05,590 --> 00:00:06,310
Están listos?

4
00:00:06,460 --> 00:00:06,910
Vamos.

5
00:00:08,230 --> 00:00:08,380
Bien.

6
00:00:08,380 --> 00:00:09,610
Vamos a limpiar nuestro código.

7
00:00:10,760 --> 00:00:14,930
Y vamos a realizar a continuación el ejercicio de paso por valor en el lenguaje C.

8
00:00:15,350 --> 00:00:19,940
Ahora, este concepto es importante precisamente porque cuando estamos pasando información entre funciones

9
00:00:20,120 --> 00:00:22,810
necesitamos saber cómo se pasa esta información.

10
00:00:22,820 --> 00:00:27,980
Y entonces cuando trabajamos con tipos primitivos, como puede ser el tipo entero flotante de tipo char

11
00:00:27,980 --> 00:00:33,020
bool, etc, entonces cuando trabajamos con estos tipos de datos, la información simplemente se pasa

12
00:00:33,020 --> 00:00:36,230
una copia del valor de la variable que estemos trabajando.

13
00:00:36,500 --> 00:00:41,290
En cambio, cuando trabajamos, por ejemplo con apuntadores o cuando trabajamos con tipos arreglo,

14
00:00:41,300 --> 00:00:45,200
vamos a ver que se pasa la referencia de memoria y no una copia del valor.

15
00:00:45,320 --> 00:00:49,970
Por ello es que estamos estudiando estos temas a profundidad, ya que es bastante importante entenderlos

16
00:00:49,970 --> 00:00:50,480
a detalle.

17
00:00:51,020 --> 00:00:54,710
Así que vamos a ver este ejemplo para trabajar con el concepto de paso por valor.

18
00:00:54,890 --> 00:00:57,050
Vamos a definir en primer lugar nuestra función.

19
00:00:57,470 --> 00:01:03,500
Se va a llamar Cambiar valor y ya sabemos que esta función tiene como objetivo comprobar si la información

20
00:01:03,500 --> 00:01:08,000
que estamos pasando a esta función modifica el valor de la variable más externa.

21
00:01:08,360 --> 00:01:11,690
Pero ya sabemos que solamente vamos a recibir una copia del valor.

22
00:01:11,840 --> 00:01:18,170
Entonces los cambios realizados en nuestra función de manera más interna no afectan a la variable más

23
00:01:18,170 --> 00:01:18,740
externa.

24
00:01:19,010 --> 00:01:20,390
Aún así, vamos a comprobarlo.

25
00:01:20,840 --> 00:01:25,370
Ya tenemos definida nuestra función no retorna, no regresa ningún tipo de información.

26
00:01:25,370 --> 00:01:29,720
Solamente intenta cambiar el valor que está recibiendo en la variable de parámetro.

27
00:01:30,200 --> 00:01:33,860
Ahora, en nuestra función principal definimos una variable llamada argumento.

28
00:01:35,460 --> 00:01:40,860
Y mandamos a imprimir el valor antes de mandar a llamar nuestra función, simplemente para comprobar

29
00:01:40,860 --> 00:01:44,400
cuál es el valor que tenemos antes de llamar a la función.

30
00:01:45,330 --> 00:01:50,490
Es un valor de tipo entero y mandamos a imprimir precisamente el valor de esta variable de argumento.

31
00:01:51,060 --> 00:01:55,050
Ahora, una vez que ya hemos mandado a imprimir este valor en primer lugar, ahora sí podemos mandar

32
00:01:55,050 --> 00:02:00,750
a llamar la función cambiar valor y le pasamos como información la variable de argumento.

33
00:02:01,080 --> 00:02:06,060
Así que esto lo que hace es pasar una copia del valor, debido a que la variable de argumento es un

34
00:02:06,060 --> 00:02:07,710
tipo primitivo, un tipo básico.

35
00:02:08,160 --> 00:02:12,600
Entonces se pasa simplemente una copia del valor hacia la variable de parámetro.

36
00:02:13,050 --> 00:02:19,440
Y por último, vamos a mandar a imprimir la variable de argumento, pero después de haber mandado a

37
00:02:19,440 --> 00:02:24,720
llamar la función para saber si de manera interna la función pudo realizar un cambio sobre esta variable

38
00:02:24,720 --> 00:02:29,220
o no, así que mandamos a imprimir después de llamar la función.

39
00:02:30,610 --> 00:02:34,540
Es un valor de tipo entero e imprimimos esta variable de argumento.

40
00:02:35,320 --> 00:02:37,270
Con eso ya tenemos prácticamente todo nuestro código.

41
00:02:37,270 --> 00:02:42,430
Vamos a ejecutarlo, pero antes de ejecutarlo, vamos a agregar un salto de línea para que quede esta

42
00:02:42,430 --> 00:02:47,770
impresión en líneas distintas y entonces podemos observar antes de llamar la función, se imprime el

43
00:02:47,770 --> 00:02:52,690
valor de diez y después de mandar a llamar nuestra función, no se realizó ninguna modificación desde

44
00:02:52,690 --> 00:02:53,380
la función.

45
00:02:53,500 --> 00:02:57,300
Tenemos exactamente el mismo valor el valor de diez, aunque de manera interna.

46
00:02:57,310 --> 00:02:59,560
Dentro de la función realizamos un cambio.

47
00:02:59,740 --> 00:03:04,060
Solamente se recibió una copia de la variable de argumento hacia la variable de parámetro.

48
00:03:04,330 --> 00:03:06,730
Vamos a ver nuestra animación para que todo esto quede más claro.

49
00:03:07,240 --> 00:03:09,430
En primer lugar, tenemos nuestro método principal.

50
00:03:09,610 --> 00:03:12,520
Se define la variable de argumento en cierta dirección de memoria.

51
00:03:12,910 --> 00:03:15,820
Así que hasta aquí solamente se está definiendo nuestra variable de argumento.

52
00:03:16,180 --> 00:03:20,920
Si se llegara a ejecutar la línea nueve, entonces tendríamos en memoria lo siguiente Tenemos nuestra

53
00:03:20,920 --> 00:03:24,610
variable de argumento con el valor de diez en cierta dirección de memoria.

54
00:03:24,940 --> 00:03:30,440
Ahora, como siguiente paso, se mandaría a imprimir el valor antes de llamar la función.

55
00:03:30,460 --> 00:03:34,900
Por lo tanto, imprimiría por primera vez este valor de diez, ya que es el valor que tiene la variable

56
00:03:34,900 --> 00:03:35,560
de argumento.

57
00:03:35,950 --> 00:03:41,770
Ahora, si continuamos, si se llegara a ejecutar la línea 11, entonces se manda llamar nuestra función.

58
00:03:41,770 --> 00:03:45,010
Cambia el valor, se pone en pausa la ejecución de la función principal.

59
00:03:45,340 --> 00:03:50,050
Pasamos a la función de cambiar valor y la variable de parámetro se crea en memoria.

60
00:03:50,350 --> 00:03:55,270
Así que podemos observar que se manda llamar Nuestra función Cambia el valor, se crea la variable de

61
00:03:55,270 --> 00:04:00,280
parámetro y entonces aquí es donde precisamente se aplica el concepto de paso por valor.

62
00:04:00,460 --> 00:04:05,650
Simplemente estamos pasando una copia del valor de la variable de argumento hacia la variable de parámetro.

63
00:04:05,850 --> 00:04:10,120
Pero por ello, cualquier modificación que hagamos sobre esta variable vamos a ver que no va a afectar

64
00:04:10,120 --> 00:04:15,220
en nada a la variable más externa, ya que estas variables son variables distintas en memoria.

65
00:04:15,220 --> 00:04:18,610
Como podemos observar, cada una tiene su propia dirección de memoria.

66
00:04:18,760 --> 00:04:20,800
Son variables muy distintas en memoria.

67
00:04:21,640 --> 00:04:25,330
Así que para inicializar esta variable simplemente se pasa una copia.

68
00:04:25,450 --> 00:04:27,370
Podemos observar que la variable de parámetro.

69
00:04:27,490 --> 00:04:32,860
Si se ejecuta esta línea, la línea cuatro se crea la variable de parámetro con el valor inicial de

70
00:04:32,890 --> 00:04:33,220
diez.

71
00:04:33,610 --> 00:04:39,460
Ahora, de manera interna, si realizamos un cambio, si se ejecuta la línea cinco, entonces ahora

72
00:04:39,460 --> 00:04:41,890
la variable de parámetro tiene el valor de 20.

73
00:04:42,760 --> 00:04:47,530
Podemos ver que tenemos el valor de 20, pero no afecta en nada el valor de la variable más externa.

74
00:04:47,920 --> 00:04:51,190
De igual manera, como ya hemos comentado, son variables distintas en memoria.

75
00:04:52,150 --> 00:04:57,430
Una vez que termina de ejecutarse la línea cinco, entonces termina de ejecutarse la función.

76
00:04:57,610 --> 00:05:03,130
Se elimina de la memoria la función, incluyendo su variable y podemos ver que regresa el control a

77
00:05:03,130 --> 00:05:03,940
la línea 11.

78
00:05:04,390 --> 00:05:08,770
Aquí no hay nada más que procesar ya que esta función no regresa Ningún tipo de información es de tipo

79
00:05:08,770 --> 00:05:09,070
void.

80
00:05:09,280 --> 00:05:13,240
Por lo tanto, continuamos con la línea 12 y entonces se manda a imprimir en memoria.

81
00:05:13,780 --> 00:05:18,430
Se ejecuta la línea 12 y entonces se manda a imprimir el valor de la variable de argumento.

82
00:05:18,700 --> 00:05:23,230
Pero como podemos comprobar en memoria, no se realizó ninguna modificación sobre este valor.

83
00:05:23,500 --> 00:05:26,980
Así que el valor final de esta variable es el valor de diez.

84
00:05:27,880 --> 00:05:30,750
Y básicamente ese es el concepto de paso por valor.

85
00:05:30,760 --> 00:05:34,930
Cualquier tipo de dato primitivo, como los que ya hemos comentado, funciona exactamente de la misma

86
00:05:34,930 --> 00:05:35,350
manera.

87
00:05:35,590 --> 00:05:37,120
Vamos a detener hasta aquí y ahora.

88
00:05:37,120 --> 00:05:41,500
En el siguiente vídeo vamos a ver cómo trabajar con referencias de memoria, utilizando precisamente

89
00:05:41,500 --> 00:05:44,800
el concepto de apuntadores, pero también aplicándolo a funciones.

90
00:05:44,980 --> 00:05:47,910
Bien, eso es todo por este vídeo y continuamos en el siguiente.

91
00:05:47,980 --> 00:05:48,520
Saludos.