1
00:00:00,800 --> 00:00:03,710
Bien, vamos a continuar con nuestro ejemplo de variables en el lenguaje C.

2
00:00:04,430 --> 00:00:05,750
Voy a cerrar esta ventana.

3
00:00:07,220 --> 00:00:10,460
Para que tengamos más espacio y visualicemos todo nuestro código.

4
00:00:10,700 --> 00:00:15,920
Ahora lo que voy a hacer es que en esta línea 11 voy a modificar el valor inicial de nuestra variable.

5
00:00:16,190 --> 00:00:17,120
Así que en este caso.

6
00:00:17,420 --> 00:00:18,440
Como Paso cuatro.

7
00:00:20,100 --> 00:00:24,510
Modificamos el valor de nuestra variable para modificar el valor de una variable.

8
00:00:24,600 --> 00:00:25,560
Es bastante simple.

9
00:00:26,010 --> 00:00:28,350
De hecho, es idéntico que en la línea siete.

10
00:00:28,530 --> 00:00:34,350
Solamente que en este caso, debido a que la variable definida en la línea cinco todavía no tenía un

11
00:00:34,350 --> 00:00:35,190
valor asignado.

12
00:00:35,400 --> 00:00:37,710
En este momento tiene un valor basura.

13
00:00:38,040 --> 00:00:42,510
Y si después de esta línea mandáramos a imprimir esta información, vamos a ver que aunque nosotros

14
00:00:42,510 --> 00:00:45,780
no le hemos asignado ningún valor, ya va a imprimir cierta información.

15
00:00:45,960 --> 00:00:49,140
Sin embargo, este es un valor que se conoce como valor basura.

16
00:00:49,410 --> 00:00:50,430
Vamos a comprobarlo.

17
00:00:51,210 --> 00:00:56,880
Si mandamos a imprimir en este punto el valor de nuestra variable, nuestro código se va a ir ejecutando

18
00:00:56,880 --> 00:00:57,810
línea a línea.

19
00:00:58,110 --> 00:01:01,950
Así que lo primero que va a suceder es que entra en nuestro método main.

20
00:01:02,340 --> 00:01:04,560
Y recordemos que dos comentarios se omiten.

21
00:01:04,830 --> 00:01:06,690
Estos comentarios no se ejecutan.

22
00:01:06,840 --> 00:01:12,450
Todo lo que esté con doble diagonal o con diagonal asterisco y termina con asterisco diagonal se va

23
00:01:12,450 --> 00:01:13,080
a omitir.

24
00:01:13,080 --> 00:01:14,160
No se va a ejecutar.

25
00:01:14,430 --> 00:01:17,490
Así que la primer línea que se va a ejecutar es la línea cinco.

26
00:01:17,730 --> 00:01:23,250
En este momento se declara una variable y en memoria se crea esta variable, pero con un valor basura.

27
00:01:23,400 --> 00:01:27,540
Por lo tanto, en la línea seis, que es la siguiente línea que se va a ejecutar, se va a mandar a

28
00:01:27,540 --> 00:01:32,970
imprimir este valor que es un valor basura y ya posteriormente si le vamos a asignar un valor que nosotros

29
00:01:32,970 --> 00:01:34,920
utilicemos en este caso el valor de diez.

30
00:01:35,220 --> 00:01:38,330
Sin embargo, es la primera vez que le estamos asignando un valor.

31
00:01:38,400 --> 00:01:41,760
Por lo tanto, se dice que estamos inicializando nuestra variable.

32
00:01:42,090 --> 00:01:44,670
Y ahora en la línea 13, vamos a modificar este valor.

33
00:01:44,790 --> 00:01:48,810
Sin embargo, de momento vamos a mandar a imprimir este valor basura para que lo veamos.

34
00:01:49,020 --> 00:01:51,630
Resultado de mandar a ejecutar la línea seis.

35
00:01:52,110 --> 00:01:54,660
Así que podemos observar que se está imprimiendo en la línea seis.

36
00:01:54,930 --> 00:02:00,870
Este valor 38 01088 y posteriormente se imprime el valor de diez.

37
00:02:01,350 --> 00:02:03,210
Eso se está imprimiendo en la misma línea.

