Page 192
Image_2341_0
Verificación de algoritmos en Visual Basic. Construcción de tablas de variables.
__rendered_path__4
VERIFICACIÓN DE ALGORITMOS UTILIZANDO VISUAL BASIC
Cuando hablamos de "Verificación de algoritmos" en el curso “Bases de la programación nivel I” de
aprenderaprogramar.com, distinguimos cinco técnicas que eran:
Verificación mental.
Verificación por seguimiento escrito.
Verificación por seguimiento con tablas de variables.
Verificación por seguimiento con desarrollo en un lenguaje.
Verificación por seguimiento con un lenguaje y paso a paso.
Vamos a abordar cómo usar estas técnicas con Visual Basic. Dado que la verificación mental o por
seguimiento escrito son propias del programador y su mente, o a lo sumo, un papel de ayuda,
comenzaremos por ver cómo construir tablas de variables con Visual Basic.
CONSTRUIR TABLAS DE VARIABLES A TRAVÉS DE VISUAL BASIC
Consideremos el siguiente código, correspondiente a una estructura de bucle anidado dentro de otro:
Código versiones menos recientes VB: Código versiones más recientes VB:
Image_2345_0
'Curso VB aprenderaprogramar.com
R
Option Explicit On
EM Curso Visual Basic aprenderaprogramar.com
Image_2343_0
Option Explicit
Dim i%, j As Integer
Public
Private
Class
Sub
Form1_Load(
Form1
ByVal
sender
As
System.
Object
,
Dim A As Integer
Private Sub Form_Load()
ByVal
e
As
Dim
System.
i, j
As
EventArgs
Integer
)
Handles
MyBase
.Load
Label1 = " "
Dim A As Integer
For i = 1 To 5
Label1.Text =
""
For j = 1 To 5
A = i * j
Label1 = Label1 & A & ", "
A = i * j
For
i = 1
For
To
j = 1
5
To
5
Label1 = Label1 & " // "
Next j
Label1.Text = Label1.Text & A &
Next
j
Label1.Text = Label1.Text &
" // "
", "
Next i
End Sub
End
End
Class
Next
Sub
i
Image_2344_0
__rendered_path__111Image_2342_0
__rendered_path__129
Supongamos que queremos construir una tabla de variables en Visual Basic con 3 columnas:
__rendered_path__73
Paso bucle 01 (i)
Paso bucle 02 (j)
Valor de A
__rendered_path__65__rendered_path__72__rendered_path__77
.
.
.
__rendered_path__66__rendered_path__74__rendered_path__79
.
.
.
__rendered_path__68__rendered_path__75__rendered_path__81
.
.
.
__rendered_path__66__rendered_path__76
.
.
.
__rendered_path__65__rendered_path__78
__rendered_path__1__rendered_path__70__rendered_path__75__rendered_path__76__rendered_path__80__rendered_path__72__rendered_path__82__rendered_path__83__rendered_path__83__rendered_path__82__rendered_path__84__rendered_path__66__rendered_path__66__rendered_path__66__rendered_path__66__rendered_path__89__rendered_path__66__rendered_path__66__rendered_path__66__rendered_path__66__rendered_path__84__rendered_path__70__rendered_path__70__rendered_path__70__rendered_path__70__rendered_path__98__rendered_path__99__rendered_path__100__rendered_path__101__rendered_path__102__rendered_path__103__rendered_path__101__rendered_path__104__rendered_path__105__rendered_path__98__rendered_path__106__rendered_path__73__rendered_path__107__rendered_path__77__rendered_path__107__rendered_path__79__rendered_path__106__rendered_path__81
© 2006-2029 aprenderaprogramar.com

