Bien, vamos a continuar con nuestro ejemplo de variables en el lenguaje C.
Voy a cerrar esta ventana.
Para que tengamos más espacio y visualicemos todo nuestro código.
Ahora lo que voy a hacer es que en esta línea 11 voy a modificar el valor inicial de nuestra variable.
Así que en este caso.
Como Paso cuatro.
Modificamos el valor de nuestra variable para modificar el valor de una variable.
Es bastante simple.
De hecho, es idéntico que en la línea siete.
Solamente que en este caso, debido a que la variable definida en la línea cinco todavía no tenía un
valor asignado.
En este momento tiene un valor basura.
Y si después de esta línea mandáramos a imprimir esta información, vamos a ver que aunque nosotros
no le hemos asignado ningún valor, ya va a imprimir cierta información.
Sin embargo, este es un valor que se conoce como valor basura.
Vamos a comprobarlo.
Si mandamos a imprimir en este punto el valor de nuestra variable, nuestro código se va a ir ejecutando
línea a línea.
Así que lo primero que va a suceder es que entra en nuestro método main.
Y recordemos que dos comentarios se omiten.
Estos comentarios no se ejecutan.
Todo lo que esté con doble diagonal o con diagonal asterisco y termina con asterisco diagonal se va
a omitir.
No se va a ejecutar.
Así que la primer línea que se va a ejecutar es la línea cinco.
En este momento se declara una variable y en memoria se crea esta variable, pero con un valor basura.
Por lo tanto, en la línea seis, que es la siguiente línea que se va a ejecutar, se va a mandar a
imprimir este valor que es un valor basura y ya posteriormente si le vamos a asignar un valor que nosotros
utilicemos en este caso el valor de diez.
Sin embargo, es la primera vez que le estamos asignando un valor.
Por lo tanto, se dice que estamos inicializando nuestra variable.
Y ahora en la línea 13, vamos a modificar este valor.
Sin embargo, de momento vamos a mandar a imprimir este valor basura para que lo veamos.
Resultado de mandar a ejecutar la línea seis.
Así que podemos observar que se está imprimiendo en la línea seis.
Este valor 38 01088 y posteriormente se imprime el valor de diez.
Eso se está imprimiendo en la misma línea.
Así que para que podamos imprimir en líneas diferentes, vamos a hacer lo siguiente Vamos a especificar
un carácter especial que se conoce como salto de línea.
Esto para que la información que estamos mandando a imprimir en la línea 11 se imprima en una nueva
línea.
Por lo tanto, ponemos al inicio de nuestra cadena diagonal N, pero esto es parte de nuestra cadena
que estamos mandando a imprimir.
Por lo tanto, debe estar dentro de esta doble comilla.
Simplemente es un carácter especial en el cual estamos indicando que al momento de mandar a imprimir
esta información, también se va a imprimir este salto de línea.
Y después del salto de línea se está mandando imprimir el valor de nuestra variable, que es una variable
de tipo entero, el cual vamos a tomar este valor de la variable llamada mi número.
Así que con esto estamos especificando un salto de línea.
El carácter especial.
Diagonal inversa N imprime un salto de línea y así tenemos más caracteres especiales que vamos a ver
posteriormente.
De momento ese es el que nos interesa para que podamos mandar a imprimir un salto de línea.
Vamos a volver a ejecutar y entonces podemos visualizar ahora.
Así que cuando mandamos a imprimir nuestro valor en la línea seis, entonces está mandando a imprimir
un valor basura el valor de 30, diez 56 cero.
Y cada vez que mandemos a imprimir nuestro programa, este valor es distinto, ya que el valor basura
es el valor que se está almacenando en la memoria, pero en la memoria, si no hemos asignado un valor,
entonces simplemente es cualquier valor que esté almacenado en esa dirección de memoria.
Y posteriormente, una vez que modificamos el valor por el valor de diez, entonces en la línea 12 se
vuelve a mandar a imprimir esta información y podemos observar que ahora sí se toma el valor que nosotros
hemos asignado, el valor de diez.
Bien, eso es para que entendamos cómo trabaja la definición de nuestras variables.
Estamos definiendo esta variable en memoria, pero si no le asignamos un valor, entonces su valor inicial
es un valor basura.
Bien, ahora en la línea 14, lo que queremos hacer es modificar el valor de nuestra variable, así
que para modificarlo, simplemente volvemos a utilizar el nombre de nuestra variable y le asignamos
un valor, por ejemplo, en este caso el valor de 20.
Y finalmente volvemos a mandar imprimir esta información.
Lo que estoy haciendo es copiar esta línea, ya que es exactamente el mismo código.
Por lo tanto, selecciono y presiono Control C o comando.
Si estamos en Mac para copiar este código y para pegarlo me posiciono en la línea 15 y presiono control
B.
Esto para poder pegar el código que hemos copiado anteriormente.
Y si estamos en Mac sería Command B, así que en la línea 14 estamos modificando el valor de nuestra
variable y se lo volvemos a mandar a imprimir.
Tendríamos que ver ahora el valor de twenty y ya sea sobrescrito.
El valor de diez aquí se sobrescribe.
El valor inicial.
El valor de diez se pierde ese valor y el valor de 20 es el nuevo valor para esta variable.
Vamos a ejecutarlo.
Y podemos cebar.
Aquí se definen nuestra variable se crea en memoria.
En la línea seis se manda a imprimir este valor como hemos comentado, sin haberlo inicializado.
Por lo tanto se imprime este valor basura.
Podemos observar que es otro número distinto de la ejecución anterior, ya que cada vez que volvemos
a ejecutar nuestro programa, recordemos que la memoria RAM es una memoria volátil.
Por lo tanto, cualquier valor que hayamos almacenado en esta variable se pierde y se vuelve a asignar
un nuevo valor.
Incluso es otra dirección de memoria.
No es la misma necesariamente.
Así que cada vez que ejecutemos nuestro programa, esta variable se le asigna una dirección de memoria
distinta y por lo tanto también el valor que almacena el valor inicial.
Este valor basura también es distinto.
Bien, como segundo paso se inicializa nuestra variable.
Y ahora sí, en la línea 12 se manda a imprimir el valor de diez.
Esto es lo que estamos logrando con la línea 12 y finalmente en la línea 14 se modifica el valor con
el valor de 20 y cuando se van a imprimir de nueva cuenta esta variable.
Se imprime ahora el valor de 20.
Recordemos que nuestro programa se ejecuta línea a línea desde la primera línea hasta la parte inferior,
por lo tanto, la última línea, la última vez que utilizamos esta variable tiene el valor de twenty.
Este es el valor final con el que termina nuestra variable.
Sin embargo, esta variable también se destruye al momento en que termina de ejecutarse en nuestro programa.
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
cero, significa que nuestro programa terminó correctamente.
Recordemos que si regresa el valor de cero quiere decir que nuestro programa se ejecutó correctamente
y entonces termina nuestro método main en el momento en que termina de ejecutarse en nuestro método
main.
También esta variable se elimina de la memoria RAM, y así, cada vez que ejecutemos nuestro programa,
podemos comprobar que nuestras variables almacenan valores distintos, al menos de manera inicial,
ya que cada vez que ejecutamos nuestro programa se le asigna una dirección de memoria distinta a nuestras
variables.
Si volvemos a ejecutarlo, podemos observar que, a diferencia de la ejecución anterior, en la que
teníamos un valor basura inicial con terminación 88, ahora tenemos un valor inicial con terminación
40 es otro valor basura, ya que esta dirección de memoria es distinta.
Sin embargo, una vez que le asignamos los valores a nuestras variables, se respetan estos valores
hasta que termina la ejecución de nuestro programa principal.
Así que otro detalle importante es que esta variable se crea al momento en que comienza a ejecutarse
nuestro método principal y termina al momento en que termina de ejecutarse en nuestro método principal.
Así que en este momento, esta variable también en memoria ya se destruye y por lo tanto, cada vez
que volvemos a ejecutar nuestro programa, se vuelve a crear nuestra variable en otra dirección de memoria.
Esto lo vamos a comprobar más adelante cuando mandemos a imprimir la dirección de memoria de nuestras
variables.
Pero de momento esto es suficiente para que tengamos a grandes rasgos el concepto de variables en el
lenguaje c.
Ahora, un detalle importante es que en cada una de estas lecciones, en cada uno de estos videos donde
estamos realizando ejemplos, les vamos a adjuntar el código fuente que estamos realizando esto para
que puedan descargarlo sin ningún problema y en dado caso también puedan ponerlo en práctica.
Pero recuerden que aquí también lo importante es que puedan hacerlo por ustedes mismos, ya que va a
ser la única manera en que van a poder aplicar estos conceptos y aprenderlo y recordarlo correctamente.
Así que por ello les invitamos a que cada uno de estos ejemplos los vayan realizando paso a paso con
nosotros.
Incluso si es necesario poner pausa al video o agregar más comentarios a su código, esto es importante
para que vayan quedando claros estos conceptos.
Así que por ello los invitamos a que cada uno de estos ejemplos los vayan realizando paso a paso con
nosotros y también, si tienen alguna duda con el código, pueden descargarlo de cada una de estas lecciones,
de cada uno de estos ejemplos que estamos realizando.
Bien, eso es todo por selección.
Pónganlo en práctica y nos vemos en el siguiente vídeo.
Saludos.