38
00:02:03,450 --> 00:02:09,150
Así que para que podamos imprimir en líneas diferentes, vamos a hacer lo siguiente Vamos a especificar

39
00:02:09,150 --> 00:02:12,360
un carácter especial que se conoce como salto de línea.

40
00:02:12,720 --> 00:02:17,340
Esto para que la información que estamos mandando a imprimir en la línea 11 se imprima en una nueva

41
00:02:17,340 --> 00:02:17,760
línea.

42
00:02:17,880 --> 00:02:23,610
Por lo tanto, ponemos al inicio de nuestra cadena diagonal N, pero esto es parte de nuestra cadena

43
00:02:23,610 --> 00:02:25,130
que estamos mandando a imprimir.

44
00:02:25,170 --> 00:02:28,260
Por lo tanto, debe estar dentro de esta doble comilla.

45
00:02:28,530 --> 00:02:34,080
Simplemente es un carácter especial en el cual estamos indicando que al momento de mandar a imprimir

46
00:02:34,230 --> 00:02:37,980
esta información, también se va a imprimir este salto de línea.

47
00:02:38,220 --> 00:02:43,560
Y después del salto de línea se está mandando imprimir el valor de nuestra variable, que es una variable

48
00:02:43,560 --> 00:02:48,480
de tipo entero, el cual vamos a tomar este valor de la variable llamada mi número.

49
00:02:49,500 --> 00:02:52,320
Así que con esto estamos especificando un salto de línea.

50
00:02:52,860 --> 00:02:54,300
El carácter especial.

51
00:02:55,810 --> 00:03:03,490
Diagonal inversa N imprime un salto de línea y así tenemos más caracteres especiales que vamos a ver

52
00:03:03,490 --> 00:03:04,240
posteriormente.

53
00:03:04,450 --> 00:03:08,530
De momento ese es el que nos interesa para que podamos mandar a imprimir un salto de línea.

54
00:03:08,740 --> 00:03:11,950
Vamos a volver a ejecutar y entonces podemos visualizar ahora.

55
00:03:11,950 --> 00:03:17,320
Así que cuando mandamos a imprimir nuestro valor en la línea seis, entonces está mandando a imprimir

56
00:03:17,320 --> 00:03:20,530
un valor basura el valor de 30, diez 56 cero.

57
00:03:20,830 --> 00:03:25,870
Y cada vez que mandemos a imprimir nuestro programa, este valor es distinto, ya que el valor basura

58
00:03:25,870 --> 00:03:30,760
es el valor que se está almacenando en la memoria, pero en la memoria, si no hemos asignado un valor,

59
00:03:30,880 --> 00:03:35,290
entonces simplemente es cualquier valor que esté almacenado en esa dirección de memoria.

60
00:03:35,560 --> 00:03:40,900
Y posteriormente, una vez que modificamos el valor por el valor de diez, entonces en la línea 12 se

61
00:03:40,900 --> 00:03:45,880
vuelve a mandar a imprimir esta información y podemos observar que ahora sí se toma el valor que nosotros

62
00:03:45,880 --> 00:03:48,070
hemos asignado, el valor de diez.

63
00:03:48,650 --> 00:03:52,450
Bien, eso es para que entendamos cómo trabaja la definición de nuestras variables.

64
00:03:52,630 --> 00:03:58,270
Estamos definiendo esta variable en memoria, pero si no le asignamos un valor, entonces su valor inicial

65
00:03:58,270 --> 00:03:59,440
es un valor basura.

66
00:03:59,950 --> 00:04:05,320
Bien, ahora en la línea 14, lo que queremos hacer es modificar el valor de nuestra variable, así

67
00:04:05,320 --> 00:04:10,450
que para modificarlo, simplemente volvemos a utilizar el nombre de nuestra variable y le asignamos

68
00:04:10,450 --> 00:04:13,120
un valor, por ejemplo, en este caso el valor de 20.

69
00:04:13,510 --> 00:04:16,480
Y finalmente volvemos a mandar imprimir esta información.

70
00:04:16,660 --> 00:04:21,040
Lo que estoy haciendo es copiar esta línea, ya que es exactamente el mismo código.

71
00:04:21,190 --> 00:04:24,940
Por lo tanto, selecciono y presiono Control C o comando.

