Hola y bienvenidos.
Vamos a ver a continuación la ejecución paso a paso en nuestro IDE de Shinji.
Están listos?
Vamos.
Bien.
Una de las ventajas de trabajar con herramientas como en este caso el IDE de Shinji, es que podemos
ejecutar paso a paso nuestro código.
En este caso, les estamos agregando una animación.
Observamos esta ventana del lado derecho en la cual vamos a agregar una animación de la ejecución paso
a paso de nuestro código y podemos observar en primer lugar que tenemos nuestra memoria stack.
Aquí es donde se va a almacenar la llamada de nuestras funciones.
Podemos observar que tenemos la llamada de nuestra función principal y también aquí vemos cómo se van
a ir definiendo y creando nuestras variables.
Y recordemos que la memoria de Stack se llama precisamente Stack, porque vamos a ir agregando 1 a 1
nuestros elementos conforme se vayan definiendo y ejecutando en nuestro programa.
Así que ya sea llamadas a funciones o también creación de variables, se van a ir agregando como si
fuera una pila.
En este caso, esta pila podríamos decir que está en orden inverso, ya que normalmente una pila.
Tenemos el primer elemento.
El segundo elemento es decir, que se van apilando y conforme se van dejando de utilizar, entonces
se van quitando según el orden en que se fueron apilando.
En este mismo orden se van eliminando, pero de manera inversa.
Así que esto sería básicamente una pila.
Pero por la forma en que vamos a realizar nuestra animación, esos nuevos elementos se van a ir agregando
hacia la parte inferior y conforme se van eliminando, entonces se van a ir retirando de nuestra memoria.
Así que ese es el concepto de memoria stack.
Y ya más adelante también vamos a ver en qué consiste el concepto de memoria IP.
De momento este concepto de memoria no lo vamos a trabajar, pero también es otra sección de memoria
que se utiliza sobre todo en lenguajes de programación orientada a objetos.
El lenguaje de C es importante comentar que solamente soporta programación estructurada y no soporta
la programación orientada a objetos.
Ejemplos de lenguajes que soportan la programación orientada a objetos podría ser, por ejemplo en lenguaje
de C++, el lenguaje de Java, C, Sharp, JavaScript, Python, etc Esos son otros lenguajes que sí
soportan la programación orientada a objetos.
Pero debido a que el lenguaje C es uno de los primeros lenguajes que se crearon, entonces este es únicamente
un lenguaje estructurado.
Esto quiere decir que nuestras instrucciones de código se ejecutan únicamente de manera secuencial,
Así que por ello vamos a ir ejecutando 1 a 1 nuestras líneas de código desde la parte superior hasta
la parte inferior.
Y es precisamente lo que vamos a hacer en este ejercicio.
Vamos a ejecutar paso a paso nuestro código.
Así que tenemos nuestro código, Tenemos nuestra animación.
Pero esta animación hemos comentado que no es parte de nuestro IDE, solamente es un apoyo visual para
que podamos entender correctamente cada uno de nuestros ejercicios y esta animación.
En la medida de lo posible, vamos a ir agregando a cada uno de los ejemplos que vamos a estar estudiando
a lo largo de nuestro curso.
Bien, para ejecutar paso a paso nuestro programa, lo primero que tenemos que hacer es poner un punto
de ruptura.
Por ejemplo, en la línea cinco, donde estamos definiendo nuestra variable, podemos agregar un punto
de ruptura de la siguiente manera A este punto de ruptura también se le conoce como breakpoint en inglés.
Así que para agregar un punto de ruptura, en este caso en la línea cinco, nos posicionamos entre el
número cinco y esta barra gris que podemos observar que separa nuestro código.
Así que si damos clic sobre la línea cinco en este espacio, entonces se agrega un punto de ruptura.
Y para quitar este punto de ruptura, simplemente volvemos a dar clic.
Ahora, un punto de ruptura, precisamente como su nombre lo indica, quiere decir que se va a detener
la ejecución de nuestro programa en este momento, en este caso en la línea cinco.
Y una vez que hemos agregado este punto de ruptura, tenemos este botón.
Este botón nos permite hacer debug o lo que es lo mismo, ejecución paso a paso de nuestro programa.
Así que vamos a hacer lo siguiente Una vez que hemos agregado el punto de ruptura, presionamos este
botón de debug.
Vamos a presionarlo.
Nos indica que en este caso, la línea cinco no es una línea válida para agregar un punto de ruptura,
ya que debe de ser, por ejemplo, una variable que se está declarando pero que además se está inicializando.
Así que damos clic en OK, Vamos a asignar un valor a nuestra variable para que podamos agregar este
punto de ruptura.
Por ejemplo, le asignamos el valor de then de manera inicial.
Volvemos a agregar nuestro punto de ruptura y volvemos a ejecutar.
Y podemos observar que en este caso, ahora, si ya se ejecutó nuestro modo debug ya es una línea válida.
Como hemos comentado, esta línea no era válida debido a que tenemos que llegar a este punto de ruptura
en una línea donde estemos declarando una variable, pero además también le estemos asignando un valor.
Bien, así que ya tenemos nuestro punto de ruptura y para poder ejecutar esta línea de código, tenemos
el siguiente botón.
En este caso, este botón se conoce como este hover, es decir, que solamente va a ejecutar esta línea
de código.
Pero si en esta línea se ejecutará alguna función, no vamos a entrar al detalle de la ejecución de
dicha función.
Solamente se va a ejecutar por completo esta línea de código.
Así que para esto funciona este botón de este hover.
Pero por ejemplo, en el método printf si quisiéramos entrar al detalle de este.
Entonces, en lugar de este hover, presionaremos el botón de este pin.
Esto para entrar al detalle de esta función de printf.
Pero de momento solamente queremos ejecutar esta línea de código.
Así que presionamos el botón de step over y entonces observamos que en este momento en memoria ya se
ha creado nuestra variable llamada mi número.
Estamos dentro del método main y ya se ha creado esta variable y se le está asignando el valor de then.
Recordemos que además falta observar la dirección de memoria donde se encuentra esta variable.
Esto lo vamos a ver posteriormente, pero de momento, de manera simplificada, tenemos el nombre de
nuestra variable, tenemos su valor y además tenemos el tipo de dato que se está almacenando en esta
variable.
Recordemos que al momento de definir nuestra variable hemos especificado que va almacenar un valor de
tipo entero.
Y ahora, si volvemos a ejecutar nuestro programa, presionamos de nueva cuenta este hover.
No necesitamos entrar al detalle en nuestra función.
Simplemente queremos mandar a imprimir este valor.
Así que mandamos a imprimir de nueva cuenta presionando el botón de este hover y podemos observar en
nuestra salida, en nuestra consola, el valor de diez.
Así que ya se está imprimiendo precisamente este valor que hemos asignado a nuestra variable.
Se está recuperando, lo estamos leyendo y se manda a imprimir este valor debido a que estamos ejecutando
la línea seis de nuestro código.
Ahora, en la línea ocho, simplemente lo que estamos haciendo es volver a asignar un valor.
Vamos a presionar este hover se manda a imprimir de nueva cuenta este valor debido a que no se ha modificado
el valor inicial de diez es el valor que se vuelve a mandar imprimir y podemos llevar que ahora estamos
ejecutando la línea 14.
Esta línea 14 lo que va a hacer es modificar el valor de la variable mi número.
Así que volvemos a ejecutar y entonces en nuestra animación podemos ver que en este momento, si ya
se ejecutó la línea 14, entonces quiere decir que el valor que tenía nuestra variable en lugar de diez.
Ahora ya tenemos el valor de 20.
Por lo tanto, si ejecutamos la línea 15, volvemos a ejecutar.
Se imprime ahora el valor de 20, así que estamos recuperando de la memoria el valor almacenado por
esta variable y se manda a imprimir el valor de 20.
Y básicamente esta es la última línea de código de nuestro programa.
Ya la siguiente línea va a retornar el valor de cero, que significa que todo ha funcionado correctamente
en nuestro programa.
Vamos a presionar de nueva cuenta este hover.
Ya estamos en la última línea de código.
Y entonces con eso termina de ejecutarse nuestro programa y entonces en nuestra animación lo que sucedería
es que termina de ejecutarse nuestro programa principal, nuestra función main y por lo tanto también
se destruye de memoria nuestra variable.
Así que la siguiente vez que volviéramos a ejecutar nuestro programa, volvemos a iniciar desde la línea
cinco y entonces esta variable se declara en otra posición de memoria.
Se vuelve a crear nuestra variable.
La variable de mi número, pero con otra posición de memoria.
Por lo tanto.
El valor inicial.
Recordemos que si no le hemos asignado otro valor, su valor inicial va a ser un valor basura, ya que
se encuentra almacenando este valor basura si es que no le hemos asignado un valor inicial y con eso
ya terminamos de ejecutar nuestro modo debug.
Y por último, podemos quitar este punto de ruptura y con esto ya hemos terminado de ejecutar paso a
paso a nuestro programa.
Si queremos volver a ejecutar el modo paso a paso, simplemente presionamos este ícono.
Para poder ejecutar nuestro programa de una sola vez.
Pero ya sabemos que se ejecuta línea a línea.
Así que desde la línea cinco hasta la línea 15 se va ejecutando una a una cada una de estas líneas.
Así que esta es la forma en que se ejecutan los programas de manera secuencial, desde la primera línea
hasta la última línea.
Además, también hemos visto cómo ejecutar paso a paso nuestro programa.
Esto nos va a servir bastante para poder encontrar errores en caso de que los encontremos al momento
de ejecutar nuestros programas.
Así que este modo debug o modo depuración nos va a permitir encontrar ese tipo de errores y poderlos
resolver más fácilmente.
Bien, pongo en práctica este ejemplo, incluyendo este modo de y nos vemos en el siguiente vídeo.
Saludos.