1. Universidad Capitán General Gerardo Barrios, SM. Guía Nº 3 - Computo II-10
Asignatura: Programación Computacional I Fecha: 07 de Septiembre de 2010
Docente: Lic. Marvin Antonio Romero Flores
Objetivo:
- Demostrar las formas más comunes de declarar variables y constantes, así como la realización de
conversiones.
- Demostrar el alcance de las variables y la forma en que preservan los valores.
Para la realización de esta guía se necesitará lo siguiente:
1. Guía de Práctica No. 1 y Nº 2
2. Computadora con software Microsoft Visual Basic.

2. Parte I:
Demostración del alcance de las variables y la forma en que
preservan valores (I)
En este ejercicio se comprobara la forma en que funcionan los alcances de variables en Visual Basic y
la forma en que podemos aprovechar su manejo para preservar valores en memoria con eficiencia.
1. Cree una solución en Blanco, llamada con su nombre Apellidos primero y Nombres después,
seguido de las palabras GUIA3, así: “romero flores marvin antonio Guia3”
2. Agregue a su solución un proyecto Windows – Aplicación de Consola, llamado ValRef.
3. Edite el programa de tal forma que aparezca como sigue:
4. Construya la solución (oprima las teclas Ctrl-Mayus-B, ó Clic Derecho sobre la solución y
seleccione Generar). Establezca el nuevo proyecto como proyecto de inicio (Clic derecho sobre el
proyecto, opción Establecer como Proyecto de inicio) y guarde todos los cambios que ha

3. realizado. en la solución (oprima las teclas Ctrl-Mayus-S). Inicie la depuración para comprobar el
comportamiento de su programa (Oprima F5).
5. Este programa es type safe, dado que todas las variables deberán declararse antes de ser
utilizadas (Option Explicit) y las conversiones tienen que hacerse de forma explícita (Option Strict).
6. El programa declara una variable de memoria, llamada Texto, que se verá sometida a
modificaciones en su contenido (línea 7); de initio, se le asigna un valor de Texto original, mismo
que es mostrado en la consola (línea 8). La variable será proporcionada como argumento a dos
procedimientos, uno de los cuales tratara el dato como valor (líneas 17 a la 20), y otro como
referencia (líneas 22 a la 25).
7. Uso del dato como tipo valor. En la línea 9 se proporciona la variable como argumento de un
procedimiento llamado Valor; dicho procedimiento recibe el valor y le da trata-miento como tipo
valor. En la línea 18 se modifica el valor de Texto, por Texto Valor, y se muestran los efectos del
cambio en la línea 19. Después de ejecutar Valor (), se muestra el contenido de la variable Texto
(línea 10); es posible observar que, aunque se modificó el valor de la variable en el procedimiento,
el valor original no se modifico en lo absoluto. Esto se debe a que el dato fue manejado como tipo
valor, lo que provoca que el argumento genere su propia copia del dato, dejan-do al dato original
intacto.
8. Uso del dato como tipo referencia. En la línea 11 se proporciona la variable como argumento de
un procedimiento llamado Referencia; dicho procedimiento recibe el valor y le da tratamiento
como tipo referencia. En la línea 23 se modifica el valor de Texto, por Texto Referencia, y se
muestran los efectos del cambio en la línea 24.
Después de ejecutar Referencia, se muestra el contenido de la variable Texto (línea 12); es posible
notar que el valor original se modifico. Esto se debe a que el dato fue manejado como tipo referencia,
lo que provoca que el argumento no genere su propia copia del dato, sino que utilice para el manejo
de información la misma position de memoria que el valor original.
Si todo ocurre de la forma esperada, obtendremos la siguiente salida:
FIN DE LA PARTE I

4. Parte II:
Declaración más común de variables y Constantes, y realización de
conversiones
En este ejercicio se utilizará una aplicación de consola para comprobar la declaración y uso de
variables en un proceso.
1. Abra la solución que creo en el ejercicio anterior.
2. Agregue a su solución un proyecto de tipo Consola, llamado AreaRectangulo.
3. Edite el programa de tal forma que aparezca como sigue.
Construcción de un solo proyecto
4. Al agregar éste, se tendrán dos proyectos en la solución. En ocasiones, cuando las soluciones son
muy grandes, reconstruir una completamente para saber si se tienen problemas en el proyecto
que se está desarrollando puede implicar un consumo innecesario de recursos de procesamiento.

5. 5. Para construir únicamente un proceso, y no todos los de la solución, basta con seleccionar el
proyecto en Explorador de Soluciones, desplegar el menú contextual y seleccionar la opción
Generar. De esa forma se construirá sólo el proyecto seleccionado.
6. Seleccione en Explorador de Soluciones el proyecto; para ello coloque el puntero sobre el nombre
del proyecto AreaRectangulo, haga clic con el botón derecho del ratón para desplegar el menú
contextual y seleccione Generar.
7. Vea en Salida (Lista de errores) cómo se procesa solamente el proyecto recién desarrollado.
Cuando su proyecto ya no presente errores, podrá construirse la solución, y ejecutarse con
confianza.
8. Construya la solución (oprima las teclas Ctrl-Mayús-B). Establezca el nuevo proyecto como
proyecto de inicio (Proyecto de inicio) y guarde todos los cambios que haya realizado en la
solución (oprima las teclas Ctrl-Mayús-S). Inicie la depuración para comprobar el comportamiento
de su programa (F5).
9. La línea 4 declara una constante, a la cual se le asigna como valor el mensaje que ha de aparecer
como encabezado del programa (línea 9); en la línea 5 se muestra una declaración de variable en
su forma más sencilla; en la línea 6 se comprueba que es posible asignar un valor inicial al
momento de la declaración; en la línea 7 se comprueba la posibilidad de declarar múltiples
variables de múltiples tipos en una misma línea (aunque esta práctica no se recomienda porque
podría hacer perder claridad al código).
10. En la línea 9 se muestra el título del programa en la consola, en la 10 se muestra el mensaje que
pregunta la base del rectángulo y en la 11 se asigna a la variable Entrada el valor que el usuario
ingresa desde la consola.
11. Como el dato se recibe en formato String desde la consola, la línea 12 se encarga de convertirlo en
Integer, utilizando para ello la función específica Clnt; el resultado es asignado a la variable Base.