72
00:04:25,060 --> 00:04:31,300
Si estamos en Mac para copiar este código y para pegarlo me posiciono en la línea 15 y presiono control

73
00:04:31,300 --> 00:04:31,480
B.

74
00:04:31,930 --> 00:04:34,960
Esto para poder pegar el código que hemos copiado anteriormente.

75
00:04:35,320 --> 00:04:41,020
Y si estamos en Mac sería Command B, así que en la línea 14 estamos modificando el valor de nuestra

76
00:04:41,020 --> 00:04:43,330
variable y se lo volvemos a mandar a imprimir.

77
00:04:43,330 --> 00:04:46,630
Tendríamos que ver ahora el valor de twenty y ya sea sobrescrito.

78
00:04:46,630 --> 00:04:49,720
El valor de diez aquí se sobrescribe.

79
00:04:52,120 --> 00:04:53,290
El valor inicial.

80
00:04:54,180 --> 00:05:00,120
El valor de diez se pierde ese valor y el valor de 20 es el nuevo valor para esta variable.

81
00:05:00,360 --> 00:05:01,350
Vamos a ejecutarlo.

82
00:05:03,480 --> 00:05:04,260
Y podemos cebar.

83
00:05:04,260 --> 00:05:06,690
Aquí se definen nuestra variable se crea en memoria.

84
00:05:07,050 --> 00:05:12,610
En la línea seis se manda a imprimir este valor como hemos comentado, sin haberlo inicializado.

85
00:05:12,660 --> 00:05:14,520
Por lo tanto se imprime este valor basura.

86
00:05:14,670 --> 00:05:19,740
Podemos observar que es otro número distinto de la ejecución anterior, ya que cada vez que volvemos

87
00:05:19,740 --> 00:05:23,810
a ejecutar nuestro programa, recordemos que la memoria RAM es una memoria volátil.

88
00:05:23,820 --> 00:05:28,320
Por lo tanto, cualquier valor que hayamos almacenado en esta variable se pierde y se vuelve a asignar

89
00:05:28,320 --> 00:05:29,130
un nuevo valor.

90
00:05:29,340 --> 00:05:31,380
Incluso es otra dirección de memoria.

91
00:05:31,680 --> 00:05:33,300
No es la misma necesariamente.

92
00:05:33,450 --> 00:05:37,860
Así que cada vez que ejecutemos nuestro programa, esta variable se le asigna una dirección de memoria

93
00:05:37,860 --> 00:05:41,650
distinta y por lo tanto también el valor que almacena el valor inicial.

94
00:05:41,670 --> 00:05:43,950
Este valor basura también es distinto.

95
00:05:44,460 --> 00:05:47,880
Bien, como segundo paso se inicializa nuestra variable.

96
00:05:48,150 --> 00:05:51,960
Y ahora sí, en la línea 12 se manda a imprimir el valor de diez.

97
00:05:52,320 --> 00:05:58,380
Esto es lo que estamos logrando con la línea 12 y finalmente en la línea 14 se modifica el valor con

98
00:05:58,380 --> 00:06:02,040
el valor de 20 y cuando se van a imprimir de nueva cuenta esta variable.

99
00:06:03,040 --> 00:06:04,900
Se imprime ahora el valor de 20.

100
00:06:05,110 --> 00:06:10,930
Recordemos que nuestro programa se ejecuta línea a línea desde la primera línea hasta la parte inferior,

101
00:06:11,380 --> 00:06:16,420
por lo tanto, la última línea, la última vez que utilizamos esta variable tiene el valor de twenty.

102
00:06:16,450 --> 00:06:19,180
Este es el valor final con el que termina nuestra variable.

103
00:06:19,480 --> 00:06:24,430
Sin embargo, esta variable también se destruye al momento en que termina de ejecutarse en nuestro programa.

104
00:06:24,760 --> 00:06:30,250
La última línea de código de este método Main es la línea 17, y una vez que se regresa el valor de

105
00:06:30,250 --> 00:06:33,580
cero, significa que nuestro programa terminó correctamente.

106
00:06:33,880 --> 00:06:38,260
Recordemos que si regresa el valor de cero quiere decir que nuestro programa se ejecutó correctamente

107
00:06:38,530 --> 00:06:43,360
y entonces termina nuestro método main en el momento en que termina de ejecutarse en nuestro método

