Bienvenidos nuevamente a otra entrega sobre el lenguaje Small Basic, en esta ocasión hablaremos sobre la librería Stack, cuya misión es ofrecernos la opción de manejar pilas en nuestros programas. Una pila, para el que no lo sepa, es una estructura de datos similar a una lista de valores, la diferencia radica en que solo podemos meter nuevos elementos por el final de esta y al sacarlos solo podemos sacar el último. Al principio uno puede no ver la utilidad de las pilas, pero con el paso del tiempo al final se hacen indispensables y es de agradecer que estén implementadas en Small Basic. Introducido el concepto, pasemos a indicar cuales son las operaciones que soporta la librería Stack:
- GetCount(nombre): Devuelve el número de elementos almacenados en una pila.
- PopValue(nombre): Saca y devuelve un elemento de una pila.
- PushValue(nombre, valor): Introduce un elemento en una pila.
Nuevamente como ya indicamos en los arrays, hay que tener en cuenta que el nombre que identifica a la pila será convertido a una cadena, con lo que ello implica. Para verlo mejor aquí tenemos un ejemplo de lo que acabo de decir.
Stack.PushValue(0, "42")
aux = Stack.PopValue("0")
TextWindow.WriteLine(aux)
En este otro ejemplo se puede ver el funcionamiento de todas las operaciones de la librería. Lo que hacemos es calcular las potencias de dos con la librería Math, de la que hablaremos próximamente, y mostramos los números a medida que los vamos sacando para ver como parece que vamos hacia atrás.
'----------------------------------------------------
' Prueba con pilas y las potencias de 2
'----------------------------------------------------
TextWindow.Title = "Prueba con pilas"
endl = Text.GetCharacter(13) '\n
endl = endl + Text.GetCharacter(10) '\r
TextWindow.Write("Los metemos: ")
For i = 0 To 10
valor = Math.Power(2, i)
Stack.PushValue("PotenciasDeDos", valor)
TextWindow.Write(valor + " ")
EndFor
TextWindow.WriteLine(endl)
aux = "Hay " + Stack.GetCount("PotenciasDeDos")
aux = aux + " valores en la pila." + endl
TextWindow.WriteLine(aux)
TextWindow.Write("Y los sacamos: ")
For i = 0 To 10
valor = Stack.PopValue("PotenciasDeDos")
TextWindow.Write(valor + " ")
EndFor
TextWindow.WriteLine(endl)
Y por último el golpe maestro y definitivo para el lenguaje Small Basic, que a pesar de sus múltiples limitaciones ello no nos impide para que podamos realizar algoritmos recursivos (subrutinas que se llaman a si mismas sin que ello implique un bucle infinito). Para ello vamos a poner de ejemplo la función factorial:
'----------------------------------------------------
' Prueba del cálculo del factorial con pilas
'----------------------------------------------------
TextWindow.Title = "Cálculo del factorial con pilas"
For i = 0 To 28
Array.SetValue("MostrarFactorial", "n", i)
MostrarFactorial()
EndFor
'----------------------------------------------------
' MostrarFactorial(n)
Sub MostrarFactorial
' Obtenemos el parametro "n".
n = Array.GetValue("MostrarFactorial", "n")
' Salvamos el parametro antes de la llamada.
Stack.PushValue("MostrarFactorial", n)
' Pasamos el parametro a la función.
Array.SetValue("Factorial", "n", n)
' Invocamos a la función.
Factorial()
' Recuperamos el parametro tras la llamada.
n = Stack.PopValue("MostrarFactorial")
' Mostramos el resultado por pantalla.
aux = "Factorial(" + n + ") = " + r
TextWindow.WriteLine(aux)
EndSub
'----------------------------------------------------
' Factorial(n) = x * Factorial(n - 1)
Sub Factorial
' Obtenemos el parametro "n".
n = Array.GetValue("Factorial", "n")
' Comprobamos que "n" esté en unos límites.
If n > 27 Then ' Error por desbordamiento.
r = 0 ' Devolvemos 0.
ElseIf n > 1 Then ' Caso recursivo.
' Salvamos el parametro "n".
Stack.PushValue("Factorial", n)
' Pasamos el parametro a la función.
Array.SetValue("Factorial", "n", n - 1)
' Invocamos a la función.
Factorial()
' Recuperamos el parametro "n".
n = Stack.PopValue("Factorial")
' Calculamos el resultado a devolver.
r = r * n
Else ' Caso base.
r = 1 ' Devolvemos 1.
EndIf
EndSub
Como podemos ver Small Basic a pesar de sus limitaciones aparentes, nos permite cierta flexibilidad como realizar subrutinas recursivas. El problema es que nos podemos volver un poco locos a la hora de asignar valores a las variables, porque un solo descuido y el programa se pone a hacer cosas muy raras. Pero ahí está la opción para poder usarla. Como veis las pilas pueden ser bastante útiles si uno se lo propone.
Y con esto ya hemos terminado la sección de la API de Small Basic dedicada a las estructuras de datos. En el próximo artículo posiblemente explique un poco más el tema de cuando una cadena es convertida a número, que yo creo que es un tema bastante peliagudo y confuso. Luego seguiré hablando de las librerías del sistema que faltan (Math, File y Sound), antes de ponerme a hablar de las librerías que utilizan la ventana de windows normal. Mientras tanto ánimo y que paséis un buen puente.
Escrito por gorkasg 
Escrito por gorkasg 
Escrito por gorkasg 