6. La misma mecánica se seguirá para preguntar y convertir la altura del rectángulo, con la diferencia
de que se utilizará para la conversión la función genérica CType.
12. La línea 17 calcula el área del rectángulo, asignando el valor a la variable Resultado. Como
Resultado es de tipo Single, posee de forma intrínseca el método ToString, que es utilizado en la
línea 18 para mostrar los resultados.
13. Todas las conversiones que realizamos en este programa pudieron haberse obviado, dado que el
programa no es ‘type safe', es decir, el CLR hubiera realizado la conversión cast en caso de que
nosotros no la hubiéramos llevado a cabo de manera explícita.
14. Proporcione un valor de 10 para la base y 15 para la altura, y vea los resultados .
Si todo ocurre como se espera, obtendremos lo siguiente:
FIN DEL EJERCICIO

7. Parte III:
Demostración del alcance de las variables y la forma en que
preservan valores (II)
En este ejercicio se comprobará la forma en que funcionan los alcances de variables en Visual Basic y
la forma en que podemos aprovechar su manejo para preservar valores en memoria con eficiencia.
1. Abra la solución que creo al inicio de esta guía n° 2.
2. Agregue a su solución un proyecto Windows - Consola, llamado Alcance.
3. Edite el programa de tal forma que aparezca como sigue:

8. 4. Construya la solución (oprima las teclas Ctrl-Mayús-B). Establezca el nuevo proyecto como
proyecto de inicio (Proyecto de Inicio) y guarde todos los cambios que haya realizado en la
solución (oprima las teclas Ctrl-Mayús-S). Inicie la depuración para comprobar el comportamiento
de su programa (Oprima F5).
5. Este programa es type safe, dado que todas las variables deberán declararse antes de ser
utilizadas (Option Explicit) y las conversiones tienen que hacerse de forma explícita (Option Strict)
(líneas 1 y 2).
6. Se declaran variables con diferente alcance en las líneas 5, 9 y 12. En la línea 5 se declara la
variable Texto1; ésta tiene un alcance a nivel módulo, debido a que se declara dentro del módulo,
fuera de cualquier procedimiento.
Esta variable podrá ser utilizada por todos los procedimientos del módulo, es decir, Main(),
Procedimiento1() y Procedimiento2(); esto se comprueba en la líneas 8 y 29, pues se despliega en
la consola una variable no definida en esos procedimientos.
En la línea 9 se declara la variable Texto2, que tiene un alcance a nivel procedimiento, por estar
declarada dentro de un procedimiento específico, pero fuera de un bloque de código; por esa
razón se trata de una variable local. Esta variable estará disponible sólo para Main (), pero no para
otros procedimientos.
En la línea 12 se declara la variable Texto3, que tiene un alcance a nivel bloque de código y estará
disponible desde que se declara (línea 12) hasta que se encuentre el estatuto que marca el final
del bloque de código (en este caso End If, en la línea 14).
Si se trata de utilizar la variable Texto3 después de la línea 14, pensando que es una variable local
(de alcance a nivel procedimiento), nuestro programa generará error, ya que la variable sólo
existe declarada para el bloque en que se declara.
7. Comprobación de la variable estática. En la línea 15 se manda ejecutar Procedimiento1 (); en
dicho procedimiento se define una variable estática llamada Texto4 (línea 25). Esta variable
tendrá un tiempo de vida que excede el tiempo de vida del procedimiento que la declara, ya que
por ser estática, mantendrá los valores en memoria aun después de concluida la ejecución del
procedimiento.
En la línea 26 se asigna a Texto4 la constante String Valor + que se concatenará con el valor que
tenga la misma Texto4; en virtud de que la variable es estática, el valor que va adoptando se
comporta como un acumulador, que nunca pierde el valor que tenía, obtenido de procesamientos
anteriores.
Las líneas 16 y 17 mandan ejecutar Procedimiento1 (), a fin de que se compruebe que
efectivamente la variable mantiene su valor al correr de las múltiples ejecuciones del
procedimiento.

9. 8. Comprobación de shadowing. Ya vimos que en la línea 5, Texto 1 se definió con un alcance a nivel
módulo y, al momento de declarar la variable, se le asignó el valor Alcance módulo. En
Procedimiento2(), se vuelve a definir la variable Textol (línea 37) y se le asigna al momento de
declaración el valor Shadow.
a) ¿Qué alcance tiene la variable Texto1, declarada en la línea 37?
___________________________________________________________________________________
___________________________________________________________________________________
b) ¿Qué valor posee Texto1 cuando es desplegada en la consola en la línea 38?
___________________________________________________________________________________
___________________________________________________________________________________
c) ¿Qué valor posee Texto1 cuando es desplegada en la consola en la línea 40?
___________________________________________________________________________________
___________________________________________________________________________________
Como podrá darse cuenta, el programa no genera conflicto con la doble declaración de la variable;
simplemente utiliza aquella que tenga menor alcance.
Si todo ocurrió como se esperaba, la salida será la siguiente:

10. 9. Modifique la línea 21, sustituyendo el estatuto de declaración Static por Dim. Ejecute el programa
nuevamente, y explique qué sucede.
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
FIN DEL EJERCICIO.