108
00:06:43,360 --> 00:06:43,600
main.

109
00:06:43,780 --> 00:06:49,150
También esta variable se elimina de la memoria RAM, y así, cada vez que ejecutemos nuestro programa,

110
00:06:49,360 --> 00:06:54,460
podemos comprobar que nuestras variables almacenan valores distintos, al menos de manera inicial,

111
00:06:54,670 --> 00:06:59,170
ya que cada vez que ejecutamos nuestro programa se le asigna una dirección de memoria distinta a nuestras

112
00:06:59,170 --> 00:06:59,710
variables.

113
00:06:59,860 --> 00:07:05,470
Si volvemos a ejecutarlo, podemos observar que, a diferencia de la ejecución anterior, en la que

114
00:07:05,470 --> 00:07:12,250
teníamos un valor basura inicial con terminación 88, ahora tenemos un valor inicial con terminación

115
00:07:12,250 --> 00:07:16,360
40 es otro valor basura, ya que esta dirección de memoria es distinta.

116
00:07:16,810 --> 00:07:21,250
Sin embargo, una vez que le asignamos los valores a nuestras variables, se respetan estos valores

117
00:07:21,250 --> 00:07:23,980
hasta que termina la ejecución de nuestro programa principal.

118
00:07:24,850 --> 00:07:29,610
Así que otro detalle importante es que esta variable se crea al momento en que comienza a ejecutarse

119
00:07:29,630 --> 00:07:35,140
nuestro método principal y termina al momento en que termina de ejecutarse en nuestro método principal.

120
00:07:35,410 --> 00:07:40,570
Así que en este momento, esta variable también en memoria ya se destruye y por lo tanto, cada vez

121
00:07:40,570 --> 00:07:45,070
que volvemos a ejecutar nuestro programa, se vuelve a crear nuestra variable en otra dirección de memoria.

122
00:07:45,670 --> 00:07:50,500
Esto lo vamos a comprobar más adelante cuando mandemos a imprimir la dirección de memoria de nuestras

123
00:07:50,500 --> 00:07:51,010
variables.

124
00:07:51,250 --> 00:07:56,170
Pero de momento esto es suficiente para que tengamos a grandes rasgos el concepto de variables en el

125
00:07:56,170 --> 00:07:56,770
lenguaje c.

126
00:07:57,160 --> 00:08:01,750
Ahora, un detalle importante es que en cada una de estas lecciones, en cada uno de estos videos donde

127
00:08:01,750 --> 00:08:07,180
estamos realizando ejemplos, les vamos a adjuntar el código fuente que estamos realizando esto para

128
00:08:07,180 --> 00:08:11,500
que puedan descargarlo sin ningún problema y en dado caso también puedan ponerlo en práctica.

129
00:08:11,650 --> 00:08:16,360
Pero recuerden que aquí también lo importante es que puedan hacerlo por ustedes mismos, ya que va a

130
00:08:16,360 --> 00:08:21,970
ser la única manera en que van a poder aplicar estos conceptos y aprenderlo y recordarlo correctamente.

131
00:08:22,240 --> 00:08:26,740
Así que por ello les invitamos a que cada uno de estos ejemplos los vayan realizando paso a paso con

132
00:08:26,740 --> 00:08:27,310
nosotros.

133
00:08:27,700 --> 00:08:33,130
Incluso si es necesario poner pausa al video o agregar más comentarios a su código, esto es importante

134
00:08:33,130 --> 00:08:35,650
para que vayan quedando claros estos conceptos.

135
00:08:35,800 --> 00:08:40,180
Así que por ello los invitamos a que cada uno de estos ejemplos los vayan realizando paso a paso con

136
00:08:40,180 --> 00:08:45,250
nosotros y también, si tienen alguna duda con el código, pueden descargarlo de cada una de estas lecciones,

137
00:08:45,250 --> 00:08:47,350
de cada uno de estos ejemplos que estamos realizando.

138
00:08:47,660 --> 00:08:48,970
Bien, eso es todo por selección.

139
00:08:49,030 --> 00:08:51,370
Pónganlo en práctica y nos vemos en el siguiente vídeo.

140
00:08:51,550 --> 00:08:52,090
Saludos.
