1 modulo - fundamentos de programación
DESCRIPTION
Programación LinealTRANSCRIPT
CARRERA DE ANÁLISIS DE SISTEMAS
Septiembre, 2015
1
Contenido Unidad 1: Conceptos básicos .......................................................................................................... 4
1.1. Conceptos de programación ........................................................................................... 4
Lenguaje de programación ........................................................................................................ 4
Programa ................................................................................................................................... 4
1.2. Pasos en la creación de un programa (Metodología) .................................................... 4
Definición del problema ............................................................................................................ 5
Análisis del problema ................................................................................................................ 5
Diseño y técnicas para la formulación de un algoritmo............................................................. 5
Codificación ............................................................................................................................... 6
Prueba y depuración ................................................................................................................. 6
Documentación ......................................................................................................................... 6
Mantenimiento ......................................................................................................................... 6
1.3. Algoritmos ........................................................................................................................ 7
Ejercicios ................................................................................................................................... 7
1.4. Entidades primitivas para el desarrollo de un programa ............................................. 9
Identificador .............................................................................................................................. 9
Tipos de datos ......................................................................................................................... 10
Operadores relacionales, lógicos y matemáticos .................................................................... 11
Prioridad de los operadores aritméticos ................................................................................. 12
Reglas para formar un Identificador ........................................................................................ 15
Expresiones ............................................................................................................................. 17
Unidad 2: Diagramas de flujo y pseudocódigo ............................................................................ 18
2.1. Diagramas de flujo ........................................................................................................ 18
Técnicas de diseño .................................................................................................................. 18
Características ......................................................................................................................... 18
Simbología ............................................................................................................................... 18
Ejercicios ................................................................................................................................. 19
Prueba de escritorio ................................................................................................................ 20
2.2. Uso de software DFD ..................................................................................................... 21
2.3. PSEUDOCÓDIGO ........................................................................................................ 21
Instrucciones algorítmicas básicas .......................................................................................... 21
2.4. Uso de software PSeInt.................................................................................................. 23
Unidad 3: Estructuras algorítmicas I .......................................................................................... 24
Diseño descendente (top-down) ............................................................................................. 24
2
Estructuras de datos ................................................................................................................ 24
Programación modular ............................................................................................................ 24
3.1. Estructura de control .................................................................................................... 24
Estructura de Control Secuencial ............................................................................................ 24
Estructura de Control Selectiva o Alternativa .......................................................................... 27
Toma de decisiones ................................................................................................................. 28
Estructura de control selectiva doble si/si-no (if/else) ............................................................ 30
Estructura de control selectiva múltiple segun_sea (switch) .................................................. 32
Unidad 4: Estructuras algorítmicas II ......................................................................................... 35
Estructura de Control repetitiva o de iteración condicionada ................................................. 35
Estructura de control repetitiva mientras (while) ................................................................... 35
Estructura de control repetitiva hacer_mientras (do while) ................................................... 37
Estructura de control repetitiva desde (for) ............................................................................ 40
Omisión de expresiones .......................................................................................................... 40
Características: ........................................................................................................................ 41
Unidad 5: Codificación ................................................................................................................. 43
5.1. Elementos del lenguaje Visual Basic ............................................................................ 43
¿Qué es Visual Basic? .............................................................................................................. 43
5.2. Tipos de datos ................................................................................................................ 44
Declaración de variables y constantes..................................................................................... 44
Declaración de constantes ...................................................................................................... 44
Declaración de variables ......................................................................................................... 45
Ejemplos de declaraciones de variables: ................................................................................. 45
Option Explicit ......................................................................................................................... 46
Instrucción de asignación ........................................................................................................ 46
5.3. Funciones ....................................................................................................................... 47
Funciones de Conversión......................................................................................................... 47
Funciones Matemáticas .......................................................................................................... 48
Funciones de Cadena .............................................................................................................. 49
5.4. Operaciones de entrada y salida ................................................................................... 50
Inputbox .................................................................................................................................. 50
MsgBox .................................................................................................................................... 52
Valores de retorno de un MsgBox ........................................................................................... 54
Botones que pueden mostrarse en un MsgBox ....................................................................... 54
Tipos de iconos para un MsgBox ............................................................................................. 55
5.5. Codificación ................................................................................................................... 56
3
Escritura de programas ........................................................................................................... 56
Ejercicios ................................................................................................................................. 56
Estructuras de decisión simple ................................................................................................ 57
Estructuras de decisión doble ................................................................................................. 58
Estructuras de decisión anidadas ............................................................................................ 60
Estructuras de decisión múltiple ............................................................................................. 63
EJERCICIOS PROPUESTOS ........................................................................................................ 66
Estructuras de Repetición ....................................................................................................... 67
Repetir Para (For…next) .......................................................................................................... 67
Repetir Mientras ..................................................................................................................... 69
Repetir Hasta ........................................................................................................................... 71
EJERCICIOS PROPUESTOS ........................................................................................................ 74
5.6. Arreglos .......................................................................................................................... 75
Definición de arreglo ............................................................................................................... 75
Unidimensionales .................................................................................................................... 75
Declaración de los arreglos en el código ................................................................................. 76
Bidimensionales ...................................................................................................................... 78
Referencia Bibliográfica ............................................................................................................... 81
Bibliografía Básica: .................................................................................................................. 81
Bibliografía Complementaría: .................................................................................................. 81
Web ......................................................................................................................................... 81
4
FUNDAMENTOS DE PROGRAMACIÓN
Unidad 1: Conceptos básicos
1.1. Conceptos de programación
Lenguaje de programación
El lenguaje de programación es la combinación de símbolos y reglas, que permiten la
elaboración de programas con los cuales la computadora puede realizar tareas o resolver
problemas de manera eficiente.
Los lenguajes de programación se clasifican en:
1. Lenguaje máquina. Las instrucciones son directamente entendibles por la computadora
y no necesitan traductor para que la CPU (unidad de procesamiento central) pueda
entender y ejecutar el programa. Utiliza un código binario (0 y 1), se basa en bits
(abreviatura inglesa de dígitos binarios).
2. Lenguaje de bajo nivel (ensamblador). Las instrucciones se escriben en códigos
alfabéticos conocidos como mnemotécnicos.
3. Lenguaje de alto nivel. Es semejante al lenguaje humano (en general en inglés), lo que
facilita la elaboración y comprensión del programa. Por ejemplo: Basic, Pascal, Cobol,
Fortran, C, etc.
Programa
Existen diferentes conceptos:
1. Es un algoritmo desarrollado en un determinado lenguaje de programación, para ser
utilizado por la computadora; es decir, es una serie de pasos o instrucciones ordenadas y
finitas que pueden ser procesadas por una computadora, a fin de permitir resolver un
problema o tarea específica.
2. Secuencia de instrucciones mediante las cuales se ejecutan diferentes acciones, de
acuerdo con los datos que se desee procesar en la computadora.
3. Expresión de un algoritmo en un lenguaje preciso, que puede llegar a entender una
computadora.
1.2. Pasos en la creación de un programa (Metodología)
Las fases para la creación de un programa son siete, aunque para algunos autores pueden
describirse en sólo seis, pues omiten la primera porque es una etapa algo obvia. Las etapas
se describen a continuación.
5
Definición del problema
Esta fase la proporciona el enunciado del problema, el cual requiere una definición clara y
precisa (no debe ser ambiguo). Es importante que se entienda perfectamente lo que
pretendemos que haga la computadora para poder continuar con la siguiente etapa.
Análisis del problema
Una vez que se ha comprendido lo que se desea que la computadora haga, la etapa de análisis
es muy importante ya que en ésta se identifican tres factores indispensables:
1. Qué información se necesita para obtener el resultado deseado (datos de entrada).
2. Qué información se desea producir (datos de salida).
3. Los métodos y fórmulas que se necesitan para procesar los datos y producir esa salida.
Diseño y técnicas para la formulación de un algoritmo
La etapa de diseño se centra en desarrollar el algoritmo basándonos en las especificaciones
de la etapa del análisis; podemos representar un algoritmo mediante el diagrama de flujo o
el pseudocódigo.
Diagrama de flujo
Un diagrama de flujo es la representación gráfica de un algoritmo; dicha representación
gráfica se lleva acabo cuando varios símbolos (que indican diferentes procesos en la
computadora) se relacionan entre sí mediante líneas que indican el orden en que se deben
ejecutar las instrucciones para obtener los resultados deseados.
Los símbolos utilizados han sido reglamentados por el Instituto Nacional de
Normalización Estadounidense (ANSI, American National Standards Institute).
Pseudocódigo
El pseudocódigo es la combinación del lenguaje natural (español, inglés o cualquier otro
idioma), símbolos y términos utilizados dentro de la programación. Se puede definir
como un lenguaje de especificaciones de algoritmos.
El pseudocódigo se creó para superar las dos principales desventajas del diagrama de
flujo: es lento de crear y difícil de modificar sin un nuevo redibujo. Por otra parte, el
pseudocódigo es más fácil de utilizar ya que es similar al lenguaje natural. Al contrario
de los lenguajes de programación de alto nivel no tiene normas que definan con precisión
lo que es y lo que no es pseudocódigo, por lo tanto varía de un programador a otro.
6
Codificación
En la etapa de codificación se transcribe el algoritmo definido en la etapa de diseño en un
código reconocido por la computadora; es decir, en un lenguaje de programación; a éste se
le conoce como código fuente.
Prueba y depuración
La prueba consiste en capturar datos hasta que el programa funcione correctamente. A la
actividad de localizar errores se le llama depuración. Existen dos tipos de pruebas: de
sintaxis y de lógica.
Las pruebas de sintaxis se ejecutan primero, son las más sencillas y las realiza el compilador
del programa cada vez que se ejecuta el programa hasta que el código no presente errores,
es decir que la sintaxis que requiere el lenguaje sea la correcta, de lo contrario el propio
compilador va mostrando los errores encontrados para que se modifiquen y se pueda ejecutar
el código; estos errores pueden ser falta de paréntesis, o puntos y comas o palabras reservadas
mal escritas.
Las pruebas de lógica son las más complicadas ya que éstas las realiza el programador;
consisten en la captura de diferentes valores y revisar que el resultado sea el deseado, es
decir el programador tendría que modificar el código hasta que el programa funcione
correctamente.
Documentación
Es la guía o comunicación escrita que permite al programador o al usuario conocer la
funcionalidad del programa.
La documentación sirve para que el código fuente sea más comprensible para el programador
o para otros programadores que tengan que utilizarlo, así como para facilitar futuras
modificaciones (mantenimiento).
Hay dos tipos de documentación:
Interna. Se generan en el mismo código y generalmente es mediante comentarios.
Externa. Son los manuales y es independiente al programa. También puede ser la ayuda
en el mismo software.
Mantenimiento
Se dice que un programa no se termina al 100%, ya que es necesario hacer algún cambio,
ajuste o complementación para que siga funcionando correctamente; para llevarlo a cabo se
requiere que el programa esté bien documentado.
7
Todos los programas tienen actualizaciones, por lo que surgen versiones diferentes. Por
ejemplo: Windows 3.11, 95, 98, 2000, Millennium, Xp, Vista y 7.
1.3. Algoritmos
Se denomina algoritmo al conjunto de pasos ordenados y finitos que permiten resolver un
problema o tarea específica. Los algoritmos son independientes del lenguaje de
programación y de la computadora que se vaya a emplear para ejecutarlo.
Todo algoritmo debe ser:
1. Finito en tamaño o número de instrucciones (tiene un primer paso y un último paso) y
tiempo de ejecución (debe terminar en algún momento). Por lo tanto, debe tener un punto
particular de inicio y fin.
2. Preciso. Debe tener un orden entre los pasos.
3. Definido. No debe ser ambiguo (dobles interpretaciones); si se ejecuta el mismo
algoritmo el resultado siempre será el mismo, sin importar las entradas proporcionadas.
4. General. Debe tolerar cambios que se puedan presentar en la definición del problema.
Toda actividad que se realiza se la pude expresar en forma de algoritmo. Existen dos tipos
de algoritmos, los que se desarrollan para ser ejecutados por una computadora, llamados
algoritmos computacionales; y los que realiza el ser humano, es decir, algoritmos no
computacionales, como ejemplos de éstos están:
1. Cambiar un neumático (llanta) de un automóvil
2. Preparar unos “huevos a la mexicana”
3. Calcular el área de un triángulo
o Técnicas para la formulación de algoritmos
Ejercicios
Algoritmo para cambiar el neumático desinflado de un automóvil.
1. Inicio1
2. Bajar la herramienta y el neumático (llanta) de repuesto del automóvil.
3. Aflojar los birlos del neumático pinchado.
4. Acomodar el gato.
5. Levantar el automóvil.
6. Quitar los birlos del neumático desinflado.
7. Quitar el neumático desinflado.
8. Colocar el neumático de repuesto.
1 Existen autores que en este tipo de algoritmos (no computacionales) no utilizan el Inicio y el Fin, ambos son opcionales.
8
9. Fijar los birlos del neumático de repuesto.
10. Bajar el automóvil.
11. Apretar en forma definitiva los birlos del neumático de repuesto.
12. Quitar el gato.
13. Guardar el neumático desinflado y la herramienta.
14. Fin.
Este algoritmo es finito, tiene 12 pasos2 y tiene un orden.
Un algoritmo para preparar unos “huevos a la mexicana”.
1. Poner la sartén en la estufa.
2. Poner aceite en la sartén.
3. Encender la estufa.
4. Cortar cebolla, tomate y chile en pedazos pequeños.
5. Poner la cebolla, el tomate y el chile en la sartén.
6. Abrir los huevos y verterlos en un recipiente.
7. Batir los huevos.
8. Poner los huevos batidos en la sartén.
9. Revolver la cebolla, tomate y el chile con los huevos hasta que queden estos
últimos cocidos.
10. Vaciarlos en un plato.
Este algoritmo también es finito (tiene 10 pasos) y algunos pasos pueden estar en
otro orden, por ejemplo los cuatro primeros puntos pudieron estar en un orden
diferente y se seguiría teniendo el mismo resultado.
Un algoritmo para calcular el área de un triángulo.
1. Inicio.
2. Solicitar (leer) los datos (la base y la altura).
3. Multiplicar la base por la altura y el resultado dividirlo entre dos, y guardarlo en
una variable.
4. Mostrar (imprimir) el resultado almacenado en la variable.
5. Fin.
Al igual que en los dos ejemplos anteriores, se cumplen todas las características,
solamente que este último algoritmo no es una situación cotidiana de la vida sino un
cálculo específico el cual tiene un resultado exacto, o sea un valor.
A continuación se describe un algoritmo, siempre que se tenga fórmulas:
2 Sin considerar inicio y fin
9
1. Inicio.
2. Leer datos de entrada, se encuentran a la derecha del operador de asignación.
3. Procesar fórmula.
4. Imprimir datos de salida, se encuentran a la izquierda del operador de asignación;
por lo tanto por cada fórmula sólo habrá un dato de salida.
5. Fin.
1.4. Entidades primitivas para el desarrollo de un programa
Identificador
Un identificador es una secuencia de caracteres alfabéticos, numéricos y el guión bajo. Con
los que se puede dar nombre a variables, constantes, tipos de dato, nombres de funciones o
procedimientos, etc.
Cada lenguaje de programación tiene sus propias características del tamaño del identificador;
el estándar de lenguaje C no especifica un límite de tamaño para un identificador, pero para
ciertas implementaciones de C11 sólo los primeros 31 caracteres son significativos (ANSI
C). El programador tiene libertad para darle cualquier nombre a un identificador, siguiendo
estas reglas:
1. Debe comenzar con una letra (A a Z) mayúscula o minúscula y no puede contener
espacios en blanco.
2. En lenguaje C, el carácter “_” (guión bajo) es considerado como letra, por lo que se
puede utilizar como primer carácter.
3. Algunos lenguajes de programación distinguen mayúsculas de minúsculas.
4. Letras, dígitos y el carácter guión bajo están permitidos después del primer carácter.
5. No pueden existir dos identificadores iguales, es decir, dos elementos de un programa
no pueden nombrarse de la misma forma. Sin embargo, un identificador puede aparecer
más de una vez en un programa.
6. No se puede utilizar una palabra reservada como identificador, sin embargo, los
identificadores estándar se pueden redefinir.
7. En lenguaje C existen identificadores que podrían tener uno o varios puntos, tales como:
persona.apellidoPaterno
El punto indica el acceso a un campo de una estructura.
Sugerencias:
1. El identificador debe tener un nombre que sea significativo, es decir, que dé una idea de
la información que almacena.
2. No utilizar nombres muy largos, es mejor utilizar abreviaturas estándar para que éstos
tengan una longitud razonable.
3. En los casos de nombres compuestos se suele poner la inicial de la segunda palabra en
mayúscula.
10
totalAlumnos, areaCirculo, numeroPositivo
Identificadores válidos: numero, year2008, Base_1, funcion, division
Identificadores no válidos: número, ?precio, año, 2007, 4semestre
En los tres primeros ejemplos de identificadores no válidos, se utilizan caracteres
especiales; en los dos últimos el primer caracter no es letra. Hay que recordar que la ñ
en el código ASCII, NO aparece con las demás letras.
Tipos de datos
Los diferentes objetos de información con los que un algoritmo o programa trabaja se
conocen colectivamente como datos. Un dato puede ser un simple carácter, tal como ‘b’, un
valor entero tal como 35.
Todos los datos tienen un tipo asociado con ellos; el tipo de un dato es el conjunto (rango)
de valores que puede tomar durante el programa. El tipo de un dato determina la naturaleza
del conjunto de valores que puede tomar una variable.
El tipo de dato asociado a una variable limita el conjunto de datos que puede almacenar, así
como las operaciones aplicables sobre esa variable. Por lo tanto, una variable que pertenece
a un tipo de dato entero no podrá almacenar datos de tipo caracter; tampoco se podrán
calcular operaciones propias de otros tipos de datos.
Las computadoras pueden trabajar con varios tipos de datos; los algoritmos y programas
operan sobre éstos.
La asignación de tipos a los datos tiene dos objetivos principales:
1. Detectar errores de operaciones en programas.
2. Determinar cómo ejecutar las operaciones.
Los datos que utilizan los algoritmos y programas se los puede clasificar en simples o
compuestos. Un dato simple es indivisible, no se puede descomponer. Un dato compuesto
está integrado por varios datos.
Los tipos de datos simples son: numéricos (enteros y reales), lógicos (booleanos) y caracteres
(alfanuméricos).
11
Simples:
1. Datos Numéricos: Permiten representar valores escalares de forma numérica, esto
incluye a los números enteros y los reales. Este tipo de datos permiten realizar
operaciones aritméticas comunes.
2. Datos Lógicos: Son aquellos que solo pueden tener dos valores (cierto o falso) ya
que representan el resultado de una comparación entre otros datos (numéricos o
alfanuméricos).
3. Datos Alfanuméricos (String): Es una secuencia de caracteres alfanuméricos que
permiten representar valores identificables de forma descriptiva, esto incluye
nombres de personas, direcciones, etc. Es posible representar números como
alfanuméricos, pero estos pierden su propiedad matemática, es decir no es posible
hacer operaciones con ellos. Este tipo de datos se representan encerrados entre
comillas.
Ejemplo:
“ITS JOL”
“2015”
Operadores relacionales, lógicos y matemáticos
Los operadores son elementos que relacionan de forma diferente, los valores de una o más
variables y/o constantes. Es decir, los operadores nos permiten manipular valores.
Tipos de datos
Simples
Numéricos
Lógicos
Alfanuméricos (string)
Estructurados
Arreglos (Vectores, Matrices)
Registros
Archivos
Apuntadores
12
Operadores Aritméticos: Los operadores aritméticos permiten la realización de
operaciones matemáticas con los valores (variables y constantes).
Los operadores aritméticos pueden ser utilizados con tipos de datos enteros o reales.
Si ambos son enteros, el resultado es entero; si alguno de ellos es real, el resultado es
real.
Operadores Aritméticos
+ Suma
- Resta
* Multiplicación
/ División
Mod Módulo (residuo de la división entera)
Ejemplo:
Expresión Resultado
7/2 3.5
12 mod 7 5
4+2*5 14
Prioridad de los operadores aritméticos
Al orden en que la computadora realiza las diferentes operaciones se llama orden de
prioridad.
1. Paréntesis ( ) Todas las expresiones entre paréntesis se evalúan primero. Las
expresiones con paréntesis anidados se evalúan de dentro hacia afuera.
Tipos de operadores
Aritméticos
Relacionales
Lógicos
13
2. Dentro de una misma expresión o subexpresión, se evalúan en el siguiente orden:
Potencia (^ o **)
*, /, mod
+, -
Los operadores en una misma expresión con igual nivel de prioridad se evalúan de
izquierda a derecha.
Ejemplos:
23 * 2 / 5 = 9.2 46 / 5 = 9.2
3 + 5 * (10 - (2 + 4)) = 23 3 + 5 * (10 - 6) = 3 + 5 * 4 = 3 + 20 = 23
3.5 + 5.09 - 14.0 / 40 = 5.09 3.5 + 5.09 - 3.5 = 8.59 - 3.5 = 5.09
2.1 * (1.5 + 3.0 * 4.1) = 28.98 2.1 * (1.5 + 12.3) = 2.1 * 13.8 = 28.98
Los operadores de asignación tienen menor prioridad que todos los otros operadores.
El orden de las operaciones en pseudocódigo es:
Operadores Relacionales: Se utilizan para establecer una relación entre dos valores.
Compara estos valores entre si y esta comparación produce un resultado de certeza o
falsedad (verdadero o falso). Los operadores relaciónales comparan valores del
mismo tipo (numéricos o cadenas). Tienen el mismo nivel de prioridad en su
evaluación. Los operadores relaciónales tiene menor prioridad que los aritméticos.
Operadores Relacionales
> Mayor que
< Menor que
> = Mayor o igual que
< = Menor o igual que
< > Diferente
= = Igual
14
Ejemplos:
Si a = 10 b = 20 c = 30
a + b > c Falso
a - b < c Verdadero
a - b == c Falso
a * b < > c Verdadero
Ejemplos no lógicos:
a < b < c
10 < 20 < 30
T < 30 (no es lógico porque tiene diferentes operandos)
Operadores Lógicos: Estos operadores se utilizan para establecer relaciones entre
valores lógicos. Estos valores pueden ser resultado de una expresión relacional.
Operadores Lógicos
And Y
Or O
Not Negociación
15
http://webdelprofesor.ula.ve/nucleotrujillo/frank_delgadillo/file/tipodedatos.pdf
Identificadores: Los identificadores representan los datos de un programa
(constantes, variables, tipos de datos). Un identificador es una secuencia de
caracteres que sirve para identificar una posición en la memoria de la computadora,
que permite acceder a su contenido.
Ejemplo:
Nombre
Num_horas
Nota2
Reglas para formar un Identificador
1. Debe comenzar con una letra (A a Z, mayúsculas o minúsculas) y no deben
contener espacios en blanco.
2. Letras, dígitos y caracteres como la subraya ( _ ) están permitidos después del
primer carácter.
3. La longitud de identificadores puede ser de hasta 8 caracteres.
Constante: Una constante es un dato numérico o alfanumérico que no cambia
durante la ejecución del programa.
Ejemplo:
pi = 3.1416
Variable: Es un espacio en la memoria de la computadora que permite almacenar
temporalmente un dato durante la ejecución de un proceso, su contenido puede
cambia durante la ejecución del programa. Para poder reconocer una variable en la
memoria de la computadora, es necesario darle un nombre con el cual podamos
identificarla dentro de un algoritmo.
Ejemplo:
area = pi * radio ^ 2
Variables: radio, área
Constante: pi
16
Por su Contenido
Variable Numéricas: Son aquellas en las cuales se almacenan valores
numéricos, positivos o negativos, es decir almacenan números del 0 al 9, signos
(+ y -) y el punto decimal.
Ejemplo:
iva = 0.15
pi = 3.1416
costo = 2500
Variables Lógicas: Son aquellas que solo pueden tener dos valores (cierto o
falso) estos representan el resultado de una comparación entre otros datos.
Variables Alfanuméricas: Está formada por caracteres alfanuméricos (letras,
números y caracteres especiales).Ejemplo:
letra =”a”
apellido = ”lopez”
direccion = “Av. Libertad #190”
Por su Uso
Variables de Trabajo: Variables que reciben el resultado de una operación
matemática completa y que se usan normalmente dentro de un programa.
Clasificación de variables
Por su contenido
Numéricas
Lógicas
Alfanuméricas (String)
Por su uso
De trabajo
Contadores
Acumuladores
17
Ejemplo:
suma = a+b/c
Contadores: Se utilizan para llevar el control del número de ocasiones en que se
realiza una operación o se cumple una condición. Con los incrementos
generalmente de uno en uno.
Acumuladores: Forma que toma una variable y que sirve para llevar la suma
acumulativa de una serie de valores que se van leyendo o calculando
progresivamente.
Expresiones
Una expresión es el resultado de unir operandos mediante operadores. Los operandos pueden
ser variables, constantes u otras expresiones; y los operadores, aritméticos, lógicos o
relacionales. El resultado de una expresión es un dato numérico o un valor lógico. Para
agrupar las expresiones se utiliza los paréntesis.
Según el tipo de datos que manipulan, se clasifican en:
Aritméticas.
Lógicas o booleanas.
Las expresiones lógicas o booleanas son expresiones relacionadas entre sí mediante
operadores relacionales o lógicos. Una expresión lógica es una expresión que sólo puede
tomar dos valores: verdadero o falso.
Las fórmulas matemáticas se deben escribir en formato lineal. Esto obliga al uso frecuente
de paréntesis que indiquen el orden de evaluación correcto de los operadores.
18
Unidad 2: Diagramas de flujo y pseudocódigo
2.1.Diagramas de flujo
Técnicas de diseño
Características
Todo diagrama debe tener un inicio y un fin.
No se especifica la declaración de variables.
Se deben usar solamente líneas de flujo horizontales y/o verticales.
Se debe evitar el cruce de líneas utilizando los conectores.
Se deben usar conectores sólo cuando sea necesario.
No deben quedar líneas de flujo sin conectar.
Se deben trazar los símbolos de manera que se puedan leer de arriba hacia abajo y de
izquierda a derecha.
Se debe evitar la terminología de un lenguaje de programación o máquina.
Los comentarios se deben utilizar ya sea al margen o mediante el símbolo gráfico
comentarios para que éstos sean entendibles por cualquier persona que lo consulte.
Si el diagrama abarca más de una hoja es conveniente enumerarlo e identificar de
dónde viene y a dónde se dirige.
Sólo los símbolos de decisión pueden y deben tener más de una línea de flujo de
salida.
Simbología
19
Ejercicios
Ejercicio 1. Sume dos números enteros
Para la parte lógica de la programación se utilizará las tres primeras etapas del desarrollo de
un programa.
1. Entender el problema
En este caso sumar dos números; el término suma es claro y conocido.
2. Análisis del problema
Al realizar un análisis nos arroja los siguientes datos:
Datos de entrada: n1, n2
Datos de salida: suma
Fórmula: suma = n1 + n2
3. Diseño del algoritmo
Se desarrolló el diagrama de flujo arriba descrito.
Explicación del diseño:
Para el nombre de las variables se recomienda hacer referencia a lo solicitado o
calculado.
20
Para este programa se declaran tres variables de tipo entero, dos variables que son
los datos de entrada, que no se conocen y se necesitan leer o pedir al usuario (n1 y
n2) y una variable (dato de salida) en la cual se va a guardar el resultado (suma).
Cabe hacer notar que en el diagrama de flujo no se acostumbra declarar ni las
variables ni las constantes.
El símbolo impresión muestra en pantalla todo lo que se encuentra entre las comillas,
y en la parte que no tiene comillas se muestra el valor de la variable respectiva. Por
lo tanto, los letreros se distinguen de las variables por las comillas y se separan con
comas, si se requiere imprimir o mostrar el valor de varias variables. Cabe hacer notar
que en un diagrama de flujo los letreros previos a la lectura de un dato o impresión
de una variable son opcionales, en el presente ejercicio no aparecen.
El símbolo entrada (leer) solicita los datos al usuario, guardando éstos en las variables
n1 y n2. La expresión suma ← n1 + n2 primero realiza la suma de los valores
almacenados a las variables n1 y n2 y el resultado lo guarda en la variable suma, la
cual se muestra en pantalla con el símbolo impresión.
Si n1= 6 y n2 = 9, se mostrará: 15
Nota 1: Solamente se muestra el valor de la variable suma, más no el nombre de la
variable.
Nota 2: Todo programa solicita los datos que desconoce o que necesita saber, los
almacena en variable(s) y luego utiliza el valor de la variable para realizar los cálculos
necesarios según sea el resultado que desea obtener, almacenando este resultado en
alguna variable y luego mostrando el valor de la variable o imprimiendo directamente
el resultado.
Prueba de escritorio
21
2.2.Uso de software DFD
Link de descarga: http://freedfd.googlecode.com/files/FreeDFD-1.1.zip
Deber: Realizar diagrama de los siguientes ejemplos:
https://www.youtube.com/watch?v=dO58-IfkhbM
https://www.youtube.com/watch?v=jLEvEmjTCCc
https://www.youtube.com/watch?v=lvSzW53_nhw
https://www.youtube.com/watch?v=yKshniLrSl0
2.3.PSEUDOCÓDIGO
Instrucciones algorítmicas básicas
Algunas de las instrucciones algorítmicas básicas son:
Entrada
Consiste en obtener un dato de un dispositivo de entrada, como el teclado, y almacenarlo en
una variable. En general, la acción de ingresar un dato a una variable se expresa en el
pseudocódigo mediante la palabra LEER, de la siguiente forma: LEER variable
22
Ejemplo:
LEER estatura
Solicita el ingreso de un valor, desde algún dispositivo de entrada (como el teclado), para la
variable estatura.
Salida
Consiste en mostrar el valor de una variable en un dispositivo de salida, como la pantalla.
En general, la acción de mostrar el valor de una variable se expresa en el pseudocódigo
mediante la palabra IMPRIMIR o ESCRIBIR (Para el caso del PSEINT) de la siguiente
forma: IMPRIMIR variable o ESCRIBIR variable
Ejemplo:
IMPRIMIR (ESCRIBIR) importeCompra
Muestra, en algún dispositivo de salida (como la pantalla), el valor de la variable
importeCompra.
Asignación
Consiste en asignar a una variable el valor de una expresión. La expresión puede ser una
simple variable, un simple literal o una combinación de variables, literales y operadores. La
asignación se expresa en el pseudocódigo de la siguiente forma: variable = expresión
Donde variable y el valor de expresión deben tener el mismo tipo de dato. Cuando se asigna
un valor ENTERO a una variable REAL, entonces el valor ENTERO se convertirá en REAL
antes de almacenarse. Así, al asignar el valor ENTERO 25 a una variable REAL, se
almacenará 25.0
Ejemplo
Algoritmo para expresar en centímetros y pulgadas una cantidad dada en metros.
Nota: lo que se encuentra después de cada // son comentarios
INICIO
// Declara las variables M, C y P
REAL M, C, P
// Solicita el ingreso de la cantidad en metros
LEER M
// Calcula la cantidad en centímetros y lo asigna a la variable C
23
C = M*100
// Calcula la cantidad en pulgadas y lo asigna a la variable P
P = C/2.54
// Muestra los valores de las variables C y P
IMPRIMIR C, P
FIN
Ejemplo:
2.4.Uso de software PSeInt
Link de descarga: http://pseint.sourceforge.net/
Visualizar el funcionamiento del software en el siguiente link:
https://www.youtube.com/watch?v=RAOYo5P31Po
Deber: Realizar un informe que incluya el enunciado del problema, diagrama de
flujo y la Codificación en Seudocódigo
https://www.youtube.com/watch?v=dwFd4srugJs
https://www.youtube.com/watch?v=dts8Tn0PWmE
24
Unidad 3: Estructuras algorítmicas I
La programación estructurada es un paradigma o forma de programar. Es un conjunto de
técnicas que nos permiten desarrollar programas fáciles de escribir, verificar, leer y mantener
e incluyen:
1. Diseño descendente (top-down).
2. Estructuras de datos.
3. Estructuras de control.
4. Programación modular.
Diseño descendente (top-down)
En la programación estructurada las instrucciones están ordenadas u organizadas de arriba a
abajo, lo que facilita el diseño del algoritmo, el entendimiento del código y por consiguiente
el mantenimiento del mismo.
Estructuras de datos
Son un conjunto de datos donde podemos almacenar y acceder a elementos individuales de
datos, por lo que pueden separarse en los elementos que la forman.
Programación modular
Otra característica que tiene la programación estructurada es que el problema se puede
dividir en secciones o partes (módulos). Este tipo de programación permite resolverlo de
manera más sencilla y en forma paralela si es necesario, es decir por un equipo de personas.
3.1.Estructura de control
Estas estructuras controlan cómo se ejecutan los programas, es decir el orden de las
instrucciones, ya que tienen un solo punto de entrada y un punto de salida. En la
programación estructurada se mezclan las estructuras de control y las podemos clasificar en:
Secuencial
Estructuras de control Selectiva
Repetitiva o de iteración condicionada
Estructura de Control Secuencial
Las instrucciones se ejecutan en orden, una por una desde la primera hasta la última,
es decir el programa ejecuta todas las instrucciones del programa en el orden
establecido sin saltarse ninguna de ellas.
Es la estructura más sencilla ya que el programador identifica los datos de entrada,
los procesa y muestra o imprime los datos de salida.
La estructura secuencial se puede representar de la siguiente forma:
25
A continuación presentamos los ejercicios resueltos; para tal efecto debemos retomar
lo aprendido en secciones anteriores respecto a la asignación. Además debemos
distinguir la entrada y la salida de datos:
Ejercicios resueltos de la estructura de control secuencial
Ejercicio 1. Sume dos números enteros.
Para la parte lógica de la programación nos centraremos en las tres primeras etapas
del desarrollo de un programa.
1. Entender el problema.
En este caso sumar dos números; el término suma es claro y conocido.
2. Análisis del problema.
Al realizar un análisis nos arroja los siguientes datos:
Datos de entrada: n1, n2
26
Datos de salida: suma
Fórmula: suma 5 n1 1 n2
3. Diseño del algoritmo.
Se desarrollaron el pseudocódigo y el diagrama de flujo arriba descritos.
Explicación del diseño:
Como se aprecia en la siguiente tabla, el nombre de las variables las elige usted; se
recomienda que hagan referencia a lo solicitado o calculado.
Para este programa se declaran tres variables de tipo entero, dos variables que son
los datos de entrada que no se conocen y se necesitan leer o pedir al usuario (n1 y
n2) y una variable (dato de salida) en la cual se va a guardar el resultado (suma).
Cabe hacer notar que en el diagrama de flujo no se acostumbra declarar ni las
variables ni las constantes.
La instrucción imprimir muestra en pantalla todo lo que se encuentra entre las
comillas, y en la parte que no tiene comillas se muestra el valor de la variable
respectiva. Por lo tanto, los letreros los distinguimos de las variables por las comillas
y los separamos con comas, si se requiere imprimir o mostrar el valor de varias
variables. Cabe hacer notar que en un diagrama de flujo los letreros previos a la
lectura de un dato o impresión de una variable son opcionales, en el presente ejercicio
no aparecen.
La instrucción leer solicita los datos al usuario, guardando éstos en las variables n1
y n2. La expresión suma ← n1 1 n2 primero realiza la suma de los valores
almacenados a las variables n1 y n2 y el resultado lo guarda en la variable suma, la
cual se muestra en pantalla en la última instrucción.
Si n1 = 6 y n2 = 9 se mostrará: La suma es: 15.
Nota 1: Solamente se muestra el valor de la variable suma, más no el nombre de la
variable.
Nota 2: Todo programa solicita los datos que desconoce o que necesita saber, los
almacena en variable(s) y luego utiliza el valor de la variable para realizar los
cálculos necesarios según sea el resultado que desea obtener, almacenando este
resultado en alguna variable y luego mostrando el valor de la variable o imprimiendo
directamente el resultado, como en el ejercicio siguiente.
27
De acuerdo con lo que acabamos de ver en el ejercicio, a continuación describimos
un algoritmo en pseudocódigo siempre que tengamos fórmulas:
1. principal()
2. inicio
3. Declaración de variables de entrada y salida.
4. Leer datos de entrada, los encontramos a la derecha del operador de
asignación.
5. Procesar fórmula.
6. Imprimir datos de salida, los encontramos a la izquierda del operador de
asignación; por lo tanto por cada fórmula sólo abra un dato de salida.
7. fin.
El algoritmo presentado es para una fórmula, pero también se puede implementar
para varias fórmulas, respetando los pasos 1, 2 y 7. Se pueden repetir los pasos 4, 5
y 6 en secuencia para cada fórmula o aplicando cada paso para todas las fórmulas,
por ejemplo si se tienen tres fórmulas en el paso 6 se imprimirían los 3 resultados.
Ejercicio 2. Área de un cuadrado
Este programa declara solamente una variable lado, la cual nos sirve para guardar el
valor del lado de un cuadrado, pero como verán no existe ninguna variable para
almacenar el resultado (área), así que el cálculo lo haremos directamente al momento
de imprimir el resultado; primero se hace el producto del lado * lado, y el resultado
se imprimirá después de la etiqueta o mensaje
Estructura de Control Selectiva o Alternativa
De acuerdo con una condición que puede ser verdadera o falsa se elige una opción,
la cual realiza una acción (una o varias instrucciones). La condición puede ser simple
o compuesta (una o varias).
Es una estructura con una sola entrada y una sola salida en la cual se realiza una
acción (una o varias instrucciones) de entre varias, según una condición; o se realiza
28
una acción según el cumplimiento o no de una determinada condición. La condición
puede ser simple o compuesta.
Los programas, para un mejor funcionamiento y para poder realizar un número
mayor de tareas, deben permitir emplear acciones alternativas a fin de poder elegir
una de ellas cuando la situación lo requiera. Por lo tanto, la ejecución de una línea o
grupos de líneas del programa depende de si cumplen o no una condición.
Toma de decisiones
La instrucción si (if) nos permite tomar decisiones, podemos hacer una pregunta y la
contestación sólo puede ser verdadera o falsa, es decir, sí o no.
Ejemplo:
Si llueve, llevar el paraguas.
La expresión condicional
La condición es una expresión booleana. Si el resultado de la expresión:
Es cero, se considera una condición falsa.
No es cero, se considera una condición cierta
Ejemplo:
x = 9; if (x) //La condición es verdadera.
if (5>7) //La condición es falsa, comparamos dos valores.
El último ejemplo es el más utilizado.
Existen tres tipos de estructuras de control selectivas; éstas se basan en una condición
o en una opción:
a) Simple if. b) Doble if-else. c) Múltiple switch-break.
Bloque de sentencias o instrucción compuesta
Se denomina bloque de sentencias a un conjunto de instrucciones delimitadas, por
ejemplo en lenguaje C, C11, Java se utilizan llaves que abren y cierran { }.
En lenguajes como Pascal, Modula, Delphi, Ada, se utiliza Begin y End. Estas
instrucciones se toman como una sola sentencia en las estructuras de control.
Estructura de control selectiva simple si (if)
Estructura de control que dirige a la computadora para ejecutar una o más
instrucciones solamente si la condición es verdadera. Si la condición es falsa no
realiza ninguna acción. El término condición lo utilizaremos a lo largo de este libro
para referirnos a una o más condiciones.
Existen dos formas de representarlo, dependiendo del número de instrucciones que
se desean realizar si la condición se cumple:
29
1. Si se requiere ejecutar una sola instrucción, cuando se cumpla la condición se
representa de la siguiente forma:
2. Si se requiere ejecutar un bloque de instrucciones, cuando se cumpla la condición
se representa de la siguiente forma:
Nota: Si existe más de una instrucción para realizar, es necesario utilizar inicio y fin
para agrupar las instrucciones, es su alcance sintáctico, si no se usa el inicio y fin
sólo se ejecuta la primera instrucción, mientras que las siguientes instrucciones se
realizarán siempre. En la tabla 3.2 vemos unos ejemplos de las distintas formas que
puede adoptar la “expresión” dentro de un if.
Formas de utilizar la instrucción if
30
Estructura de control selectiva doble si/si-no (if/else)
Estructura de control que dirige a la computadora para ejecutar una acción si la
condición es verdadera, y otra acción en caso de que sea falsa. Cabe mencionar que
las instrucciones deberán ser diferentes en cada caso, ya que si fueran iguales no se
requeriría una estructura selectiva, con la estructura secuencial se resolvería el
problema.
Existen dos formas de representarlo, dependiendo del número de instrucciones que
se desean realizar si la condición se cumple o no:
Si la condición se cumple se realiza la instrucción 1, pero si la condición no se cumple
se realiza la instrucción 2
Si la condición se cumple se realizan las instrucciones 1 y 2, pero si no se cumple se
realizarán las instrucciones 3 y 4.
Ejercicios resueltos de la estructura de control selectiva simple si (if) y doble
si/si-no (if/else)
Ejercicio 1. Según una calificación, imprimir si ésta es aprobada.
31
En el ejercicio 1 se utiliza la estructura selectiva simple. La condición de este ejemplo
y la mayoría que veremos en el presente curso consisten en comparar dos valores (la
variable cal y 60), y si dicha condición es verdadera se realiza una determinada
acción. Se revisa la calificación (cal), si es mayor o igual que 60, se imprime
aprobada, de lo contrario no imprime nada el programa, es decir sólo pasa por parte
del programa dependiendo de una condición. Ejemplo: si cal = 85 el programa
imprime “Aprobada”, pero si cal 5 59, el programa no imprime nada.
Ejercicio 2. Según una calificación, imprimir si es aprobada o reprobada.
A diferencia del ejercicio 1, el ejercicio 2 utiliza la selectiva doble, ya que revisa la
condición; si ésta se cumple (es verdadera) imprimirá “Aprobada”, pero, si la
condición no se cumple imprimirá “Reprobada”, es decir el programa pasa por una u
otra instrucción pero no por ambas. Ejemplo: si cal = 85 el programa imprime
32
“Aprobada”, pero si cal = 59, el programa imprime “Reprobada”. La alternativa
doble es más rápida; en este ejemplo sólo evalúa una condición, a diferencia de la
simple, que evaluaría dos.
Estructura de control selectiva múltiple segun_sea (switch)
Esta estructura selecciona entre varias posibilidades, dependiendo del valor de la
expresión. Cuando en la estructura si (if) todas las condiciones utilizan la igualdad
de una variable determinada con constantes predefinidas, se puede utilizar la
instrucción segun_sea (switch), en dicha instrucción existen más de dos opciones.
La estructura segun_sea (switch) evalúa una expresión que puede tomar n valores
distintos; según con cuál de estos valores coincida, se ejecutarán ciertas acciones, es
decir, el programa o algoritmo seguirá un determinado camino entre los n posibles.
Dicha expresión sólo acepta valores enteros o caracteres para entrar a la opción y el
operador de relación es el igual.
Se compara la “expresión” (puede ser una sola variable) con cada una de las opciones
“const” y en el momento de encontrar una constante idéntica se ejecutan la(s)
instrucción(es) correspondiente(s) a ese caso. Al terminar de realizar las
instrucciones del caso, se debe usar la palabra reservada salir (break) para que vaya
al final de la estructura.
Si ninguno de los casos cumple con la expresión, se puede definir un caso por
omisión, que también puede tener instrucciones; la computadora ejecutará la
sentencia caso contrario (default). El default es opcional, si no está presente no se
hace nada.
Hay tres puntos que debemos considerar en la sentencia segun_sea (switch):
33
1. Se diferencia del si (if) en que el primero sólo puede comprobar por igualdad,
mientras que la expresión condicionada del si (if) puede ser de cualquier tipo.
2. No puede tener dos constantes en los casos con idénticos valores en el mismo
segun_sea (switch).
3. La sentencia segun_sea (switch) es más eficiente que el si anidado si-si no-si
(if-else-if).
Notas:
• Si cada caso tiene varias instrucciones no es necesario agruparlas con llaves, ya que
el salir (break) termina el caso.
• Se utilizará segun_sea (switch) para manejar un menú. Un menú nos muestra en
pantalla todas las opciones que podemos realizar con nuestro algoritmo o programa.
Ejercicios resueltos de la estructura de control selectiva múltiple segun_sea
(switch)
Ejercicio 1. Imprimir a qué día de la semana corresponde en número
Este tipo de selectiva múltiple nos sirve para elegir una entre varias opciones. En el
ejercicio anterior el usuario introduce un número del 1 al 7 y se almacena en la
variable dia, posteriormente revisa si el día capturado pertenece a alguno de los siete
casos e imprimirá a qué día de la semana pertenece; la instrucción salir (break) que
se escribe a un lado, le indica al programa que si ya entró en algún caso, no continúe
con lo siguiente, es decir que se salga de la estructura segun_sea (switch), y el
programa pasará el control a la siguiente instrucción que se encuentre después del fin
34
del segun_sea (switch). Si el usuario introduce un valor menor a 1 o mayor que 7 no
entra a ninguno de los casos, sino que entrará a la parte caso contrario (default) e
imprimirá “El día no existe”.
Si día = 3 el programa imprimirá “El día 3 es Miércoles”, si día = 9 el programa
imprimirá “El día no existe”. El formato para imprimir el día dentro de la expresión,
depende del lenguaje.
Si omitimos la instrucción salir (break) recorrerá todos los casos siguientes al
capturado;
Si la variable dia fue 2, pasará por los casos 3, 4, 5, 6 y 7. Observamos que cada caso
no necesita inicio ni fin debido a que el break es el fin de cada uno de ellos.
Es importante recordar que la variable que utiliza el segun_sea (switch) sólo puede
ser algún tipo entero o caracter (char); en nuestro ejemplo la variable dia es tipo int.
Si hubiéramos elegido un tipo real.
float dia en lugar de int dia, el compilador nos enviaría el siguiente mensaje: “Error
Línea 10: Switch selection expression must be of integral type”.
Dos posibles salidas si ejecutamos el programa son:
Escriba el número de día:
2
El 2 corresponde a martes.
Escriba el número de día:
21
El día no existe.
35
Unidad 4: Estructuras algorítmicas II
Estructura de Control repetitiva o de iteración condicionada
Una acción se repite una cantidad definida o indefinida de veces mientras una
condición sea verdadera.
La lógica de programación se centra sobre todo en el cuerpo del programa, utilizando
las estructuras de datos y las de control, además de la programación modular. Para
diseñar los programas de computadora, comúnmente se utilizan diferentes estructuras
de control a fin de poder llegar a la solución de un problema, cuáles y cuántas
dependerán del problema mismo.
Las computadoras están diseñadas primordialmente para aquellas aplicaciones en las
cuales una operación o conjunto de ellas deben repetirse más de una vez.
La repetición de una acción (una o varias instrucciones) se lleva a cabo mientras se
cumpla cierta condición; para que la acción termine, la acción misma debe modificar
la(s) variable(s) de control que interviene(n) en la condición. Dicha condición puede
estar predefinida como en el ciclo desde (for); o no predeterminada, como en los
bucles mientras (while) y hacer-mientras (do_while).
Bucles, ciclo o iteración. Es un segmento de un algoritmo o programa, cuya(s)
instrucción(es) se repite(n) un número conocido o indefinido de veces mientras se
cumpla una determinada condición. En cada vuelta del ciclo comprueba si la
condición es verdadera, rompiéndose el ciclo cuando es falsa. La condición en algún
momento tiene que ser falsa ya que en caso contrario el bucle se hará infinito.
Estructura de control repetitiva mientras (while)
Al ejecutarse la instrucción mientras (while), se evaluará la expresión booleana
suministrada en los paréntesis (condición), y si su valor es verdadero (distinto de
cero) se realizará el ciclo o bucle (una o varias instrucciones).
Después, la condición es reevaluada y se procede de la misma manera. Cuando la
condición se vuelve falsa (es decir, cero), en la siguiente evaluación se dará por
terminado el ciclo mientras (while).
Si la condición nunca se vuelve cero, el ciclo nunca terminará y, dependiendo de las
instrucciones incluidas en el bucle, se generaría un error de ejecución que detendría
el programa, o podría ser que el programa itere indefinidamente hasta ser detenido
en forma manual.
En esta estructura no se conoce necesariamente el número de veces que entrará al
ciclo, ya que esto dependerá de la condición definida
36
Donde condición es cualquier expresión numérica, relacional o lógica.
Características:
1. La condición (expresión lógica) se evalúa antes del ciclo. Si la condición es
verdadera se ejecuta el bucle, y si es falsa se sale y el control pasa a la
instrucción siguiente al ciclo.
2. Si la condición es falsa cuando se revisa por primera vez el bucle no se ejecuta
nunca, es decir no entra ninguna vez.
3. Mientras la condición sea verdadera el bloque de instrucciones se ejecutará
indefinidamente a menos que exista por lo menos una instrucción que
modifique el valor de un elemento de la condición.
4. Si existe más de una instrucción se necesitan las palabras reservadas inicio -
fin ({-}) para delimitar el bloque de instrucciones.
Nota: Existen algunos algoritmos y programas que se pueden efectuar con los tres
ciclos: desde, mientras y hacer_ mientras; aunque cada una tiene sus características
específicas.
Ejercicios resueltos de la estructura de control repetitiva mientras (while)
Ejercicio 1. Mostrar los 10 primeros números enteros positivos.
37
El ejercicio 1 declara la variable i de tipo entero, luego se inicializa con el valor de 1
ya que es el primer número entero positivo; se revisa la condición del mientras (1
<11); como la condición se cumple entra al ciclo y se ejecutan las dos instrucciones
que están delimitadas en el bloque entre inicio-fin ({-}). Así que imprime el 1 y luego
i←i+1 lo podemos interpretar como la nueva i recibe el valor de la i anterior más 1,
incrementando en 1 a la variable i, de tal forma que i = 2, revisa la condición del
mientras otra vez (2 < 11), como la condición sigue siendo verdadera vuelve a entrar
al ciclo, y así sucesivamente hasta que el valor de i sea mayor o igual a 11; esto hará
que se salga del ciclo y termine el programa. Si vemos la instrucción i ← i + 1, se
realiza cada vez que entra al ciclo, esto hace que se cumpla la característica número
tres de la estructura repetitiva mientras, para que en un momento dado i tome un valor
mayor que 10 y se salga del ciclo.
El programa imprimirá 1 2 3 4 5 6 7 8 9 10. El último valor que toma i es 11, hace
que no se cumpla la condición y por lo tanto se sale del ciclo mientras.
Nota: Como se verá más adelante, este ejercicio es igual al ejercicio 1 de la estructura
repetitiva “desde”; la ventaja principal es que el ciclo desde el incremento de su
contador i lo hace de manera automática, y en la estructura “mientras” se debe
realizar en una instrucción dentro del ciclo.
Estructura de control repetitiva hacer_mientras (do while)
Esta estructura le permite al programador especificar que se repita una acción en tanto
cierta condición sea verdadera; cuando ésta es falsa se sale del ciclo. La condición la
revisa después del ciclo o bucle.
38
Existen algoritmos y programas que requieren que por lo menos se ejecute el ciclo
una vez y al final se revise la condición; en este caso utilizamos la estructura
hacer_mientras. Es muy semejante al ciclo mientras, con la diferencia de que la
condición se evalúa después de ejecutar el cuerpo del bucle. Tanto el ciclo mientras
como el hacer_mientras pueden utilizarse cuando no se conoce de antemano el
número de veces que se repetirá el ciclo.
Nota: No es usual que la estructura hacer_mientras (do_while) tenga una sola
instrucción, generalmente tiene por lo menos dos.
Características:
1. Siempre entra por lo menos una vez al ciclo, ya que la condición está después
del ciclo.
2. Si la condición es verdadera entra de nuevo al ciclo y regresa a revisar la
condición, hasta que ésta sea falsa se sale del bucle.
3. Debe existir una instrucción dentro del ciclo que modifique la condición, de
lo contrario se hace infinita.
4. Si tiene más de una instrucción, necesita obligadamente del inicio-fin ({-}).
Ejercicios resueltos de la estructura de control repetitiva hacer_mientras
(do_while)
Ejercicio 1. Imprimir los 10 primeros números enteros positivos.
39
El ejercicio anterior realiza la misma operación que el ejercicio 1 de la estructura
mientras, pero ahora utilizando la estructura repetitiva hacer_mientras. Se declara la
variable i de tipo entero, se inicializa con el valor de 1 ya que es el primer número
entero positivo, se entra al ciclo hacer_mientras y se imprime el valor de la variable
i = 1, se incrementa la variable i en 1, es decir i = 2 y se revisa la condición del
hacer_mientras (2 < 11). Como la condición se cumple entra al ciclo y se ejecutan
las dos instrucciones que están delimitadas en el bloque entre inicio-fin ({-}), se
imprime el valor de la variable i = 2, se incrementa la variable i en 1, es decir i = 3,
se revisa la condición del hacer_mientras (3 < 11). Como la condición se cumple
entra al ciclo y se ejecutan las dos instrucciones que están delimitadas en el bloque
entre inicio-fin ({-}), se imprime el valor de la variable i = 3, se incrementa la
variable i en 1, es decir i = 4 y se revisa la condición del hacer_ mientras (4 < 11).
Como la condición se cumple entra al ciclo y se ejecutan las dos instrucciones que
están delimitadas en el bloque entre inicio-fin ({-}) y así sucesivamente hasta que
i=11. Cuando se revisa la condición, como ésta no se cumple se sale del ciclo
hacer_mientras y termina el programa; esto hace que se cumpla la característica 3 de
la estructura repetitiva hacer_mientras, para que en un momento dado i tome un valor
mayor a 10 y se salga del ciclo. El programa imprimirá 1 2 3 4 5 6 7 8 9 10. El último
valor que toma i es 11 y por lo tanto no se cumple la condición y se sale del ciclo.
Nota: En el programa primero entra al ciclo y después revisa si la condición es
verdadera, hasta que ésta se hace falsa se sale del ciclo e imprime el valor de la suma
S.
40
Estructura de control repetitiva desde (for)
El desde (for) es la estructura repetitiva más utilizada y simple de manejar, ya que
repite un conjunto de instrucciones un número determinado de veces. Una de sus
aplicaciones principales son los arreglos.
Dónde:
expr_ini(s): expresión(es) de asignación que se utilizan para iniciar la(s) variable(s)
de control del bucle.
cond: es una expresión relacional o lógica (booleana) que determina cuándo
finalizará el ciclo o bucle. La condición puede ser simple o compuesta (una o varias).
inc(s): define cómo cambiará(n) la(s) variable(s) de control cada vez que se repite el
bucle o ciclo.
Las tres componentes pueden tener una o varias instrucciones, las cuales deben ir
separadas por comas. La cond nos lleva al valor final.
Omisión de expresiones
Cualquiera de los componentes en los paréntesis se puede omitir, incluso los tres,
pero los separadores coma (punto y coma) deben aparecer siempre.
Las tres expresiones del bucle desde (for) se pueden omitir, con el siguiente
resultado:
41
En la instrucción desde (for), primero se ejecutará la(s) inicialización(es),
posteriormente se evaluará la condición y, en caso de ser verdadera (no cero), se
ejecutará(n) la(s) instrucción(es) que compone(n) el ciclo.
Después, se realizará el incremento(s) y se volverá a verificar la condición. Cuando
la condición se vuelve falsa, en la siguiente evaluación se terminará el desde (for). Si
la condición nunca se vuelve cero, la estructura nunca terminará y el ciclo se repetirá
indefinidamente hasta que se detenga en forma manual.
Características:
1. Se debe conocer por anticipado el valor de la variable inicial y final antes de
entrar al ciclo.
2. La condición se evalúa antes del bloque de instrucciones. Si la condición es
verdadera se ejecuta el bloque, y si es falsa se sale y pasa el control a la
instrucción siguiente al bloque.
3. No se debe cambiar el valor de la(s) variable(s) de control, del valor inicial ni
del valor final dentro del ciclo.
4. Se puede incrementar o decrementar la variable de control según se requiera.
5. El incremento o decremento de la variable de control es automático.
6. Sólo si existe más de una instrucción dentro del ciclo desde se necesita el
inicio-fin ({-}).
7. Puede tener una o varias expresiones de inicialización, de condición y de
incremento; estas expresiones se separan mediante comas en pseudocódigo y
con puntos y comas en lenguaje C.
8. Puede tener alguna o todas las expresiones vacías: desde (,,)-for (; ;).
9. Si la condición está vacía, tenemos un bucle infinito.
Ejercicios resueltos de la estructura de control repetitiva desde (for)
Ejercicio 1. Imprimir en pantalla los primeros 10 números enteros positivos.
42
En el ejercicio 1 antes de entrar al ciclo desde, se declara la variable i, ésta inicia con
el valor de 1, se evalúa la condición (i<=10), es decir (1<=10), como es verdadera,
entra al ciclo e imprime el 1, en seguida la i se incrementa en 1 (i←i+1)
convirtiéndose en 2; en la segunda vuelta se evalúa la condición (2<=10), como es
verdadera entra al ciclo e imprime el 2, en seguida la i se incrementa en 1 y se
convierte en 3; de la tercera a la décima vuelta todas las condiciones son verdaderas
(3<=10, 4<=10, 5<=10, 6<=10, 7<=10, 8<=10, 9<=10, 10<=10) y se imprime 3 4 5
6 7 8 9 y 10; en la décima vuelta después de imprimir el 10, cuando la i se incrementa
en 1 y vale 11, la condición (11<=10) será falsa y por lo tanto se rompe el ciclo (deja
de dar vueltas).
El programa anterior realiza exactamente lo mismo, la diferencia es que las
condiciones que revisa son: (1<11), (2<11), (3<11), (4<11), (5<11), (6<11), (7<11),
(8<11), (9<11), (10<11), todas ellas son verdaderas y se imprime: 1 2 3 4 5 6 7 8 9 y
10; en la décima vuelta después de imprimir el 10, cuando la i se incrementa en 1 y
vale 11, la condición (11<11) será falsa y por lo tanto se rompe el ciclo (deja de dar
vueltas).
En este programa la variable contador del ciclo es i. Las tres partes del for son:
La expresión de inicialización es i=1, la condición es (i<=10), dicha condición nos
lleva al valor final 10, y el incremento es i++, es decir que a la i en cada vuelta se le
suma 1.
Nota: La instrucción for no debe llevar punto y coma al final del paréntesis: for
(i=1;i<=10;i++) ya que no respetará la impresión de i dentro del ciclo, imprimirá el
valor de i que rompió el ciclo, en este caso 11.
43
Unidad 5: Codificación
5.1.Elementos del lenguaje Visual Basic
¿Qué es Visual Basic?
Visual Basic es un lenguaje de programación que permite crear aplicaciones (programas)
para Windows. Usando Visual Basic se pueden construir en forma fácil, programas con una
interfaz gráfica que puede incorporar elementos como ventanas, botones, cuadros de
diálogo, cuadros de texto, botones de opción y de selección, barras de desplazamiento,
menús, etc., propios de cualquier aplicación bajo Windows.
En una aplicación Visual Basic, el programa está formado por una parte de código puro, y
otras partes asociadas a los objetos que forman la interfaz gráfica. Es por tanto, un término
medio entre la programación tradicional, formada por una sucesión lineal de código
estructurado, y la programación orientada a objetos. Combina ambas tendencias sin
embargo, no puede decirse que Visual Basic pertenezca por completo a uno de esos dos
tipos de programación.
En este capítulo se especifican los fundamentos básicos del lenguaje Visual Basic y la
sintaxis utilizada para crear el código de los programas. Además, se explican programas
muy sencillos que siguen el enfoque de programación tradicional, es decir, programas
secuenciales donde el usuario introduce los datos, el programa hace los cálculos y muestra
los resultados.
44
5.2.Tipos de datos
Declaración de variables y constantes
La declaración de variables o constantes implica decirle a la computadora cuántas
variables y/o constantes se utilizarán en el programa, cómo se llamarán y el tipo de
datos que contendrán.
Declaración de constantes
Para declarar una constante en Visual Basic únicamente es necesario utilizar la
palabra CONST seguida del nombre de la constante y su correspondiente valor. La
sintaxis es:
Const nombre_constante = valor
Donde:
Nombre_constante: es el nombre que el programador le da a la constante
que se está declarando.
Valor: valor asignado a la constante.
Ejemplo de declaración de constantes:
Const PI = 3.1416
Const Max = 350
Const Saludo = “Hola”
45
Declaración de variables
En Visual Basic hay diferentes formas de declarar una variable. La Sentencia DIM
es la forma más común. Puede emplearse en un Procedimiento, Función, Formulario
o Módulo. La sintaxis es la siguiente:
Dim nombre_variable As tipo
Donde:
Nombre_variable: es el nombre que el programador le da a la variable que
se está declarando.
Tipo: tipo de dato asociado a la variable.
Se le puede colocar cualquier nombre a una variable, siempre y cuando cumpla con
las siguientes reglas:
1. El nombre de una variable tiene que comenzar siempre por una letra y puede
contener hasta 255 caracteres.
2. El nombre sólo puede contener letras, números y el carácter de subrayado (_).
No se aceptan espacios en blanco.
3. No pueden utilizarse como nombres de variables las palabras reservadas de
Visual Basic, como por ejemplo: if, next, for, val, caption, etc. Para saber
cuáles son las palabras reservadas se puede consultar el Help de Visual Basic,
en la referencia Reserved Words. Las palabras reservadas aparecen en color
azul cuando se escribe el código del programa.
Ejemplos de declaraciones de variables:
Dim Edad as byte
Dim Nom_Estudiante as string
Dim salario as single
Dim area as double, saldo as single
Dim X, Y as integer
Mediante estas declaraciones, el programa sabe de qué tipo de dato se trata y por
tanto cómo debe trabajar con él. Existen otras formas de declarar las variables en
Visual Basic, aquí sólo se utilizará DIM.
Visual Basic no distingue entre mayúsculas y minúsculas. Por ejemplo, las variables
SalarioTotal y salariototal son consideradas como una misma variable y no como
dos.
En Visual Basic no es necesario que se declaren todas las variables que se van a
utilizar. Cuando en el código se escribe una variable nueva que no ha sido declarada,
46
Visual Basic asume que es una variable y que su tipo es el adecuado para el valor
que le está asignando en ese momento. Por ejemplo, si Visual Basic encuentra estas
instrucciones
Nombre ="Pedro González"
CI = "1234567"
Nota=18
Entiende que Nombre, CI y Nota son variables, que Nombre y CI son cadenas de
caracteres (string) porque su valor está entre comillas, y que Nota es un número (su
valor no está entre comillas).
Esta particularidad de no necesitar declarar las variables hace que sea sencillo
introducir una variable nueva. Sin embargo, puede ser una fuente de errores.
Supóngase que en un paso posterior del programa, se desea hacer una operación con
la variable Nota, y que por error el programador escribe Nata en vez de Nota. Visual
Basic interpreta que Nata es una variable e irá a leer en memoria el valor que tiene.
No tendrá ningún valor. Por lo tanto la operación no se hará en forma correcta y
además no dará ningún aviso de que se ha cometido un error.
Para evitar este tipo de errores se recomienda declarar todas las variables que se van
a utilizar en el programa. Para que Visual Basic dé un mensaje de error cuando se
utiliza una variable no declarada previamente se puede utilizar la instrucción Option
Explicit, la cual se explica a continuación.
Option Explicit
Obliga a declarar previamente las variables que se vayan a usar. De no haberla
declarado antes de usarla, el programa dará una comunicación de error.
Instrucción de asignación
Una vez que se elige un nombre y un tipo de dato para una variable, se le debe dar
un valor. Existen tres métodos principales para dar valores a una variable:
1. Asignarle un valor dentro del programa.
2. Pedir al usuario que teclee un valor.
3. Leer un valor de un archivo de datos.
En esta sección se explicará la instrucción de asignación. La introducción de valores
con el teclado se tratará en el apartado 2.5 de este tema. La lectura de archivos no se
incluye en estos apuntes. La sintaxis de una instrucción de asignación es:
Nombre_variable = valor o expresión
47
Ejemplos:
1) A = X+Y +2
El resultado de sumar las variables X y Y, se le asigna a la variable
A.
2) Salario = 1250000
A la variable salario se le asigna el valor 1250000
3) Nombre_ alumno = “José Rodríguez”
A la variable nombre_alumno se le asigna el valor José Rodríguez.
Obsérvese que cuando se asigna una cadena de caracteres, ésta debe
ir entre comillas.
4) A=B
El contenido de la variable B se asigna a la variable A
Existen algunas reglas para instrucciones de asignación que hay que tener presente:
1. Sólo un nombre de variable puede ir a la izquierda del signo igual, porque
indica la ubicación de memoria que cambiará.
2. El valor a la derecha del signo igual puede ser una constante (ejemplos b y
c), otra variable (ejemplo d) o una fórmula o expresión que combine
constantes y variables (ejemplo a).
3. La variable y su valor deben ser del mismo tipo de datos.
5.3.Funciones
Funciones de Conversión
Asc
AscW
CBool (Función)
CByte (Función)
CChar (Función)
CDate (Función)
CDbl (Función)
CDec (Función)
Chr
ChrW
CInt (Función)
CLng (Función)
CObj (Función)
CSByte (Función)
CShort (Función)
CSng (Función)
CStr (Función)
CType (Función)
CUInt (Función)
CULng (Función)
CUShort (Función)
Format
Hex
Oct
Str
Val
48
Funciones Matemáticas
Método Descripción
Abs Devuelve el valor absoluto de un número.
Acos Devuelve el ángulo cuyo coseno es el número especificado.
Asin Devuelve el ángulo cuyo seno es el número especificado.
Atan Devuelve el ángulo cuya tangente corresponde al número especificado.
Atan2 Devuelve el ángulo cuya tangente es el cociente de dos números
especificados.
BigMul Devuelve el producto completo de dos números de 32 bits.
Ceiling Devuelve el valor entero más pequeño que es mayor o
igual Decimal especificado o Double.
Cos Devuelve el coseno del ángulo especificado.
Cosh Devuelve el coseno hiperbólico del ángulo especificado.
DivRem Devuelve el cociente de dos de 32 bits o de enteros con signo de 64 bits, y
también devuelve el resto de un parámetro de salida.
Exp Devuelve e (base de los logaritmos naturales) se produce a la potencia
especificado.
Floor Devuelve el entero más grande que sea menor o igual que Decimal o el
número especificado de Double.
IEEERemainder Devuelve el resto que es el resultado de la división de un número
especificado por otro número especificado.
Log Devuelve el logaritmo natural (de e base) de un número especificado o el
logaritmo de un número especificado en una base especificada.
Log10 Devuelve el logaritmo en base 10 de un número especificado.
Max Devuelve el mayor de dos números.
Min Devuelve el menor de dos números.
Pow Devuelve un número especificado elevado a la potencia especificada.
49
Round Devuelve un valor de Decimal o de Doubleredondeado al valor entero más
cercano o a un número especificado de dígitos fraccionarios.
Sign Devuelve un valor Integer que indica el signo de un número.
Sin Devuelve el seno del ángulo especificado.
Sinh Devuelve el seno hiperbólico del ángulo especificado.
Sqrt Devuelve la raíz cuadrada de un número especificado.
Tan Devuelve la tangente del ángulo especificado.
Tanh Devuelve la tangente hiperbólica del ángulo especificado.
Truncate Calcula la parte entera de Decimal o un número especificado de Double.
Funciones de Cadena
Método Descripción
Asc Devuelve un valor de tipo Integer que representa el código de
carácter que corresponde a un carácter.
Chr Devuelve el carácter asociado al código de carácter especificado.
Filter Devuelve una matriz basada en cero que contiene un subconjunto de
una matriz String basada en criterios de filtro especificados.
Format Devuelve una cadena con el formato que especifiquen las
instrucciones contenidas en una expresión String de formato.
FormatCurrency Devuelve una expresión con formato de moneda en la que se utilizará
el símbolo de moneda que se haya definido en el panel de control del
sistema.
FormatDateTime Devuelve una expresión de cadena que representa un valor de fecha u
hora.
FormatNumber Devuelve una expresión con formato de número.
FormatPercent Devuelve una expresión con formato de porcentaje (multiplicada por
100), acompañada del carácter final %.
InStr Devuelve un entero que especifica la posición inicial de la primera
aparición de una cadena dentro de otra.
InStrRev Devuelve la posición de la primera aparición de una cadena dentro de
otra, comenzando por el extremo derecho de la cadena.
LCase Devuelve una cadena o un carácter convertidos en minúscula.
Left Devuelve una cadena que contiene un número especificado de
caracteres a partir del lado izquierdo de una cadena.
50
Len Devuelve un entero que contiene el número de caracteres de una
cadena.
LSet Devuelve una cadena alineada a la izquierda que contiene la cadena
especificada ajustada a la longitud indicada.
LTrim Devuelve una cadena que contiene una copia de una cadena
especificada sin espacios iniciales.
Mid Devuelve una cadena que a su vez contiene un número especificado
de caracteres de una cadena.
Replace Devuelve una cadena en la que la subcadena especificada se
reemplaza determinado número de veces por otra subcadena.
Right Devuelve una cadena que contiene un número especificado de
caracteres desde el lado derecho de una cadena.
RTrim Devuelve una cadena que contiene una copia de una cadena
especificada sin espacios finales.
Space Devuelve una cadena que consta del número especificado de
espacios.
StrComp Devuelve un valor, -1, 0 ó 1, que indica el resultado de una
comparación de cadena.
StrConv Devuelve una cadena convertida según se ha especificado.
StrDup Devuelve una cadena o un objeto que se compone del carácter
especificado repetido el número de veces especificado.
StrReverse Devuelve una cadena en la que se invierte el orden de los caracteres
de la cadena especificada.
Trim Devuelve una cadena que contiene una copia de una cadena
especificada sin espacios iniciales o finales.
UCase Devuelve una cadena o un carácter que contiene la cadena
especificada convertida en mayúsculas.
5.4.Operaciones de entrada y salida
Recuérdese que el flujo básico del procesamiento por computadora es entrada,
proceso, salida. En los problemas que aquí se resuelven, se asume que hay un usuario
sentado frente a la computadora introduciendo datos con el teclado, el programa
acepta estos datos (entrada), los procesa y luego muestra el resultado en la pantalla
(salida).
En Visual Basic existen varias formas de gestionar las entradas y salidas. En este
capítulo se explicarán las más simples: cuadros de entrada (InputBox) y cuadros de
Mensaje (MsgBox).
Inputbox
Un InputBox es una ventana donde se le solicita información al usuario, tal como
puede verse en el siguiente ejemplo:
51
El InputBox escribe un mensaje que da información al usuario, en la figura 2.1 le
está indicando que escriba la edad. Además presenta un cuadro donde el usuario
puede escribir lo que se le está solicitando.
Sintaxis:
Nombre_variable = InputBox (“mensaje”)
Donde:
Nombre_variable: corresponde al nombre de la variable en la cual se
almacenará el valor que escriba el usuario
Mensaje: es la frase que aparecerá en el InputBox antes del cuadro donde el
usuario puede escribir su respuesta. El mensaje debe ir entre comillas.
Los cuadros de entrada o InputBox siempre incluyen los botones Aceptar y Cancelar.
Si el usuario hace clic en Aceptar (o presiona la tecla Enter), lo que haya escrito se
almacenará en la variable indicada (para el ejemplo, sería la variable edad). Si se
presiona cancelar, a la variable se le asigna una cadena vacía (“ ”).
Un InputBox tiene como título predeterminado el nombre dado al proyecto Visual
Basic en el momento de guardar, por ejemplo, en la figura anterior se observa que el
título es Proyecto1. Sin embargo, es posible colocarle un título diferente, así como
también un valor predeterminado para la respuesta. En ese caso la sintaxis es:
Nombre_variable = InputBox (“mensaje”, “título”, valor predeterminado)
52
Esta instrucción despliega un cuadro de entrada como el siguiente:
Observe que el valor por defecto es Venezuela, esto significa que el mismo aparecerá
como respuesta predeterminada. Si el usuario está de acuerdo hace clic en Aceptar.
Si no está de acuerdo puede escribir otro país.
MsgBox
Un MsgBox o cuadro de mensaje es una ventana donde se puede dar información
al usuario. En la figura 2.3 se muestra un MsgBox.
Sintaxis
MsgBox (“mensaje”)
El MsgBox muestra el mensaje y luego espera que el usuario haga clic en Aceptar.
53
Si se desea colocar mensajes y variables en un MsgBox, éstos se concatenan con el
signo &. A continuación se dan algunos ejemplos:
Ejemplo 2: Supóngase que se tiene el siguiente código:
a=7
num = 4*a
MsgBox ("El número seleccionado es" & num)
Estas instrucciones hacen que un programa muestre el siguiente cuadro de mensaje:
Ejemplo 3:
La instrucción
MsgBox ("línea 1" & Chr(10) & "línea 2")
Muestra el cuadro de mensaje:
Existen opciones que permiten cambiar la apariencia de un cuadro de mensaje,
mostrando otros botones además del botón Aceptar, un título específico, un icono,
etc. Así por ejemplo, si se desea colocar otros botones y/o un título específico en un
MsgBox, debe utilizarse la siguiente sintaxis:
Nombre_variable = Msgbox (“mensaje”, tipos_de_botones, “título”)
Nombre_variable: se refiere a una variable donde se almacenará un número
entero entre 1 y 7, el cual indica el botón sobre el cual el usuario hizo clic. En
el cuadro 2.4 se muestra el significado de cada número.
54
Tipos_de_ botones: es un número entero entre 0 y 5, o una constante de Visual
Basic que indica la combinación de botones que se desea para el MsgBox. En
el cuadro 2.5 se muestran los posibles valores.
Título: texto que aparecerá en la barra de título del cuadro de mensaje.
Valores de retorno de un MsgBox
Botones que pueden mostrarse en un MsgBox
Ejemplo 4:
Resp = MsgBox(“El inventario ha finalizado“,0,“Sistema de Inventarios “)
Ejemplo 5:
En el siguiente código se utiliza una constante Visual Basic para mostrar los
botones Sí y No
R = Msgbox (“¿Desea introducir nuevos datos? “, vbYesNo, “Estadística 1.0“)
55
Para incluir un icono en un cuadro de mensaje, se suma al parámetro
tipos_de_botones el valor o constante Visual Basic que representa a un determinado
icono. En el cuadro 2.6 se muestran los tipos de iconos disponibles.
Tipos de iconos para un MsgBox
Ejemplo 6:
El siguiente código muestra un mensaje de error con un icono.
Resp = MsgBox (“Error: ha introducido un dato inválido“, 5 + 16, “Cálculos“)
Ejemplo 7:
Para mostrar el cuadro de mensaje del ejemplo 5 con un icono de interrogación, se
escribe la siguiente instrucción:
R = Msgbox (“¿Desea introducir nuevos datos? “, vbYesNo + 32, “Estadística 1.0 “)
56
Ejemplo 8:
Resp = MsgBox (“Faltan datos por introducir “, vbexclamation, “Advertencia”)
Esta instrucción despliega el cuadro de mensaje de la figura 2.10. Obsérvese que el
MsgBox sólo tiene el botón Aceptar, en ese caso no es necesario colocar 0 +
vbexclamation ó vbOkonly + vbexclamation, en el segundo parámetro.
5.5.Codificación
Ya se conocen los elementos básicos que permitirán escribir los primeros programas en Visual
Basic. Lo que falta es colocar todo –entrada, proceso y salida – en un programa completo que
la computadora pueda entender.
Ya que por ahora no se utilizan las herramientas visuales del lenguaje Visual Basic (formularios,
controles, etc.), el código se coloca en una subrutina (sección de código) llamada Sub Main, la
cual es el punto de partida del programa.
Escritura de programas
Ejercicios
Ejemplo 1: Programa que eleva un número entero al cuadrado (el número debe ser
suministrado por el usuario).
Código del programa:
Option explicit
Sub main()
Dim num As Integer, cuadrado As Integer
57
num = InputBox("introduzca el número que desea elevar al cuadrado")
cuadrado = num * num
MsgBox (Str(num) + " elevado al cuadrado es" & cuadrado)
End Sub
Ejemplo 2: Programa que calcula el área de un triángulo.
Option explicit
Sub main()
Dim b As Single, h As Single, area As Single
b = InputBox("Introduzca la base")
h = InputBox("Introduzca la altura")
area = b * h / 2
MsgBox (" El área del triángulo es" & area )
End Sub
Ejemplo 3: programa que calcular el precio total a pagar por un artículo si se tiene como
dato el precio de venta y se sabe que el IVA es del 16%.
Option explicit
Sub main()
Dim pv As Single, iva As Single, pt As Single
pv = InputBox("Precio de venta")
iva = 0.16 * pv
pt = pv + iva
MsgBox (" Precio total a pagar" & pt )
End Sub
Estructuras de decisión simple
If expresión lógica Then
Una o varias instrucciones
End If
Ejemplo 1: programa que calcula el salario neto de un trabajador, teniendo como entrada
su salario base y el número de hijos. Al trabajador se le descuenta el 5% de su salario base
por concepto de seguro social, pero si tiene más de dos hijos se le pagan 50.000 Bs.
adicionales.
58
Option Explicit
Sub main()
Dim sb As Single, nh As Byte, sn As Single
sb = InputBox("Salario base: ")
nh = InputBox("Número de hijos")
sn = sb - 0.05 * sb
If nh > 2 Then
sn = sn + 50000
End If
MsgBox ("Salario Neto = " & sn)
End Sub
Ejemplo 2: programa que calcula el precio total a pagar por la compra de un artículo,
considerando que el IVA es del 16%. Si el precio es mayor de 100.000 Bs. se realiza un
descuento del 1%.
Option explicit
Sub main()
Dim Pv As Single, Pt As Single
Pv = InputBox("Introduzca el precio de venta del artículo")
If Pv > 100000 then
Pv = Pv - 0.01 * Pv
End If
Pt = Pv + 0.16 * Pv
MsgBox (" El precio total a pagar es " & pt)
End Sub
Estructuras de decisión doble
Se utilizan cuando la computadora debe elegir entre dos alternativas dependiendo de
una condición. Una estructura de decisión doble evalúa una expresión lógica, si ésta
es verdadera se ejecuta un conjunto de instrucciones, y si es falsa se ejecuta otro
conjunto de instrucciones. En Visual Basic, una estructura de decisión doble se
escribe de la siguiente manera:
59
If expresión lógica Then
Una o varias instrucciones
Else
Una o varias instrucciones
End If
Si la expresión lógica es verdadera se ejecutan las instrucciones que están a
continuación de Then, y si la expresión es falsa, se ejecutan las instrucciones que
están después de Else.
Ejemplo 3: programa que calcula el promedio de un estudiante dadas tres calificaciones. Si
el promedio es mayor o igual que 9.5 se debe mostrar un mensaje que indique
“APROBADO”. En caso contrario, el mensaje debe ser “REPROBADO”.
Option explicit
Sub main()
Dim C1 As Single, C2 As Single, C3 As Single, prom As Single
C1 = InputBox("Introduzca la calificación 1")
C2 = InputBox("Introduzca la calificación 2")
C3 = InputBox("Introduzca la calificación 3")
Prom = (C1 + C2 + C3) / 3
If Prom >= 9.5 then
MsgBox (" Promedio=" & prom & Chr(10) & Chr(10) &
"APROBADO")
Else
MsgBox (" Promedio=" & prom & Chr(10) & Chr(10) &
"REPROBADO")
End If
End Sub
Ejemplo 4: Programa que calcula el valor de Y, el cual está dado por la siguiente ecuación
𝑦 =𝑥3+5
𝑥 . Si x = 0 debe dar un mensaje de error e indicar que no puede realizarse el
cálculo.
Option Explicit
Sub main()
Dim X As Single, Y As Single, resp As Byte
60
X = InputBox("Escriba el valor de X")
If X = 0 Then
resp = MsgBox("No puede realizarse el cálculo" & Chr(10) & "X debe
ser diferente de cero", vbCritical, "Error")
Else
Y = (X ^ 3 + 5) / X
MsgBox ("El valor de Y es " & y)
End If
End Sub
Ejemplo 5: Programa que calcula la comisión que le corresponde a un vendedor. Si vendió
más de Bs. 1.000.000, la comisión es el 3% sobre las ventas. Si vendió Bs.1.000.000 o
menos, la comisión es del 1% de las ventas.
Option Explicit
Sub main()
Dim Ventas As Single, Com As Single
Ventas = InputBox("Introduzca el monto vendido (Bs.)")
If Ventas > 1000000 Then
Com = 0.03 * Ventas
Else
Com = 0.01 * Ventas
End If
MsgBox (" Comisión del vendedor=" & Com )
End Sub
Estructuras de decisión anidadas
Se utilizan cuando hay más de dos alternativas entre las cuales se puede elegir.
Cuando en una estructura de decisión, alguna de sus instrucciones es otra estructura
de decisión, se dice que las estructuras están anidadas. Visual Basic permite escribir
las estructuras anidadas haciendo uso de estructuras If – then – else, tal como se
muestra a continuación.
If expresión lógica then
Una o más instrucciones
61
Else
If expresión lógica then
Una o más instrucciones
Else
If expresión lógica then
Una o más instrucciones
End If
End If
End If
Esta sintaxis corresponde a un esquema de anidamiento.
Ejemplo 6: programa para clasificar una especie forestal de acuerdo a su resistencia. El
dato de entrada del programa es el porcentaje de pérdida de peso de la especie y la salida es
uno de los siguientes mensajes.
Mensaje % Pérdida de peso
Altamente resistente [0 – 1]
Resistente (1 - 5]
Moderadamente resistente (5 – 10]
Muy poco resistente (10- 30]
No resistente Más de 30
Option Explicit
Sub main()
Dim pp as Single
Pp = InputBox ("Introduzca el porcentaje de pérdida de peso")
If pp <=1 then
MsgBox ("Especie forestal altamente resistente")
Else
If pp <= 5 then
MsgBox ("Especie forestal resistente")
Else
If pp <= 10 then
MsgBox ("Especie forestal moderadamente resistente")
Else
If pp<= 30 then
MsgBox ("Especie forestal muy poco resistente")
Else
MsgBox ("Especie forestal resistente")
End If
62
End If
End If
End If
End Sub
Ejemplo 7: Programa para calcular el precio a pagar por la compra de madera. Los datos
de entrada son la cantidad de metros cúbicos a comprar, el precio por metro cúbico y el tipo
de madera. La madera está clasificada en tres tipos (A, B y C). Si la cantidad a comprar es
superior a 30 metros cúbicos, se aplica el siguiente esquema de descuento:
Tipo de madera Descuento
A 4 %
B 8 %
C 10 %
Si la cantidad comprada es inferior a 30 metros cúbicos el descuento es del 2%,
independientemente del tipo de madera.
Option Explicit
Sub main()
Dim cant as Single, pre as Single, pre_tot as Single, desc as Single
Dim TipoM as String
TipoM = InputBox ("Introduzca el tipo de madera")
cant = InputBox ("Introduzca la cantidad en metros cúbicos a comprar")
pre = InputBox ("Introduzca el precio por metro cúbico")
pre_tot = cant * pre
If cant > 30 then
If TipoM= "A" then
Desc = 0.04 * pre_tot
Else
If TipoM = "B" then
Desc = 0.08 + pre_tot
Else
If tipoM = "C" then
Desc = 0.1 * pre_tot
End If
End If
End If
63
Else
Desc= 0.02 * pre_tot
End If
Pre_tot = pre_tot – Desc
MsgBox (" El precio total a pagar es " & pre_tot)
End Sub
Ejemplo 8: programa que determina cuál es el mayor de tres números.
Option Explicit
Sub main()
Dim a As Single, b As Single, c As Single, mayor As Single
a = InputBox("Escriba el primer número")
b = InputBox("Escriba el segundo número")
c = InputBox("Escriba el tercer número")
If a > b Then
If a > c Then
mayor = a
Else
mayor = c
End If
Else
If b > c Then
mayor = b
Else
mayor = c
End If
End If
MsgBox (" El número mayor es = " & mayor)
End Sub
Estructuras de decisión múltiple
Al igual que las estructuras de decisión anidadas, las estructuras múltiples se utilizan
cuando se quiere elegir entre varias alternativas. En una estructura de decisión
múltiple se especifica una variable o expresión, la cual puede tomar diferentes
valores, dependiendo del valor que tenga se ejecutarán las instrucciones pertinentes.
Select Case Variable o Expresión
Case primer valor
64
Una o más instrucciones (1)
Case segundo valor
Una o más instrucciones (2)
Case tercer valor
Una o más instrucciones (3)
.
.
.
Case Else
Una o más instrucciones (4)
End Select
El Select Case funciona de la siguiente manera: si la variable o expresión toma el
primer valor se ejecuta el bloque de instrucciones (1), si es igual al segundo valor se
ejecutan las instrucciones (2), y así sucesivamente. En el caso de que la variable o
expresión no sea igual a ninguno de los valores especificados, se ejecutan las
instrucciones que están después del Else. Una vez que Visual Basic ejecuta el Case
que coincida, ignorará los Case restantes y continuará con el código que esté después
del End Select.
La parte Case Else de la estructura Select Case es opcional, sólo se coloca si es
necesario. Si no se utiliza Case Else y la variable no toma ninguno de los valores
especificados en los Case, se ejecuta el código que sigue a End Select.
Ejemplo 8: Programa que recibe como dato de entrada un número entero entre 1 y 7, y
escribe el día de la semana correspondiente.
Option explicit
Sub main( )
Dim número as Integer
número = InputBox (“Escriba un número entre 1 y 7 “)
Select Case número
Case 1
MsgBox (“Domingo“)
Case 2
MsgBox (“Lunes“)
Case 3
MsgBox (“Martes“)
Case 4
MsgBox (“Miércoles“)
Case 5
MsgBox (“Jueves“)
Case 6
MsgBox (“Viernes“)
65
Case 7
MsgBox (“Sábado“)
Case Else
MsgBox (“Número fuera de rango“)
End Select
End Sub
Existen dos formatos adicionales del Select Case, que permiten utilizar esta
estructura cuando se desea hacer comparaciones o utilizar un rango de valores.
Ejemplo 9: Programa que clasifica a una persona de acuerdo a su edad, Las posibles
clasificaciones son: bebé, niño, adolescente, adulto y anciano.
Option Explicit
Sub main()
Dim edad As Integer
Dim Tipo As String
edad = InputBox("Escriba la edad")
Select Case edad
Case Is < 2:
Tipo = "Bebé"
Case 2 To 12:
Tipo = "Niño"
Case 13 To 18:
Tipo = "Adolescente"
Case 19 To 69:
Tipo = "Adulto"
Case Is >= 70:
Tipo = "Anciano"
End Select
MsgBox (Tipo)
End Sub
Como puede observarse en los ejemplos, un Select Case cumple la misma función
que una estructura de decisión anidada con If -Then -Else, pero de una forma más
ordenada, la única desventaja es que sólo es posible evaluar una expresión, mientras
que con If pueden usarse tantas como sean necesarias. Por ejemplo, si en un
programa se quiere hacer un descuento a los clientes tipo A que compren un monto
superior a 200000 Bs, no puede usarse un Select Case ya que hay que considerar
dos criterios para tomar la decisión, uno referente al tipo de cliente y el otro al
monto de la compra. Es precisamente por eso que existen estas dos posibilidades,
estructuras de decisión anidadas y múltiple, cuando una no es válida, se puede usar
la otra.
66
EJERCICIOS PROPUESTOS
1. Determinar la cantidad total a pagar por una llamada telefónica, teniendo en cuenta
lo siguiente:
- Toda llamada que dure tres minutos o menos tiene un costo de 300 Bs.
- Cada minuto adicional a partir de los tres primeros cuesta 150 Bs.
2. Se quiere un programa que permita calcular el precio a pagar por la compra de un
artículo. El IVA a pagar es del 15% y si el precio bruto (precio de venta + IVA) es
mayor de 150.000 Bs. se debe realizar un descuento del 1%.
3. Los empleados de una fábrica trabajan en uno de los siguientes turnos: diurno o
nocturno. Se desea calcular el salario de un trabajador de acuerdo con lo siguiente:
- La tarifa diurna es de 1.000 Bs./hora
- La tarifa nocturna es de 1.500 Bs./hora
4. Dado un número entero N, determinar si es par.
5. Escribir un programa que clasifique a un entero x en una de las siguientes
categorías y muestre un mensaje apropiado
- x < 5
- 5 <= x <= 50
- x > 50
6. Hacer un programa que resuelva una ecuación de segundo grado AX2P + BX + C =
0.
7. Calcular el salario total de un trabajador teniendo en cuenta su salario base y el
número de horas extra trabajadas. Para el pago de las horas extra se debe considerar
la categoría del trabajador, de acuerdo a la siguiente tabla:
Categoría Precio de la hora extra
A 4000
B 3000
C 2500
D 1000
8. Escribir un programa que permita introducir el número de un mes (1 a 12) y
muestre el número de días que tiene ese mes.
9. Una compañía consultora requiere un programa calcule el precio que debe cobrar
por una asesoría. El precio por hora viene dado por el tipo de asesoría, tal como se
indica en la siguiente tabla:
Tipo de asesoría Costo ($/hora)
A 3000
B 2000
C 1000
D 500
En estos momentos, la compañía desea aplicar un descuento especial que depende
del número de horas de asesoría:
67
Número de horas Descuento
< 5 No hay descuento
[5, 10) 5 %
[10, 15) 8%
>= 15 10%
10. Escribir un programa que tenga como dato de entrada una calificación alfabética A,
B, C, D, E, o F, y muestre la correspondiente calificación numérica: 20, 17, 14, 10,
5, 0, respectivamente.
11. Un negocio mayorista que vende tablas de madera de ciertas medidas y especie, tiene
clasificado a sus clientes en tres tipos: 1 (si paga a tiempo), 2 (si se retrasa con los
pagos) y 3 (si es un cliente nuevo). Este negocio necesita un programa que dado el
número de tablas que un cliente compra, el precio unitario (precio de una tabla) y el
tipo de cliente, calcule el precio total que dicho cliente debe pagar, considerando un
descuento. Si el cliente es tipo 1 el descuento es del 15%, si es tipo 2 tiene un
descuento del 5%, y si es tipo 3 tiene un descuento del 2%.
Estructuras de Repetición
Las estructuras de repetición permiten ejecutar un conjunto de instrucciones varias
veces, tantas como sea necesario. También se conocen como “bucles” o “lazos”.
En general, existen tres tipos de repetición: Para, Mientras y Hasta; en las próximas
secciones se explica la lógica de cada una de estas estructuras y la forma de utilizarlas
en Visual Basic
Repetir Para (For…next)
Se utiliza cuando de antemano es posible conocer el número exacto de repeticiones,
el cual puede ser un dato de entrada o un valor dado en el planteamiento del
problema
For variable = Valor_Inicial to Valor_Final Step Incremento
Una o más instrucciones (1)
Next variable
La instrucción For ejecutará las instrucciones (1) X veces, siendo X =Valor_final–
Valor_inicial +1.
Step Incremento, permite especificar si se requiere un incremento diferente de uno.
Si el incremento es 1, no es necesario escribir Step.
Ejemplo 1: Programa que muestra 5 veces un mismo mensaje.
68
Option Explicit
Sub Main()
Dim i As Integer
For i = 1 To 5
MsgBox ("Hola ¿Cómo estas?")
Next i
End Sub
Ejemplo 2: Programa que escribe los números pares comprendidos entre 2 y 10 (ambos
inclusive).
Option explicit
Sub Main ( )
Dim num as integer
For num = 2 to 10 step 2
MsgBox(num)
Next num
End Sub
El siguiente ejemplo muestra un programa en el cual se utiliza una estructura de
repetición para introducir los datos de entrada y calcular un resultado.
Ejemplo 3: Programa que calcula el promedio general de un curso de n estudiantes.
Option Explicit
Sub Main()
Dim nota As Single, suma As Single, i As Integer
Dim n As Integer, promedio As Single
Suma=0
n = InputBox ("Introduzca el número de estudiantes a procesar:")
For i = 1 To n
nota = InputBox("Nota del estudiante " & i)
suma = suma + nota
Next i
promedio = suma / n
MsgBox("Promedio = " & promedio)
End Sub
69
La variable suma de este ejemplo es un acumulador. Una variable acumuladora se
utiliza cuando se quiere sumar valores sucesivos de una variable, dentro de una
estructura de repetición. Generalmente se inicializa en cero.
Repetir Mientras
Este tipo de estructura de programación, repite la ejecución de un conjunto de
instrucciones mientras que una expresión lógica es verdadera. Si la expresión lógica
es falsa, no se repiten las instrucciones.
Visual Basic proporciona tres formas distintas para definir una estructura “Repetir
Mientras”, la sintaxis de cada una de ellas se indica a continuación.
a) Forma 1: expresión lógica al comienzo
Do While expresión lógica
Una o más instrucciones (1)
Loop
b) Forma 2: expresión lógica al final
Do
Una o más instrucciones (1)
Loop While expresión lógica
c) Forma 3
While expresión lógica
Una o más instrucciones (1)
Wend
Esta manera de escribir un “Repetir Mientras” tiene la misma lógica de la forma es
simplemente otra alternativa
Ejemplo 5: programa que calcula el promedio general de un curso de n estudiantes. Éste es
igual al ejemplo 3 pero en su solución se utiliza “Repetir Mientras”.
Option Explicit
Sub Main()
Dim nota As Single, suma As Single, i As Integer
Dim n As Integer, promedio As Single
suma = 0
n = InputBox ("Introduzca el número de estudiantes a procesar:")
70
i=1
Do While i<= n
nota = InputBox("Nota del estudiante " & i)
suma = suma + nota
i=i+1
Loop
promedio = suma / n
MsgBox( "Promedio = " & promedio)
End Sub
Ejemplo 6: programa que recibe como datos de entrada las edades de los 50 empleados de
una empresa y calcula: a) el número de empleados que tienen menos de 30 años, b) el número
de empleados que tienen entre 30 y 50 años, c) el número de empleados que tienen más de
50 años, y d) la edad promedio de los empleados.
Option Explicit
Sub Main()
Dim i As Integer, edad As Byte, e1 As Byte, e2 As Byte, e3 As Byte
Dim prom As Single, sumaedad As Integer
i = 1
sumaedad = 0
Do While i <= 5
edad = InputBox("Edad " & i)
sumaedad = sumaedad + edad
If edad < 30 Then
e1 = e1 + 1
Else
If edad <= 50 Then
e2 = e2 + 1
Else
e3 = e3 + 1
End If
End If
i = i + 1
Loop
prom = sumaedad / 5
MsgBox ("Promedio = " & prom)
MsgBox ("Empleados con menos de 30 años= " & e1)
MsgBox ("Empleados con que tienen entre 30 y 50 años " & e2)
MsgBox ("Empleados con más de 50 años= " & e3)
End Sub
Las variables e1, e2 y e3 son contadores. Un contador es una variable que se utiliza
para determinar la cantidad de elementos que cumplen cierta condición. En este
71
ejemplo, las variables e1, e2 y e3 almacenan la cantidad de empleados que tienen
menos de 30 años, entre 30 y 50 años, y más de 50 años, respectivamente.
Repetir Hasta
Esta estructura permite repetir un conjunto de instrucciones hasta que una expresión
lógica sea verdadera, o lo que es igual, repite mientras una expresión lógica es falsa.
Cuando la expresión lógica es verdadera, el bucle deja de ejecutarse y el programa
continúa en la instrucción siguiente.
a) Expresión lógica al final
Do
Una o más instrucciones (1)
Loop Until expresión lógica
b) Expresión lógica al comienzo
Do Until expresión lógica
Una o más instrucciones (1)
Loop
Al comienzo del bucle se evalúa la expresión lógica y si ésta es falsa se
ejecutan las instrucciones (1), si es verdadera no se ejecuta el “Repetir Hasta”.
Ejemplo 8: Programa que calcula el promedio general de un curso de n estudiantes. Éste es
el mismo programa de los ejemplos 3 y 5, pero resuelto con la estructura“Repetir Hasta”.
Option Explicit
Sub Main()
Dim nota As Single, suma As Single, i As Integer
Dim n As Integer, promedio As Single
suma = 0
n = InputBox ("Introduzca el número de estudiantes a procesar:")
i=1
Do Until i> n
nota = InputBox("Nota del estudiante " & i)
suma = suma + nota
i=i+1
Loop
promedio = suma / n
MsgBox ("Promedio = " & promedio)
End Sub
72
Ejemplo 9: Programa que permite obtener la siguiente información acerca de los estudiantes
de una Facultad
- Número de estudiantes del sexo masculino
- Número de estudiantes del sexo femenino
- Edad promedio
- Promedio de notas general de la Facultad
Para resolver este problema utilizando una estructura de repetición, se requiere como primer
dato de entrada el número de estudiantes de la Facultad. Luego, para cada estudiante se
solicitan los siguientes datos: sexo, edad y promedio de notas.
Option Explicit
Sub Main()
Dim n As Integer, sexo As String, edad As Byte, prom As Single
Dim i As Integer, nm As Integer, nf As Integer, sumae As Single
Dim sumap As Single, prome As Single, promg As Single
n = InputBox("Número de estudiantes")
i = 1
nm = 0
Do Until i > n
sexo = InputBox("Sexo:", "Estudiante " & i)
edad = InputBox("Edad:", "Estudiante " & i)
prom = InputBox("Promedio:", "Estudiante " & i)
If sexo = "M" Or sexo = "m" Then
nm = nm + 1
Else
If sexo = "F" Or sexo = "f" Then
nf = nf + 1
End If
End If
sumae = sumae + edad
sumap = sumap + prom
i = i + 1
Loop
prome = sumae / n
promg = sumap / n
MsgBox("Edad Promedio=" & prome & Chr(10) & "Promedio
General= " & promg)
MsgBox ("No. de hombres= " & nm & Chr(10) & "No. de mujeres=
" & nf)
End Sub
Ejemplo 10: Este programa tiene un conjunto de instrucciones que permiten validar la
entrada de datos haciendo uso de una estructura “Repetir Hasta”. En el ejemplo el usuario
73
debe introducir la edad, pero se requiere que la edad esté entre 5 y 100, es decir que una edad
menor que 5 se considera inválida, al igual que una edad superior a 100. El objetivo es que
el programa detecte el error y no acepte las edades que son inválidas.
Option Explicit
Sub main()
Dim edad As Byte, Resp As Integer
Do
edad = InputBox("Escriba su edad")
If edad < 5 Or edad > 100 Then
Resp = MsgBox("La edad debe estar entre 5 y 100",
vbExclamation, "Error!")
End If
Loop Until edad >= 5 And edad <= 100
End Sub
Ejemplo 11: Programa que calcula la suma y la media aritmética de un conjunto de números.
Cada vez que se introduce un número se muestra un MsgBox donde se pregunta si se desea
introducir un nuevo número, si la respuesta es sí, aparece un InputBox para escribir el
siguiente número, si es no, entonces se muestran la suma, la media aritmética y la cantidad
de números procesados.
Option Explicit
Sub main()
Dim num As Single, suma As Single, media As Single, can_num As
Integer
Dim resp As Byte
suma = 0
can_num = 0
Do
num = InputBox("Escriba un número:")
suma = suma + num
can_num = can_num + 1
resp =MsgBox("¿Desea introducir otro número?", vbYesNo +
vbInformation, _
"ejemplo 11")
Loop Until resp = 7
media = suma / can_num
MsgBox ("Números procesados = " & can_num & Chr(10) & "Suma
= " & _
suma & Chr(10) & "Media = " & media)
End Sub
Nota: cuando una instrucción no cabe en una sola línea, se coloca al final de ésta el
símbolo ( _, ) y se continúa en la siguiente línea.
74
resp =MsgBox("¿Desea introducir otro número?", vbYesNo + vbInformation, _
"ejemplo 11")
Muestra el siguiente cuadro de mensaje:
EJERCICIOS PROPUESTOS
1. Hacer de tres maneras diferentes: usando “Repetir Para”, “Repetir Mientras” y
“Repetir Hasta”.
a) Obtener la suma de n números introducidos por el usuario.
b) Calcular la suma de los cuadrados de los 50 primeros números naturales
(enteros positivos).
2. Calcular independientemente la suma de los números pares e impares comprendidos
entre 1 y 50.
3. Se tienen las calificaciones de los alumnos de un curso de informática, el cual consta
de tres materias: Visual Basic, Excel y Word. Calcular la nota definitiva de cada
alumno, número de estudiantes aplazados, número de estudiantes aprobados y el
promedio general del curso.
4. Se tienen como datos de entrada los salarios de 50 empleados de una empresa. Hacer
un programa para determinar: a) el número de empleados que ganan menos de
350000 Bs., b) el número de empleados que ganan entre 350000 y 600000 Bs. c) el
número de empleados que ganan más de 600000 Bs. d) El valor de la nómina (suma
de todos los salarios).
5. En un centro meteorológico se llevan las precipitaciones mensuales caídas en tres
zonas del país: Occidente, Centro y Oriente. Se desea un programa que reciba como
datos de entrada las precipitaciones registradas en los 12 meses de un año para cada
región y determine: a) precipitación anual en cada región y b) región con mayor
precipitación anual.
6. Se quiere un programa que contabilice una cuenta de ahorros. Al inicio se le
introduce el nombre del titular de la cuenta y el saldo inicial. A continuación se
permite hacer depósitos y retiros sucesivos, el usuario debe escribir una “d” si desea
depositar o una “r” si desea retirar. Cuando es depósito se incrementa al saldo y
cuando es retiro se resta, luego de cada operación debe mostrarse el saldo. El
programa finalizará cuando ya no se desee hacer más movimientos. Al terminar, el
75
programa debe mostrar el saldo final. Sugerencia: utilizar una estructura de
repetición con una condición evaluada al final del bucle.
7. Calcular el promedio de un estudiante que presenta tres exámenes. El programa debe
validar los datos de entrada, es decir, sólo debe aceptar notas entre 0 y 20.
5.6.Arreglos
Los arrays, arreglos o mejor conocidos como vectores (o matrices) que son conocidas
por algunos como vectores multidimensionales forman parte también de las cosas
que podíamos usar en VB6.
Definición de arreglo
Es un conjunto de datos o una estructura de datos homogéneos que se encuentran
ubicados en forma consecutiva en la memoria RAM (sirve para almacenar datos en
forma tempora) , son una colección de variables del mismo tipo que sé referencia
utilizando un nombre común.
Un arreglo puede definirse como un grupo o una colección finita, homogénea y
ordenada de elementos. Los arreglos pueden ser de los siguientes tipos:
•De una dimensión.
•De dos dimensiones.
•De tres o más dimensiones
Unidimensionales
Es un tipo de datos estructurado que está formado de una colección finita y ordenada
de datos del mismo tipo. Es la estructura natural para modelar listas de elementos
iguales.
76
Para implementar arreglos unidimensionales se debe reservar espacio en memoria, y
se debe proporcionar la dirección base del arreglo, la cota superior y la inferior.
Por ejemplo imaginemos que tenemos 20 variables de tipo String que almacenan
nombres (nombre1, nombre2, etc..). Si yo ahora quisiera pasar todas estas cadenas a
minúsculas tendría que utilizar la función Lcase con cada variable: nombre1 =
Lcase(nombre1), nombre2 = Lcase(nombre2), etc.
En cambio si utilizara un arreglo solucionaría mi problema solo a esto
Dim nombres(30) As String
For x = 0 To 30
nombres(x) = LCase(nombres(x))
Next
Siguiendo el ejemplo anterior: en vez de escribir la sentencia Lcase 30 veces para
cada variable, hemos utilizado un arreglo llamado nombres con un número de índice
30 , es decir que almacena 30 datos de tipo String
Declaración de los arreglos en el código
Para crear un arreglo se debe en primer lugar declararlo como cualquier otra variable,
la única diferencia es que debemos indicar la cantidad de elementos que contendrá el
arreglo, colocando el número de índice entre paréntesis. Por ejemplo:
Lo siguiente crea un arreglo de 15 elementos o datos de tipo integer
Dim miArreglo (1 to 15) as integer
Esto crea un arreglo de 11 elementos o datos de tipo String
Dim empleados (10) as String
Como podemos ver en el primer ejemplo hemos declarado un arreglo
llamado miArreglo y entre paréntesis hemos declarado el rango de capacidad del
mismo, es decir la cantidad de datos que podrá contener
El primer número, el 1 , indica el límite inferior del mismo, y el número 15 indica el
límite máximo del arreglo, conformando de esta manera un arreglo que podrá
almacenar 15 datos de tipo string.
En el segundo ejemplo, declaramos un arreglo de 11 elementos de tipo string. Como
podés ver hemos indicado solo un número que representa el valor máximo del
mismo. Cabe aclarar que hemos puesto de índice el número 10, pero en realidad el
arreglo contiene 11 elementos ya que cuando NO indicamos el límite inferior, se
asume que el mismo comienza desde el 0.
Importante: los arreglos se dividen en 2 grupos, los vectores y las matrices. Los
vectores son arreglos que contienen una sola dimensión y las matrices 2 o mas
dimensiones.
77
Acceder a los datos de un arreglo
Para acceder a los datos de un arreglo o vector, debemos hacerlo mediante
el índice o número del elemento del mismo. Por ejemplo:
Dim alumnos(1 To 4) As String
alumnos(1) = "juan"
alumnos(2) = "micaela"
alumnos(3) = "maría"
alumnos(4) = "ignacio"
Primero declaramos un arreglo llamado alumnos, de tipo string y que contendrá 4
elementos. Luego le asignamos un valor de cadena como a cualquier otra variable de
tipo string, pero con la diferencia que para referirnos al elemento utilizamos el n° de
índice del mismo.
Otro ejemplo
Dim paises(2) As String
' Llena el vector con datos
paises(0) = "Argentina"
paises(1) = "Perú"
paises(2) = "Brasil"
' Recorre los elementos del vector
For x = 0 To 2
MsgBox "Nombre del país : " & paises(x)
Next x
En este último ejemplo, declaramos y creamos un vector de 3 elementos que
contendrá el nombre de 3 países. Luego en un bucle For utilizamos la función
MsgBox para mostrar los elementos del arreglo, pasándole como parámetro del
índice la variable x del bucle For.
Utilizar una estructura Type o UDT en un arreglo
Como vimos, en un arreglo podemos almacenar datos de cualquier tipo pero no
mezclarlos, es decir podemos crear arreglos de tipo string, de tipo Integer etc., pero
sin duda que lo más importante y de más utilidad a la hora de programar es la
utilización de datos definidos por nosotros mediante una estructura Type
Por ejemplo:
78
Option Explicit
' Estructura de dato para el vector
Private Type agenda
nombre As String
apellido As String
cpostal As Integer
End Type
' Declaramos el vector
Dim personas(1 To 3) As agenda
Private Sub Form_Load()
' Llenamos con datos para el elemento 1 del arreglo
personas(1).nombre = "carlos"
personas(1).apellido = "Martínez"
personas(1).cpostal = 1900
' Llenamos con datos para el elemento 2 del arreglo
personas(2).nombre = "Héctor"
personas(2).apellido = "rosales"
personas(2).cpostal = 1898
' Llenamos con datos para el elemento 3 del arreglo
personas(3).nombre = "Albert"
personas(3).apellido = "Einstein"
personas(3).cpostal = 1324
End Sub
Para utilizar una estructura definida por nosotros en vectores o matrices, se hace de
la forma habitual, con la diferencia que debemos declarar el arreglo utilizando el tipo
de dato Type que hayamos creado, en este caso Dim personas(1 to 3) as agenda
Bidimensionales
Como se dijo anteriormente, las matrices son arreglos de
más de 1 dimensión (2 o más), a diferencia de los vectores
que poseen una sola dimensión. Podemos imaginar una
matriz bidimensional (2 dimensiones), como una
cuadrícula con filas y columnas, donde las filas
representarían las coordenadas x y las columnas las
coordenadas y.
79
La representación en memoria se realiza de dos formas: almacenamiento por
columnas o por renglones. Para manejar un arreglo, las operaciones a efectuarse son:
Declaración del arreglo,
Creación del arreglo,
Inicialización de de los elementos del arreglo, y
Acceso a los elementos del arreglo.
Ejemplo de matriz de 2 dimensiones
Matriz bidimensionales de 6 x 8 (de 2 dimensiones).
Dim personas (1 to 6, 1 to 8) as string
Si luego quisiera acceder a los datos de la misma basta con referirnos a los subíndices
Por ejemplo:
personas (1, 1) = "Natalia"
personas (2, 1) = "pedro"
personas (1, 7) = "valeria"
personas (1, 8) = "josé"
personas (2, 2) = "carolina"
personas (4, 1) = "raquel"
personas (6, 2) = "eustaquio"
personas (6, 5) = "maria"
personas (6, 8) = "mariana"
El total de índices posibles para almacenar datos o valores en el ejemplo anterior es
de 48 datos, ya que si multiplicamos 6 x 8 nos da como total 48 valores posibles para
utilizar en la matriz bidimensional.
En este ejemplo creamos una matriz de 3 dimensiones de 3 x 3 x 3
Dim cubo (1 to 3, 1 to 3, 1 to 3) as integer
Para acceder a los datos sería exactamente de la misma manera pero debemos utilizar
un índice más.
Ejemplo:
cubo (1, 1 , 1) = 50
cubo (1, 1 , 2) = 50
cubo (1, 1 , 3) = 50
cubo (1, 2 , 1) = 50
cubo (1, 2 , 2) = 50
cubo (1, 2 , 3) = 50
cubo (1, 3 , 1) = 50
cubo (1, 3 , 2) = 50
cubo (1, 3 , 3) = 50
cubo (2, 1 , 1) = 50
cubo (2, 1 , 2) = 50
cubo (2, 1 , 3) = 50
cubo (2, 2 , 1) = 50
80
cubo (2, 2 , 2) = 50
cubo (2, 2 , 3) = 50
cubo (2, 3 , 1) = 50
cubo (2, 3 , 2) = 50
cubo (2, 3 , 3) = 50
cubo (3, 1 , 1) = 50
cubo (3, 1 , 2) = 50
cubo (3, 1 , 3) = 50
cubo (3, 2 , 1) = 50
cubo (3, 2 , 2) = 50
cubo (3, 2 , 3) = 50
cubo (3, 3 , 1) = 50
cubo (3, 3 , 2) = 50
cubo (3, 3 , 3) = 50
En el ejemplo anterior, que es un poco extenso, es para que veas todos los posibles
valores que puedes almacenar en una matriz de 3 x 3 x 3, y que da como resultado
un arreglo de 27 valores posibles.
81
Referencia Bibliográfica
Bibliografía Básica:
Corona, M., Ancona, M. (2011). Diseño de algoritmos y su codificación en
lenguaje C. McGrawHill. 2011
Bibliografía Complementaría:
Márquez, G., Osorio, S., Olvera, N. (2011). Introducción a la Programación
Estruturada en C. Pearson. 2011
Web
http://webdelprofesor.ula.ve/forestal/mariaq/archivos_guias_apuntes/IntroProgVB.