Page 193
Construcción de tablas de variables.
Para ello pdemos escribir el siguiente código:
Código versiones menos recientes VB: Código versiones más recientes VB:
Verificación de algoritmos en Visual Basic.
__rendered_path__4
'Curso VB aprenderaprogramar.com
Option Explicit
Dim i%, j As Integer
Dim A As Integer
Private Sub Form_Load()
Label1 = "": Label2 = "": Label3 = ""
Label1 = "Paso bucle 01" & vbCrLf
Label2 = "Paso bucle 02 (j)" & vbCrLf
Label3 = "Valor de A" & vbCrLf
For i = 1 To 5
For j = 1 To 5
A = i * j
Label1 = Label1 & " " & i & vbCrLf
Label2 = Label2 & " " & j & vbCrLf
Label3 = Label3 & " " & A & vbCrLf
Next j
Next i
End Sub
Con un resultado gráfico tal como este:
© 2006-2029 aprenderaprogramar.com
Image_2341_0
Image_2369_0
REM Curso Visual Basic aprenderaprogramar.com
Image_2368_0
Option Explicit On
Public Class Form1
Private Sub Form1_Load(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles MyBase.Load
Dim i, j As Integer
Dim A As Integer
Label1.Text = "" : Label2.Text = "" : Label3.Text = ""
Label1.Text = "Paso bucle 01" & vbCrLf
Label2.Text = "Paso bucle 02 (j)" & vbCrLf
Label3.Text = "Valor de A" & vbCrLf
For i = 1 To 5
For j = 1 To 5
A = i * j
Label1.Text = Label1.Text & " " & i & vbCrLf
Label2.Text = Label2.Text & " " & j & vbCrLf
Label3.Text = Label3.Text & " " & A & vbCrLf
Next j
Next i
End Sub
End Class
__rendered_path__1Image_2370_0Image_2344_0__rendered_path__33Image_2342_0__rendered_path__55

Page 194
Image_2341_0
Verificación de algoritmos en Visual Basic. Construcción de tablas de variables.
__rendered_path__4
Hemos utilizado para mostrar un resultado un Label, pero también podríamos haberlo hecho sobre un
TextBox. ¿Por qué? No hay motivo por el cual usar un Label sea obligatorio. Cada cual lo hará como lo
estime conveniente. Nosotros usamos normalmente Labels para mostrar resultados, pero en algunos
casos, por ejemplo si nos interesa poder copiar y pegar un texto, usamos TextBox.
Supongamos un programa que contiene el doble bucle que hemos visto. Hemos querido verificarlo y lo
hemos hecho con esta visualización. Una vez estamos satisfechos del resultado del bucle, borramos la
verificación que hemos utilizado para visualizar y seguimos trabajando tranquilos, sabemos que el bucle
no va a producir efectos indeseados.
En ocasiones nos interesa obtener un resultado en forma de tabla de variables que podamos exportar
por ejemplo a un procesador de textos. Una forma de hacerlo sería programándolo, pero también
podemos hacer que los resultados se presenten sobre un TextBox como hemos indicado antes y a partir
de ahí lo único que tenemos que hacer es copiar (Ctrl + C) y pegar (Ctrl + V). Vamos a ver este caso en
código. Primeramente crearemos un TextBox y en la ventana de propiedades establecemos Multiline =
True y Scrollbars = 3 (Both).
Código versiones menos recientes VB: Código versiones más recientes VB
Image_2375_0
'Curso VB aprenderaprogramar.com
REM Curso Visual Basic aprenderaprogramar.com
Image_2374_0
Option Explicit
Option Explicit On
Dim i%, j As Integer
Public
Class
Form1
Dim A As Integer
Private Sub Form1_Load(ByVal sender As System.Object,
Dim Espacios As String
ByVal e As System.EventArgs) Handles MyBase.Load
Private Sub Form_Load()
Dim
Dim
i, j
A
As
As
Integer
Integer
Espacios = " "
Dim Espacios As String
Text1 = "Paso bucle 01 " & " Paso bucle
02 (j) " & " Valor de A" & vbCrLf
Espacios = " "
For i = 1 To 5
TextBox1.Text = "Paso bucle 01 " & " Paso bucle
For j = 1 To 5
02 (j) "
&
For
" Valor de A"
i = 1
To
5
& vbCrLf
A = i * j
For j = 1 To 5
Text1 = Text1 & " " & i &
A = i * j
Espacios & j & Espacios & A & vbCrLf
TextBox1.Text = TextBox1.Text & " " &
Next j
i & Espacios & j & Espacios & A & vbCrLf
Next i
Next j
End Sub
End
Next
Sub
i
End Class
Image_2344_0__rendered_path__58
Image_2342_0__rendered_path__82
Si Multiline no está establecido en True nos saldrá el resultado en una sola línea. El resultado es la ya
conocida tabla, pero con este código en formato "capturable" en el portapapeles, de modo que
podemos por ejemplo pasarlo a una hoja de cálculo.
Próxima entrega: CU00348A
Acceso al curso completo en aprenderaprogramar.com -- > Cursos, o en la dirección siguiente:
http://www.aprenderaprogramar.com/index.php?option=com_content&view=category&id=37&Itemid=61
__rendered_path__1__rendered_path__54
© 2006-2029 aprenderaprogramar.com

Page 195
Image_2384_0
Programación rápida. Verificar algoritmos en Visual Basic. Recargar formularios.
__rendered_path__5
PROGRAMACIÓN RÁPIDA. VERIFICACIÓN DE ALGORITMOS EN VISUAL BASIC.
La programación rápida busca verificar el funcionamiento de los algoritmos antes de entrar en aspectos
más formales, como pueden ser la estética, comentarios, etc. La programación rápida puede ser
entendida de distintas maneras según los criterios de cada programador. Algunas prácticas de
programación rápida pueden ser las siguientes:
Se usa el formato de salida por pantalla más sencillo posible. En nuestro caso usaremos Labels,
TextBox ó msgBox.
No se piden datos al usuario. La entrada de datos es controlada directamente por el programador,
bien usando la instrucción Rnd para generar datos aleatorios o disponiendo una entrada de valores a
variables directa, controlada por el programador.
La estructura del programa no es la definitiva, con los diferentes módulos o procedimientos que
pueda llevar, sino provisional.
Vamos a ver un ejemplo de lo que sería programación rápida aplicada al código que se muestra a
continuación (Programa SUC02), relativo al cálculo de un sumatorio del tipo:
0 , ... ,2a ,1a ,a
__rendered_path__1__rendered_path__43__rendered_path__44__rendered_path__45__rendered_path__46__rendered_path__47__rendered_path__48__rendered_path__43__rendered_path__44__rendered_path__49__rendered_path__43__rendered_path__47__rendered_path__45
© 2006-2029 aprenderaprogramar.com

Page 196
rgar formularios.
Código versiones menos recientes VB: Código versiones más recientes VB:
Programación rápida. Verificar algoritmos en Visual Basic. Reca
__rendered_path__5
Image_2409_0
'Curso VB aprenderaprogramar.com
'Programa SUC02
Option Explicit
Dim Dato As Single
Dim Raíz01!, Raíz02 As Single
Dim Suce As Single
Private Sub Form_Load()
Form1.Caption = "Programa SUC02"
CommandCálculo.Caption = "Cálculo"
CommandSalir.Caption = "Salir"
End Sub
Private Sub CommandSalir_Click()
Unload Form1
End
End Sub
Private Sub CommandCálculo_Click()
Call EntraDatos
Call Proceso(Dato)
Call Resultados
End Sub
Private Sub EntraDatos()
Do
Dato = CInt(InputBox("Por favor, introduzca
nº entero entre 0 y 100", "Dato"))
Loop While Dato < 0 Or Dato > 100
End Sub
Private Sub Proceso(ByVal Num As
Integer)
Raíz01 = Sqr(Num)
Raíz02 = -Raíz01
Suce = 0
Do While Num >= 0
Suce = Suce + Sqr(Num)
Num = Num - 1
Loop
End Sub
Private Sub Resultados()
Label1.Alignment = 2
Label1.FontBold = True
Label1 = "Dato base = " & Dato & vbCrLf &
vbCrLf & " Raíz01 = " & Raíz01 & " Raíz02 =" &
Raíz02 & vbCrLf & vbCrLf & "Valor sucesión = "
& Suce
End Sub
Image_2408_0
__rendered_path__13
© 2006-2029 aprenderaprogramar.com
Image_2384_0
REM Curso Visual Basic aprenderaprogramar.com
Image_2407_0
'Programa SUC02
Option Explicit On
Public Class Form1
Dim Dato As Single
Dim Raíz01 As Single, Raíz02 As Single
Dim Suce As Single
Private Sub Form1_Load(ByVal sender As
System.Object, ByVal e As System.EventArgs) Handles
MyBase.Load
Me.Text = "Programa SUC02"
ButtonCálculo.Text = "Cálculo"
ButtonSalir.Text = "Salir"
Label1.Text = ""
End Sub
Private Sub ButtonSalir_Click(ByVal sender As
System.Object, ByVal e As System.EventArgs) Handles
ButtonSalir.Click
Me.Close()
End
End Sub
Private Sub ButtonCálculo_Click(ByVal sender As
System.Object, ByVal e As System.EventArgs) Handles
ButtonCálculo.Click
Call EntraDatos()
Call Proceso(Dato)
Call Resultados()
End Sub
Private Sub EntraDatos()
Do
Dato = CInt(InputBox("Por favor,
introduzca nº entero entre 0 y 100", "Dato"))
Loop While Dato < 0 Or Dato > 100
End Sub
Private Sub Proceso(ByVal Num As Integer)
Raíz01 = Math.Sqrt(Num)
Raíz02 = -Raíz01
Suce = 0
Do While Num >= 0
Suce = Suce + Math.Sqrt(Num)
Num = Num - 1
Loop
End Sub
Private Sub Resultados()
Label1.TextAlign = ContentAlignment.MiddleCenter
Label1.Font = New Font("Arial", 10, FontStyle.Bold)
Label1.Text = "Dato base = " & Dato & vbCrLf &
vbCrLf & " Raíz01 = " & Raíz01 & " Raíz02 =" &
Raíz02 & vbCrLf & vbCrLf & "Valor sucesión = " &
Suce
End Sub
End Class
__rendered_path__1Image_2406_0__rendered_path__67

Page 197
Visual Basic. Reca
SOLUCIÓN CÓDIGO DE PROGRAMACIÓN RÁPIDA
Código versiones menos recientes VB: Código versiones más recientes VB:
cidente con el que obtuvimos en el
opuso en el citado ejercicio está en que:
ados con la estética del programa
de formulario "Programa SUC02". Ya en los pr
Programación rápida. Verificar algoritmos en
__rendered_path__5
'Curso VB aprenderaprogramar.com
Image_2427_0
'Preliminar SUC02
Option Explicit
Dim Datobase!, Dato!, Raíz01!, Raíz02!,
Suce As Single
Private Sub Form_Load()
Label1 = “”
Datobase = 85 '[Línea de introducción
manual de datos]
Rem Randomize: Datobase = Cint(Rnd *
100 + 1) '[Línea de generación _
aleatoria de datos, actualmente
desactivada]
Dato = Datobase
Raíz01 = Sqr(Dato)
Raíz02 = -Raíz01
Suce = 0
Do While Dato > = 0
Suce = Suce + Sqr(Dato)
Dato = Dato - 1
Loop
Label1 = Label1 & "Dato base = " &
Datobase & vbCrLf & "Raíz01 = " & Raíz01
& " Raíz02 = " & Raíz02 & vbCrLf & "
Valor sucesión = " & Suce
End Sub
El resultado de este código es coin
creamos el programa, es decir:
Datobase = 85
Raíz 01 = 9,219544 Raíz 02 = -9,219544
Valorsucesión = 526,8474
La diferencia respecto al código que se pr
Se han eliminado aspectos relacion
© 2006-2029 aprenderaprogramar.com
Image_2384_0
rgar formularios.
Image_2426_0
REM Curso Visual Basic aprenderaprogramar.com
'Preliminar SUC02
Option Explicit On
Public Class Form1
Dim Datobase, Dato, Raíz01, Raíz02, Suce As Single
Private Sub Form1_Load(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles MyBase.Load
Label1.Text = ""
Datobase = 85 '[Línea introducción manual de datos]
REM generación aleatoria de datos desactivada]
'Randomize() : Datobase = CInt(Rnd() * 100 + 1)
Dato = Datobase
Raíz01 = Math.Sqrt(Dato)
Raíz02 = -Raíz01
Suce = 0
Do While Dato >= 0
Suce = Suce + Math.Sqrt(Dato)
Dato = Dato - 1
Loop
Label1.Text = Label1.Text & "Dato base = " &
Datobase & vbCrLf & "Raíz01 = " & Raíz01 & " Raíz02
= " & Raíz02 & vbCrLf & " Valor sucesión = " & Suce
End Sub
End Class
Image_2408_0Image_2406_0
ejercicio de referencia donde
__rendered_path__15__rendered_path__41__rendered_path__72
como que se muestre un título
__rendered_path__1Image_2425_0
ogramas que venimos desarrollando la atención a

Page 198
Image_2384_0
Programación rápida. Verificar algoritmos en Visual Basic. Recargar formularios.
__rendered_path__5
cuestiones estéticas es más bien escasa, pero para la verificación de un algoritmo nos olvidamos
completamente de ellas.
La estructura del programa, que constaba de 2 opciones, Cálculo y Salir, con 3 procedimientos
asociados a la opción cálculo (EntraDatos, Proceso y Resultados) se ha eliminado, existiendo un
único código asociado a la carga del formulario por ser lo más rápido.
La petición de datos al usuario con un InputBox de tipo (Dato = CInt(InputBox("Por favor, introduzca
nº entero entre 0 y 100", "Dato")) se ha eliminado. A cambio, existen dos líneas con las que el
programador trabaja. Una en la que introduce datos manualmente y otra en las que genera datos
aleatoriamente. De este modo puede hacer tanto comprobaciones específicas como
comprobaciones aleatorias.
Las variables que intervienen no coinciden exactamente con las del programa definitivo.
El programador introducirá los cambios que le resulten de interés para la verificación del programa. Por
ejemplo, será habitual introducir un botón para que cada vez que sea pulsado se repita la muestra de
resultados (generando datos aleatorios). Para ello nos basta desactivar la introducción de datos
manual, activar la aleatoria e introducir un botón que se encargue de recargar el formulario. El código
sería el siguiente:
Código versiones menos recientes VB: Código versiones más recientes VB
Image_2436_0
'Curso VB aprenderaprogramar.com
REM Curso Visual Basic aprenderaprogramar.com
Image_2435_0
Private Sub CommandRepetir_Click()
Private Sub Button1_Click(ByVal sender As System.Object,
Form_Load
ByVal
e
As
Me
System.
.Form1_Load(
EventArgs
Me
,
)
New
Handles
System.
Button1.Click
EventArgs
)
End Sub
End Sub
Image_2408_0
__rendered_path__55Image_2406_0
__rendered_path__62
De este modo podemos llegar a resultados como el que se muestra a continuación:
__rendered_path__1Image_2437_0
© 2006-2029 aprenderaprogramar.com

Page 199
Image_2384_0
Programación rápida. Verificar algoritmos en Visual Basic. Recargar formularios.
__rendered_path__5
De una pantalla de este tipo un programador avezado puede obtener numerosa información respecto
al funcionamiento del algoritmo. Fijémonos por ejemplo en los resultados para dato base = 49. Las
raíces que nos da son 7 y -7. De ahí podemos intuir que el cálculo de raíces se está realizando
correctamente. La raíz esperada para 81 sería 9. Tenemos un dato base 82 con raíz 9,05, luego con
distintos datos parece que el cálculo de raíces es correcto. En cuanto a los sumatorios, podríamos
compararlos con datos de que dispongamos previamente para valorar su corrección, o incluso
valorarlos comparativamente. Podemos esperar que el sumatorio para un dato base 79 sea similar
(ligeramente inferior) al de un dato base 82. Comprobamos que es así.
Si para un dato base 49 se nos mostraran raíces 5,05 y -5,05, o el sumatorio correspondiente a 79 fuera
superior a 82, estaríamos ante una situación de no superación de la verificación. Si se diera esta
circunstancia, tendríamos que apuntar los datos que nos están dando lugar a resultados erróneos,
revisar el algoritmo por si existen errores de sintaxis, trascripción, etc. e incluso modificar su diseño si
fuera necesario. Por último, cuando creamos que está funcionando razonablemente, introduciremos de
forma manual los datos que apuntamos en su momento como generadores de errores y
comprobaremos que para esos datos no hay problema ninguno.
Las propuestas de verificación que hemos visto se corresponden con la verificación funcional del
algoritmo, ya que mediante un número limitado de pruebas inferimos que su funcionamiento es
correcto. A su vez, para la entrada manual se supone que escogemos una serie de casos
representativos, lo que se correspondería con lo que hemos denominado verificación razonada. Por el
contrario, la ejecución del programa con datos de entrada generados con Randomize y Rnd se
correspondería con una verificación aleatoria.
La verificación total de este algoritmo consistiría en un programa que nos mostrara los resultados para
todos los valores posibles (enteros comprendidos entre 0 y 100), de forma que pudiéramos comprobar
la corrección de cada uno de ellos. Esto sería posible, pero en general supone un esfuerzo que se
considera no necesario ya que las verificaciones funcionales bien realizadas resultan rápidas y efectivas.
Además, en muchos casos una verificación completa es inviable, ya que en muchos problemas los
posibles datos de entrada son infinitos (por ejemplo, los números enteros).
Próxima entrega: CU00349A
Acceso al curso completo en aprenderaprogramar.com -- > Cursos, o en la dirección siguiente:
http://www.aprenderaprogramar.com/index.php?option=com_content&view=category&id=37&Itemid=61
__rendered_path__1__rendered_path__72
© 2006-2029 aprenderaprogramar.com

Page 200
Image_2451_0
Paso a paso y puntos de interrupción breakpoints en Visual Basic.
__rendered_path__5
PASO A PASO Y PUNTOS DE INTERRUPCIÓN (BREAKPOINTS)
Visual Basic dispone de distintas opciones relacionadas con la ejecución paso a paso de un programa,
de las cuales vamos a ver una de ellas: los puntos de interrupción. Se entiende por punto de
interrupción una línea del programa donde el programador decide detener la ejecución. El objetivo será
comprobar qué valor tienen las variables, qué resultados se han obtenido por pantalla hasta el
momento, etc. y de esta forma comprobar si el programa hasta ese momento está haciendo lo que se
espera.
Una vez posicionado el cursor sobre la línea en que queremos detener el programa, hay cuatro
maneras de establecer puntos de interrupción:
a) En el menú Depuración (Depurar), elige la opción alternar puntos de interrupción.
b) Pulsa F9.
c) Pulsa el botón derecho del ratón y elige Punto de interrupción – Insertar punto de interrupción ó
Alternar - Puntos de interrupción (según versión de Visual Basic que estés utilizando).
d) Sobre la banda gris que está en el lateral izquierdo de la ventana de código, pincha con el ratón a la
altura de la línea en que quieres establecer un punto de interrupción.
En cualquiera de los casos, el resultado será que la línea elegida aparecerá subrayada en rojo y con un
punto rojo en su lado izquierdo. El aspecto del editor será similar al mostrado a continuación (aunque
depende de la versión de Visual Basic que estemos utilizando).
Image_2452_0
__rendered_path__1
© 2006-2029 aprenderaprogramar.com

Page 201
Image_2451_0
Paso a paso y puntos de interrupción breakpoints en Visual Basic.
__rendered_path__5
Vamos a suponer que estamos trabajando con el programa 'Preliminar SUC02' cuyo código hemos visto
en la entrega anterior de este curso de Visual Basic de aprenderaprogramar.com, y que establecemos
un punto de interrupción o breakpoint en la línea Suce = Suce + Math.Sqrt(dato) ó Suce = Suce +
Sqr(Dato) según versión, dentro del bucle Do While.
Si ejecutas el programa (p.ej. pulsando F5), comprobarás que el programa se detiene, indicando con
una flecha amarilla que se encuentra detenido al llegar a la línea que hemos indicado como punto de
interrupción. Comprueba ahora cómo si posicionas el puntero del ratón sobre una variable, por ejemplo
Suce, Visual Basic te muestra el valor que tiene la variable Suce justo en ese momento.
Image_2469_0
__rendered_path__71
Para continuar ejecutando el programa se ha de pulsar el icono de ejecución (o pulsar F5 nuevamente),
y el programa continuará hasta encontrarse nuevamente con un punto de interrupción. Ten en cuenta
que un punto de interrupción dentro de un bucle detendrá el programa tantas veces como se ejecute el
bucle.
Igual que para variables situadas sobre la línea de interrupción, puedes consultar el valor de variables
en otras líneas. Ten en cuenta que el valor mostrado es siempre el valor de las variables antes de
ejecutar la línea de interrupción. Por eso en la primera interrupción nos indica que Suce vale 0. Si
quisiéramos saber el valor de las variables justo después de ejecutarse esa línea, es decir, qué valor ha
adquirido Suce, podemos hacerlo de dos maneras. La primera, sumando los valores actuales a la
derecha de la igualdad. La segunda, estableciendo la interrupción en la línea inmediatamente posterior
a aquella línea que queremos evaluar. En nuestro caso podríamos establecer la interrupción en la línea
Dato = Dato – 1 de modo que en esta línea podemos comprobar el valor que ha tomado Suce después
de ejecutada la línea anterior:
Image_2468_0
__rendered_path__73
Para un dato base igual a 85, el primer valor de Suce tras ejecutarse la línea es 9,219544. Para realizar
este tipo de interpretación hemos establecido la interrupción en la línea inmediata posterior a aquella
que nos resulta de interés. Comprueba cómo va variando el valor de Suce con cada paso por el bucle y
razona si los valores que va tomando son correctos o no.
Se pueden establecer tantos puntos de interrupción como se estimen oportunos. Normalmente irán
colocados en lugares que el programador estima estratégicos para sus intenciones como pueden ser:
antes de entrar a un bucle, en el interior de un bucle, tras salir de un bucle, etc.
__rendered_path__1
© 2006-2029 aprenderaprogramar.com

Page 202
Image_2451_0
Paso a paso y puntos de interrupción breakpoints en Visual Basic.
__rendered_path__5
Un punto de interrupción se elimina de la misma manera que se puso: si estando sobre una línea
marcada pulsamos F9 o elegimos alternar puntos de interrupción, será desactivada. También podemos
suprimir todos los puntos de interrupción existentes a través de una opción más avanzada.
__rendered_path__19
Ex isten otras formas de paso a paso con Visual Basic como son: Paso a Paso por instrucciones
__rendered_path__20
(F8), Paso a Paso por Procedimientos (Mayús + F8), o Ejecutar hasta el cursor (Ctrl + F8).
__rendered_path__16__rendered_path__19
Ex isten muchas más opciones de configuración y posibilidades para la depuración de programas con
__rendered_path__21
Visual Basic. Ten en cuenta que con aplicaciones profesionales, largas y ex tensas, pueden ex istir miles
__rendered_path__21
de líneas de código. Los programadores profesionales utilizan las herramientas de depuración
__rendered_path__22__rendered_path__46__rendered_path__48
disponibles para detectar y corregir errores en el código.
__rendered_path__25__rendered_path__47__rendered_path__49
__rendered_path__25
__rendered_path__22
__rendered_path__25
Próxima entrega: CU00350A
__rendered_path__25
__rendered_path__22
Acceso al curso completo en aprenderaprogramar.com -- > Cursos, o en la dirección siguiente:
__rendered_path__25
http://www.aprenderaprogramar.com/index.php?option=com_content&view=category&id=37&Itemid=61
__rendered_path__1__rendered_path__25__rendered_path__22__rendered_path__25__rendered_path__25__rendered_path__30__rendered_path__19__rendered_path__20__rendered_path__19__rendered_path__32__rendered_path__32__rendered_path__44__rendered_path__50__rendered_path__51__rendered_path__52__rendered_path__53
© 2006-2029 aprenderaprogramar.com

Page 203
Image_2486_0
Enfoques para verificar programas en Visual Basic: depuración.
__rendered_path__5
DEPURAR ALGORITMOS
Vamos a reflejar en forma de código enfoques para la verificación de algoritmos. Partimos del siguiente
bucle ejemplo:
Image_2491_0
For i = a To b
For j = m To n
R = i * j
Next j
Next i
Image_2490_0
__rendered_path__75
Los enfoques para depurar el algoritmo los podemos establecer a partir de puntos de interrupción. Sin
embargo, en general es más rápido hacer una simple constatación del valor de variables que establecer
una interrupción del programa, ya que por cada parada estaremos perdiendo un tiempo. Con este
razonamiento, usaremos un Label para dejar constancia del valor de una variable en un punto dado del
programa. Sólo cuando no seamos capaces de llegar a conclusiones sin tener que detener el programa,
estableceremos puntos de interrupción.
Enfoque al resultado
__rendered_path__38
Nos centramos en comprobar un valor final, en este caso R, suponiendo que si este valor es correcto el
resto de procesos también lo son. Por ejemplo:
Código versiones menos recientes VB: Código versiones más recientes VB:
Image_2489_0
'Curso VB aprenderaprogramar.com
R
EM Curso Visual Basic aprenderaprogramar.com
Image_2487_0
Option Explicit
Dim i%, j%
Option Explicit On
Public
Class
Form1
Dim a%, b%
Dim m%, n%
Dim R%
Private
ByVal
e
Sub
As
Dim
Form1_Load(
System.
EventArgs
i%, j%
ByVal
sender
)
Handles
As
System.
MyBase
.Load
Object
,
Dim
a%, b%
Private Sub Form_Load()
Dim
Dim
m%, n%
R%
Label1 = ""
Label1.Text =
""
a = 1: b = 3: m = 1: n = 3
For i = a To b
For j = m To n
R = i * j
a = 1 : b = 3 : m = 1 : n = 3
For
i = a
To
b
For
j = m
To
n
R = i * j
Label1 = Label1 & R & vbCrLf
Label1.Text = Label1.Text & R & vbCrLf
Next
j
Next j
Next i
Next i
End Sub
End
End
Class
Sub
Image_2488_0
__rendered_path__84Image_2490_0
__rendered_path__105
En el programa anterior hemos verificado qué valor toma R en cada pasada del bucle. El objetivo del
bucle va a ser transferir el valor de R a otros procesos, pero antes de hacer eso hemos querido
comprobar qué resultado era el que obteníamos con este diseño de bucle.
__rendered_path__1
© 2006-2029 aprenderaprogramar.com

Page 204
Image_2486_0
Enfoques para verificar programas en Visual Basic: depuración.
__rendered_path__5
Enfoque al proceso
__rendered_path__11
Analizamos qué ocurre en uno o varios pasos del programa que resultan de nuestro interés, estudiando
los valores que van tomando las variables. Por ejemplo:
Código versiones menos recientes VB: Código versiones más recientes VB:
Image_2518_0
'Curso VB aprenderaprogramar.com
REM Curso Visual Basic aprenderaprogramar.com
Image_2517_0
Option Explicit
Option Explicit On
Dim i%, j%
Public
Class
Form1
Dim a%, b%
Private Sub Form1_Load(ByVal sender As System.Object,
Dim m%, n%
ByVal e As System.EventArgs) Handles MyBase.Load
Private Sub Form_Load()
Dim i%, j%
Label1 = ""
Dim
Dim
a%, b%
m%, n%
a = 1: b = 3: m = 1: n = 3
Label1 = Label1 & "a = " & a & " b = " & b &
Label1.Text = ""
vbCrLf
a = 1 : b = 3 : m = 1 : n = 3
For i = a To b
Label1.Text = Label1.Text & "a =" & a & " b =" & b &
Label1 = Label1 & "m = " & m & " n = " &
vbCrLf
For
i = a
To
b
n & " i = " & i & vbCrLf
Label1.Text = Label1.Text & "m =" & m & " n =" & n
For j = m To n
& " i =" & i & vbCrLf
Label1 = Label1 & "j = " & j & vbCrLf
For j = m To n
Next j
Label1.Text = Label1.Text & "j =" & j & vbCrLf
Next i
End Sub
Next
End
Next
i
Sub
j
End Class
Image_2488_0
__rendered_path__48Image_2490_0
__rendered_path__86
Este programa da lugar a que se nos muestre lo siguiente:
a = 1 b = 3
m = 1 n = 3 i = 1
j = 1
j = 2
j = 3
m = 1 n = 3 i = 2
j = 1
j = 2
j = 3
m = 1 n = 3 i = 3
j = 1
j = 2
j = 3
__rendered_path__69
A partir de estos valores de variables el programador analiza si el programa está respondiendo a lo que
él tenía previsto o si se está produciendo un resultado indeseado. En caso de detectar algún error,
procede a la corrección y a una nueva prueba.
__rendered_path__1
© 2006-2029 aprenderaprogramar.com

Page 205
Image_2486_0
Enfoques para verificar programas en Visual Basic: depuración.
__rendered_path__5
Enfoques zonales
__rendered_path__11
Analizamos qué ocurre en una zona de código donde estimamos ocurren procesos de interés o donde
pensamos que puede existir un problema. Siguiendo con nuestro ejemplo, un enfoque zonal a la
entrada del bucle sería:
Código versiones menos recientes VB: Código versiones más recientes VB:
Image_2525_0
'Curso VB aprenderaprogramar.com
REM Curso Visual Basic aprenderaprogramar.com
Image_2524_0
Option Explicit
Option Explicit On
Public
Class
Form1
Dim i%, j%
Private Sub Form1_Load(ByVal sender As System.Object,
Dim a%, b%, m%, n%, R%
ByVal e As System.EventArgs) Handles MyBase.Load
Private Sub Form_Load()
Dim i%, j%
Label1 = ""
Dim
a%, b%, m%, n%, R%
a = 1: b = 3: m = 1: n = 3
Label1.Text = ""
Label1 = Label1 & "a = " & a & " b = " &
a = 1 : b = 3 : m = 1 : n = 3
b & vbCrLf
Label1.Text = Label1.Text & "a = " & a & " b =
Label1 = Label1 & "m = " & m & " n = " &
" & b & vbCrLf
n & vbCrLf
Label1.Text = Label1.Text &
"
& n & vbCrLf
"m = "
& m &
" n =
Label1 = Label1 & "i = " & i & " j = " & j &
Label1.Text = Label1.Text & "i = " & i & " j =
vbCrLf
" & j & vbCrLf
Label1 = Label1 & "R = " & R & vbCrLf
Label1.Text = Label1.Text & "R = " & R &
For i = a To b
vbCrLf
For j = m To n
For
i = a
For
To
j = m
b
To
n
R = i * j
R = i * j
Label1 = Label1 & R & " ,"
Label1.Text = Label1.Text & R & " ,"
Next j
Next j
Next i
Next i
End Sub
End
End
Class
Sub
Image_2488_0
__rendered_path__53Image_2490_0
__rendered_path__88
El resultado obtenido es:
a = 1 b = 3
m = 1 n = 3
i = 0 j = 0
R = 0
1, 2, 3, 2, 4, 6, 3, 6, 9
__rendered_path__79
Se han verificado todas las variables a la entrada del bucle. Algunas no tiene demasiada lógica que se
verifiquen, pero a veces los errores saltan donde menos son de esperar, y toda información es valiosa.
Próxima entrega: CU00351A
Acceso al curso completo en aprenderaprogramar.com -- > Cursos, o en la dirección siguiente:
http://www.aprenderaprogramar.com/index.php?option=com_content&view=category&id=37&Itemid=61
__rendered_path__1__rendered_path__49
© 2006-2029 aprenderaprogramar.com

Page 206
Image_2534_0
Ejemplo de tablas de variables para verificar un algoritmo en Visual Basic.
__rendered_path__5
EJERCICIO RESUELTO
Se ha previsto un programa donde se incluye un bucle que se pretende probar para comprobar que su
funcionamiento es correcto. Para los valores emp = 1, emp = 0, emp = 1, emp = 4, emp = 7 y emp = 10
construir las tablas de variables que describen el funcionamiento del siguiente bucle:
__rendered_path__25
i = emp
__rendered_path__24__rendered_path__27
Mientras i <= 7 Hacer
__rendered_path__17__rendered_path__26
i = i + 2
__rendered_path__17__rendered_path__24
Mostrar “2 * i vale”, 2 * i
__rendered_path__17
Repetir
__rendered_path__16__rendered_path__17
__rendered_path__22
__rendered_path__28
__rendered_path__25
__rendered_path__28
SOLUCIÓN
__rendered_path__27
Versiones menos recientes de VB:
Versiones más recientes de VB:
Image_2538_0
'Curso VB aprenderaprogramar.com
REM Curso Visual Basic aprenderaprogramar.com
Image_2536_0
Option Explicit
Option Explicit On
Dim i%, emp%, iteración%
Public Class Form1
Private Sub Form_Load()
Private
System.
MyBase
Object
.Load
Sub
Form1_Load(
,
ByVal
e
ByVal
As
System.
sender
As
EventArgs
)
Handles
Label1 = ""
Dim i%, emp%, iteración%
emp = Val(InputBox("Valor de emp="))
Label1.Text =
emp = Val(InputBox(
""
"Valor de emp="
))
i = emp: iteración = 0
i = emp : iteración = 0
Label1 = Label1 & "Previo a bucle i =" & i &
vbCrLf
Label1.Text = Label1.Text &
i & vbCrLf
Do
While
i <= 7
"Previo a bucle i ="
&
Do While i <= 7
iteración = iteración + 1
iteración = iteración + 1
i = i + 2
Label1.Text = Label1.Text &
" iteración ="
&
i = i + 2
iteración & " i =" & i & " Visualización:" & 2 * i
Label1 = Label1 & " iteración =" & iteración &
& vbCrLf
Loop
" i =" & i & " Visualización:" & 2 * i & vbCrLf
End Sub
Loop
End Sub
Private
System.
Object
Sub
BotonRepetir_Click(
,
ByVal
e
As
System.
ByVal
EventArgs
sender
)
As
Handles
BotonRepetir.Click
Private Sub BotonRepetir_Click()
End
Sub
Me
.Form1_Load(
Me
,
New
System.
EventArgs
)
Form_Load
End Class
End Sub
Image_2537_0
__rendered_path__48Image_2535_0
__rendered_path__72
El programa nos permite visualizar tantas tablas de variables como queramos pulsando un botón
(button). En cada ocasión se nos pide el valor de emp a través de un InputBox.
Comprueba los resultados consultando las siguientes tablas.
__rendered_path__1
© 2006-2029 aprenderaprogramar.com

Page 207
Ejemplo de tablas de variables para ve
rificar un algoritmo en Visual Basic.
Tablas:
Visualización
Visualización
Previo a bucle
Visualización
Previo a bucle
© 2006-2029 aprenderaprogramar.com
__rendered_path__5
__rendered_path__17__rendered_path__125
emp = 1
__rendered_path__119__rendered_path__126
Estado
__rendered_path__120
Previo a bucle
__rendered_path__114
Iteración 1
__rendered_path__54__rendered_path__17__rendered_path__31
Iteración 2
__rendered_path__55__rendered_path__32
Iteración 3
__rendered_path__52
Iteración 4
__rendered_path__134__rendered_path__23__rendered_path__44__rendered_path__45
Iteración 5
__rendered_path__18__rendered_path__46
emp = 0
__rendered_path__12__rendered_path__17__rendered_path__146
Estado
__rendered_path__13__rendered_path__19__rendered_path__54__rendered_path__44__rendered_path__45
Iteración 1
__rendered_path__21__rendered_path__55__rendered_path__46
Iteración 2
__rendered_path__22__rendered_path__17__rendered_path__31__rendered_path__52
Iteración 3
__rendered_path__23__rendered_path__32__rendered_path__22__rendered_path__44__rendered_path__45
Iteración 4
__rendered_path__21__rendered_path__23__rendered_path__46
emp = 1
__rendered_path__22__rendered_path__44__rendered_path__45__rendered_path__21
Estado
__rendered_path__23__rendered_path__46__rendered_path__22__rendered_path__44__rendered_path__45
Iteración 1
__rendered_path__52__rendered_path__23__rendered_path__46
Iteración 2
__rendered_path__54__rendered_path__44__rendered_path__45__rendered_path__52
Iteración 3
__rendered_path__55__rendered_path__46__rendered_path__54__rendered_path__44__rendered_path__45
Iteración 4
__rendered_path__87
i
__rendered_path__57__rendered_path__33
1
__rendered_path__58__rendered_path__34
1
__rendered_path__88
3
__rendered_path__53
5
__rendered_path__136__rendered_path__47__rendered_path__94
7
__rendered_path__137__rendered_path__95
9
__rendered_path__35__rendered_path__147
i
__rendered_path__25__rendered_path__33__rendered_path__57__rendered_path__47__rendered_path__94
0
__rendered_path__26__rendered_path__34__rendered_path__58__rendered_path__95
2
__rendered_path__36__rendered_path__53
4
__rendered_path__39__rendered_path__25__rendered_path__47__rendered_path__94
6
__rendered_path__25__rendered_path__47__rendered_path__48__rendered_path__26__rendered_path__95
8
__rendered_path__26__rendered_path__49__rendered_path__39
i
__rendered_path__53__rendered_path__25__rendered_path__47__rendered_path__94
1
__rendered_path__57__rendered_path__47__rendered_path__48__rendered_path__26__rendered_path__95
3
__rendered_path__58__rendered_path__49__rendered_path__53
5
__rendered_path__53__rendered_path__57__rendered_path__47__rendered_path__94
7
__rendered_path__25__rendered_path__47__rendered_path__48__rendered_path__58__rendered_path__95
9
Image_2534_0
__rendered_path__17__rendered_path__20
2
__rendered_path__114
6
__rendered_path__129__rendered_path__33__rendered_path__132
10
__rendered_path__130__rendered_path__34
14
__rendered_path__133
18
__rendered_path__17__rendered_path__20__rendered_path__17
__rendered_path__21__rendered_path__53
4
__rendered_path__28__rendered_path__33__rendered_path__37__rendered_path__52
8
__rendered_path__29__rendered_path__34__rendered_path__141__rendered_path__142__rendered_path__47__rendered_path__144
12
__rendered_path__38__rendered_path__145
16
__rendered_path__17__rendered_path__44
__rendered_path__39__rendered_path__147
6
__rendered_path__21__rendered_path__146
10
__rendered_path__28__rendered_path__47__rendered_path__50__rendered_path__129__rendered_path__47__rendered_path__144
14
__rendered_path__1__rendered_path__29__rendered_path__51__rendered_path__44__rendered_path__53__rendered_path__52__rendered_path__60__rendered_path__61__rendered_path__47__rendered_path__50__rendered_path__51__rendered_path__44__rendered_path__52__rendered_path__53__rendered_path__52__rendered_path__22__rendered_path__23__rendered_path__26__rendered_path__28__rendered_path__29__rendered_path__44__rendered_path__45__rendered_path__46__rendered_path__49__rendered_path__47__rendered_path__50__rendered_path__51__rendered_path__44__rendered_path__21__rendered_path__39__rendered_path__39__rendered_path__21__rendered_path__22__rendered_path__23__rendered_path__25__rendered_path__26__rendered_path__28__rendered_path__29__rendered_path__44__rendered_path__45__rendered_path__46__rendered_path__47__rendered_path__48__rendered_path__49__rendered_path__47__rendered_path__50__rendered_path__51__rendered_path__44__rendered_path__52__rendered_path__53__rendered_path__53__rendered_path__52__rendered_path__22__rendered_path__23__rendered_path__25__rendered_path__26__rendered_path__28__rendered_path__29__rendered_path__44__rendered_path__45__rendered_path__46__rendered_path__47__rendered_path__48__rendered_path__49__rendered_path__47__rendered_path__50__rendered_path__51__rendered_path__44__rendered_path__72__rendered_path__73__rendered_path__39__rendered_path__35__rendered_path__39__rendered_path__37__rendered_path__72__rendered_path__20__rendered_path__75__rendered_path__76__rendered_path__17__rendered_path__80__rendered_path__81__rendered_path__17__rendered_path__20__rendered_path__21__rendered_path__21__rendered_path__22__rendered_path__23__rendered_path__25__rendered_path__26__rendered_path__84__rendered_path__85__rendered_path__17__rendered_path__31__rendered_path__32__rendered_path__33__rendered_path__34__rendered_path__87__rendered_path__88__rendered_path__33__rendered_path__34__rendered_path__89__rendered_path__90__rendered_path__17__rendered_path__21__rendered_path__39__rendered_path__39__rendered_path__21__rendered_path__22__rendered_path__23__rendered_path__25__rendered_path__26__rendered_path__84__rendered_path__85__rendered_path__44__rendered_path__45__rendered_path__46__rendered_path__47__rendered_path__94__rendered_path__95__rendered_path__47__rendered_path__96__rendered_path__97__rendered_path__44__rendered_path__52__rendered_path__53__rendered_path__53__rendered_path__52__rendered_path__54__rendered_path__55__rendered_path__57__rendered_path__58__rendered_path__100__rendered_path__101__rendered_path__44__rendered_path__45__rendered_path__46__rendered_path__47__rendered_path__94__rendered_path__95__rendered_path__47__rendered_path__96__rendered_path__97__rendered_path__44__rendered_path__52__rendered_path__53__rendered_path__53__rendered_path__52__rendered_path__22__rendered_path__23__rendered_path__25__rendered_path__26__rendered_path__84__rendered_path__85__rendered_path__44__rendered_path__45__rendered_path__46__rendered_path__47__rendered_path__94__rendered_path__95__rendered_path__47__rendered_path__96__rendered_path__97__rendered_path__44__rendered_path__21__rendered_path__39__rendered_path__39__rendered_path__21__rendered_path__22__rendered_path__23__rendered_path__25__rendered_path__26__rendered_path__84__rendered_path__85__rendered_path__44__rendered_path__45__rendered_path__46__rendered_path__47__rendered_path__94__rendered_path__95__rendered_path__47__rendered_path__96__rendered_path__97__rendered_path__44__rendered_path__52__rendered_path__53__rendered_path__53__rendered_path__52__rendered_path__54__rendered_path__55__rendered_path__57__rendered_path__58__rendered_path__100__rendered_path__101__rendered_path__44__rendered_path__45__rendered_path__46__rendered_path__47__rendered_path__94__rendered_path__95__rendered_path__47__rendered_path__96__rendered_path__97__rendered_path__44__rendered_path__21__rendered_path__112__rendered_path__113__rendered_path__94__rendered_path__113__rendered_path__96__rendered_path__114__rendered_path__130__rendered_path__145__rendered_path__44__rendered_path__53__rendered_path__52__rendered_path__153__rendered_path__142__rendered_path__47__rendered_path__144__rendered_path__145__rendered_path__44__rendered_path__39__rendered_path__21__rendered_path__153__rendered_path__142__rendered_path__47__rendered_path__144__rendered_path__145__rendered_path__44__rendered_path__53__rendered_path__52__rendered_path__55__rendered_path__129__rendered_path__130__rendered_path__46__rendered_path__47__rendered_path__144__rendered_path__145__rendered_path__44__rendered_path__52__rendered_path__53__rendered_path__53__rendered_path__52__rendered_path__22__rendered_path__23__rendered_path__25__rendered_path__26__rendered_path__153__rendered_path__142__rendered_path__44__rendered_path__45__rendered_path__46__rendered_path__47__rendered_path__94__rendered_path__95__rendered_path__47__rendered_path__144__rendered_path__145__rendered_path__44__rendered_path__72__rendered_path__73__rendered_path__39__rendered_path__87__rendered_path__39__rendered_path__132__rendered_path__72__rendered_path__20
18