UNIVERSIDAD DE EL SALVADOR

FACULTAD DE CIENCIAS NATURALES Y MATEMÁTICA

CARRERA : LICENCIATURA EN INFORMÁTICA EDUCATIVA

ASIGNATURA : INTRODUCCIÓN A LA PROGRAMACIÓN
CICLO : II–2020
GUÍA DE LABORATORIO #1 : INSTRUCCIONES DE CONTROL
PONDERACIÓN : 3%
FECHA DE REALIZACIÓN : Domingo 25 de octubre de 2020

OBJETIVOS

Que al finalizar el laboratorio #2 el estudiante podrá:

• Desarrollar algoritmos mediante el proceso de mejoramiento de arriba abajo, paso a

paso.

• Utilizar las estructuras de selección if, if…else y switch para elegir entre distintas
acciones alternativas.

• Usar el break y continue para alterar el flujo de control.

• Utilizar las instrucciones de repetición for, while y do…while para ejecutar instrucciones
repetidas veces en un programa.

• Comprender la repetición controlada por un contador y por un centinela.

• Utilizar los operadores de incremento, decremento y asignación.

Introducción

Para escribir un programa que dé solución a un problema, es necesario comprender tanto el

problema como la metodología necesaria para resolverlo. Esta última, se refiere más bien a
comprender los bloques de sentencia que utilizaremos y las técnicas para construirlos. En este
laboratorio abordaremos los capítulos 4 y 5: “Instrucciones de Control” del libro de texto Como
programar en C++ de Paul Deitel.

Por lo general, en un programa las instrucciones se ejecutan una después de otra, en el orden en
que están escritas. Este proceso se conoce como ejecución secuencial. En este laboratorio
veremos que esto no es rígido y podemos indicarle a nuestro programa qué instrucción ejecutar
en determinado momento. Esto se conoce como transferencia de control. Tal como veremos,
existen tres tipos de estructuras de control: la de secuencia, la de selección y la de repetición.
Presentaremos 7 ejemplos que pretenden exponer el uso de cada una de ellas.

La parte final del laboratorio corresponde a una serie de ejercicios propuestos, los cuales deberá
resolver y subirlos a la plataforma en un periodo máximo de 8 días.
Conceptos básicos

Programación estructurada: es una técnica que nos permite construir programas de fácil
comprensión, mejorando la claridad, la calidad y el tiempo de desarrollo. Para ello utiliza
subrutinas llamadas estructuras de control.

Estructuras de control: es un conjunto de instrucciones que nos permiten modificar el flujo de

ejecución de las instrucciones de un programa, tomar decisiones, realizar acciones repetitivas,
etc., dependiendo de las condiciones que nosotros mismos establezcamos.

Condición booleana: es una expresión que puede tener como resultado solo el valor de verdadero
o falso.

Estructuras de selección

Las estructuras de control selectivas o estructuras de selección son aquellas que evalúan una
expresión, usualmente una condición booleana, y a partir del resultado permiten tomar decisiones
entre una, dos o más opciones; a esto se le conoce como selección condicional.

C++ tiene dos estructuras de control para la selección, if (selección simple y selección doble) y
switch (selección múltiple).

La estructura de selección simple (if) fue abordada en el laboratorio anterior, lo que nos permitirá
centrar nuestro estudio en la estructura de selección doble y múltiple.

Estructura de selección doble: if…else

Como vimos en el laboratorio anterior, la estructura de selección simple (if) realiza una acción
indicada solamente cuando la condición booleana es verdadera. Adicionalmente la estructura
if…else nos permite evaluar una condición booleana y elegir entre dos opciones. Si la condición es
verdadera, ejecutará la instrucción que se encuentra después del if, pero si la condición es falsa se
ejecutará la condición que se encuentra a continuación del else.

La notación de esta sentencia es la siguiente:

if (<expres_bool>)

<bloque_sent>

{else if (<expres_bool>) <bloque_sent>}

[else <sec_sent>]

donde <expres bool> es una expresión booleana y <sec_sent> puede ser una sola sentencia o un
bloque de sentencias.
Las formas más sencillas de esta sentencia, son:

if (<expres_bool>) if (<expres_bool>)

<sentencia> <sentencia>

else

<sentencia>

if (<expres_bool>) if (<expres_bool>)

{ {

<sent 1> <sent 1>

... ...

<sent n> <sent n>

} }

else

<sent 1>

...

<sent n>

Nótese que en el caso en el que sólo siga una sentencia al if no es necesario incluir las llaves, pero
sí lo es cuando le siguen más de una sentencia. A un conjunto de instrucciones contenidas dentro
de un par de llaves se le llama bloque.

Ejemplos de condiciones complejas utilizando los operadores lógicos dentro de un if:

if((a>5)&&(Z<=12))

if((Z>5)||(w<1))

if((renta<=120)&&(AFP>45))

if((a>0)||(b<=0)&&(n!= a))

Los programas a menudo realizan una serie de tests de los que sólo uno será verdadero. Como
ejemplo, considérese un programa para escribir en pantalla un mensaje diferente correspondiente
a un número que representa una calificación numérica. En C++, utilizando sentencias if anidadas,
quedaría:
 if (Nota == 10)

cout << "Matrícula de Honor";

else if (Nota >= 9)

cout << "Sobresaliente";

else if (Nota >= 7)

cout << "Notable";

else if (Nota >= 6)

cout << "Aprobado";

else cout << "Suspenso";

Sin embargo, C++ nos proporciona una forma más concisa de expresar lo anterior, completamente
equivalente:

if (Nota == 10) cout << "Matrícula de Honor";

else if (Nota >= 9) cout << "Sobresaliente";

else if (Nota >= 7) cout << "Notable";

else if (Nota >= 5) cout << "Aprobado";

else cout << "Suspenso";

De esta última forma evitamos tener que usar numerosas sangrías del código que pueden
dificultar la lectura. Por tanto, el criterio que se debe seguir para decidir el anidamiento o no de
estructuras selectivas es la legibilidad del código.

Ejemplo #1: El siguiente programa convierte kilómetros a metros o viceversa, una cantidad
introducida por un usuario, el cual también decide qué tipo de conversión quiere con solo
presionar el número 1 o 2.

#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
float m, km;
int op;
cout<<"********Convertidor de kms a mts o viceversa***************** \n";
cout<<"--------------------------------------------------------------\n";
cout<<"Para convertir de kms a metros escribe 1 y de mts a kms escribe 2:";
cin>>op;
cout<<"--------------------------------------------------------------\n";
if (op==1)
{
cout<<"\nDigita la cantidad de Kilometros: ";
cin>>km;
m=km*1000;
cout<<"\n------------------------------------------------------\n";
cout<<km <<" Kilometros es igual a " <<m <<" metros";
cout<<"\n------------------------------------------------------\n";
}
Else if (op==2)
{
cout<<"\nDigita la cantidad de Metros: ";
cin>>m;

km=m/1000;

cout<<"\n------------------------------------------------------\n";

cout<<m <<" metros es igual a " <<km <<" kilometros";

cout<<"\n---------------------------------\n";

getch();

Salida:

Ejemplo #2: Realizar un programa que permita comparar dos números ingresados por un usuario y
determine cuál de ellos es el mayor.

#include <iostream>

#include <stdlib.h>

using namespace std;

//Programa que permite determinar el mayor de dos números ingresados por

el usuario

int main()
{

//declaración variables de Entrada

int a=0, b=0; // crea 2 variables enteras

cout<<" Programa que permite determinar el mayor de dos numeros ingresados por el usuario:
"<<endl<<endl;

cout<<"Introduzca 1er numero: “;

cin>>a;

cout<<"Ahora introduzca 2do número a comparar: ";

cin>>b;

if (a>b)

cout<<endl<<"El primero valor ( "<<a<<" ) es el mayor "<<endl;

else

if (a<b)

cout<<endl<<"El segundo valor ( "<<b<<" ) es el mayor "<<endl;

else

cout<<endl<<"Ambos números ingresados son iguales "<<endl;

} // fin if -2

} // fin if -1

system("pause"); //detiene ejecución hasta que usuario presione UNA tecla

} // fin función principal main

Salida:
Estructura de selección múltiple: switch

Aunque la sentencia if de C++ es muy potente, en ocasiones su escritura puede resultar tediosa,
sobre todo en casos en los que el programa presenta varias elecciones después de evaluar una
condición: selección múltiple o multialternativa. En situaciones donde el valor de una expresión
determina qué sentencias serán ejecutadas es mejor utilizar una sentencia switch en lugar de una
if. Por ejemplo, la sentencia switch:

switch (operador)

{ case + : resultado = A + B; break;

case - : resultado = A - B; break;

case * : resultado = A * B; break;

case / : resultado = A / B; break;

default :

cout << "Operador invalido"; }

tiene el mismo efecto que la siguiente sentencia if:

if (operador == +)

resultado = A + B;

else if (operador == -)

resultado = A - B;

else if (operador == *)

resultado = A * B;

else if (operador == /)

resultado = A / B;

else cout << "Operador invalido";

En este ejemplo se observa que el valor de la expresión operador (en este caso sólo una variable)
determina qué sentencias se van a ejecutar. Esta expresión recibe el nombre de selector de la
estructura selectiva múltiple. También se puede apreciar la mayor simplicidad de la primera
sentencia.

La palabra reservada break permite que el flujo de programa se detenga justo después de la
ejecución de la sentencia anterior a ese break, impidiendo que se ejecuten las sentencias
correspondientes a las siguientes alternativas del switch. Por tanto, debemos obligatoriamente
acabar cada bloque de sentencias correspondiente a cada alternativa con una sentencia break.

Por otro lado, la alternativa default es opcional y engloba un conjunto de sentencias (que puede
ser vacío, contener una sola sentencia o varias) que se ejecutan en caso de que ninguna de las
alternativas del switch tenga un valor coincidente con el resultado de evaluar la expresión del
selector. La notación de la sentencia switch es:

switch (<expresion>)

{ case 1: instruccion 1;

break;

case 2: instruccion 2;

break;

case n: instruccion n;

break;

[default: <instruccion n+1;>]

Una sentencia switch contiene un selector (en el ejemplo, operador), cuyo tipo debe ser int, char o
enumerado. Cuando una sentencia switch se ejecuta, el valor del selector se compara (con el
operador ==) con las etiquetas case. Si alguna de ellas concuerda con ese valor se ejecutará la
correspondiente secuencia de sentencias. Si queremos que varias alternativas tengan el mismo
conjunto de sentencias a ejecutar, podemos hacer como en el siguiente ejemplo:

switch (selector)

{ case 1:

case 2: cout << "Salida para los casos 1 y 2" <<

endl; break;
 case 3: cout << "Salida para el caso 3" <<

endl; break;

default:

cout << "Salida para los restantes casos" << endl;

En este ejemplo, si el selector se evalúa y su valor es 1 o 2, se ejecuta, en ambos casos, la

instrucción cout << "Salida para los casos 1 y 2"<< endl;. En este caso particular puede apreciarse
la utilidad de break a la hora de detener el flujo del programa.

Ejemplo #3: Realizar un programa que indique el día seleccionado por el usuario con solo digitar
una letra.

#include <iostream>

#include <conio.h>

using namespace std;

int main ()

char dia;

cout <<"Elije un dia de la semana: \n Lunes = L\n Martes = M\n Miercoles

= X\n Jueves = J\n Viernes = V\n Sabado = S\n Domingo = D\n";

cin >> dia;

switch(dia)

case 'L': cout <<"El dia seleccionado es: Lunes";

break;

case 'M': cout <<"El dia seleccionado es: Martes";

break;

case 'X': cout <<"El dia seleccionado es: Miercoles";

break;

case 'J': cout <<"El dia seleccionado es: Jueves";

break;

case 'V': cout <<"El dia seleccionado es: Viernes";

 break;

case 'S': cout <<"El dia seleccionado es: Sabado";

break;

case 'D': cout <<"El dia seleccionado es: Domingo";

break;

default:cout<<"Ese dia no existe";

getch();

return 0;

Salida:

Estructuras de iteración (repetición)

Una estructura iterativa permite repetir una acción; la repetición es controlada por una expresión
booleana. C++ nos ofrece 3 esquemas de iteración diferentes:

• while

• do…while

• for

La repetición puede ser definida o indefinida. La iteración es definida cuando se conoce de

antemano el número de repeticiones a ejecutar, para estos casos es mejor utilizar la estructura de
control for. Para los casos en que no se conoce el número de veces que se repetirá el ciclo, es
mejor utilizar las estructuras while y do…while.
Estructura while

La sintaxis de la sentencia while viene definida por la siguiente notación:

expresión 1 while (expresión 2)

instrucciones;

expresión 3;

Dónde:

expresión 1: siempre será el valor de inicio de la variable de control.

expresión 2: es la condición booleana.

expresión 3: es la forma en que cambia la variable de control.

instrucciones: son las instrucciones a ejecutar mientras se cumpla la condición.

Una sentencia while se ejecutará cero o más veces dependiendo de si se cumple la condición
booleana (expresión 2).

Por ejemplo, si queremos leer una serie de enteros y encontrar su suma, parando cuando se lea un
número negativo, podemos hacer:

sum = 0;

cin >> i;

while (i >=0)

sum = sum + i;

cin >> i;

Ejemplo #4: Realizar un programa que calcule el producto de varios números enteros ingresados
por el teclado y continuar el proceso mientras se conteste con una letra ‘s’ o ‘S’.

#include <iostream>

#include <conio.h>

using namespace std;

main ()
 {

int prod, num;

char resp='s'; prod=1;

while (resp=='s'||resp=='S')

system("cls");

cout<<"Dame un numero: ";

cin >> num;

prod=prod*num;

cout<<"Quieres multiplicar otro numero s/n: ";

cin >> resp;

cout<<"El producto total es: " <<prod;

getch();

return 0;

Salida:

Este es un ejemplo de iteración indefinida, en el que la variable de control es resp. Aquí resp es
una bandera o centinela, un tipo de variable empleada cuando el ciclo es indefinido, o sea que la
repetición se hará de acuerdo al valor contenido, que no depende del número de iteraciones.

Estructura do/while
Su sintaxis viene dada por:

expresión 1 do

instrucciones;

expresión 3;

} while (expresión 2)

Dónde:

expresión 1: siempre será el valor de inicio de la variable de control.

expresión 2: es la condición booleana.

expresión 3: es la forma en que cambia la variable de control.

instrucciones: son las instrucciones a ejecutar mientras se cumpla la condición.

Al igual que en la sentencia while, en esta sentencia el cuerpo del bucle se ejecuta mientras que
sea verdadera la expresión booleana que constituye la condición de control.

Además, esta condición se comprueba cada vez tras la ejecución del cuerpo, no antes, como en el
while. El cuerpo de una sentencia do/while siempre se ejecuta al menos una vez. Cuando esto
pueda ocurrir es más conveniente su uso que la sentencia while.

Ejemplo# 5: Utilizaremos el mismo programa del ejemplo anterior para visualizar la similitud de
estas dos estructuras.

#include <iostream>

#include <conio.h>

using namespace std;

main

()

int prod, num;

char resp='s';

prod=1;

do

cout<<"Dame un numero: ";

 cin >> num;

prod=prod*num;

cout<<"Quieres multiplicar otro numero s/n: ";

cin >> resp;

} while (resp=='s'||resp=='S');

cout<<"El producto total es: " <<prod;

getch();

return 0;

La salida es la misma del ejemplo anterior.

Ejemplo# 6: hagamos ahora un programa que sume los primeros cinco números impares que el
usuario ingrese por el teclado, eso implica que el programa terminará solo cuando se hayan
introducido cinco números impares.

/*Leer cinco números impares leídos desde el teclado*/

#include <iostream>

#include <conio.h>

using namespace std;

int main () {

int suma=0, num, cont=0;

do

cout<<"Escribe un número: ";

cin >> num;

if (num%2==1)

suma+=num;

cont=cont+1;

}while(cont<5);
 cout<<"\n La suma de los primeros 5 impares que digitaste es: " <<suma;

getch();

return 0;

Salida:

Estructura for

Como ya lo habíamos mencionado, esta estructura se utiliza generalmente cuando la repetición

está definida.

Su sintaxis:

for (<expres_ini>; <expres_bool>; <expres_inc>)

<sec_sent>

El bucle for contiene las cuatro partes siguientes:

• Parte de inicialización (<expres ini>), que inicializa las variables de control del bucle. Se puede
utilizar variables de control de bucle simples o múltiples. Lo más normal es inicializar en este
punto una sola variable cuyo valor varía luego en la parte de incremento. Si se inicializan varias
variables de control, cada inicialización se separa de la anterior con una coma.

• Parte de iteración (<expres bool>), que contiene una expresión lógica que hace que el bucle
realice las iteraciones de las sentencias, mientras que a expresión sea verdadera.

• Parte de incremento (<expres inc>), que modifica la variable o variables de control de bucle. Si se
modifican varias variables de control, cada operación se separa de la anterior por una coma.

• Sentencias (<sec sent>), acciones o sentencias que se ejecutarán por cada iteración del bucle.

Puede verse claramente la equivalencia entre una sentencia for y un while:

for (v = valor1; v<=valor2; v=v+paso) v = valor1;

{ while (v <= valor2)

// sentencias {

} // sentencias

v = v + paso;

Conviene tener en cuenta algunas consideraciones:

• Debemos asegurarnos que la expresión de inicialización del bucle y la expresión de incremento

harán que la condición del bucle se convierta en falsa en algún momento.

• Si el cuerpo de un bucle (secuencia de sentencias) modifica los valores de cualquiera de las

variables implicadas en ese bucle, entonces el número de repeticiones se puede modificar.

Ejemplo:

int limite = 1;

int i;

for (i=0; i<=limite; i++)

cout << i << endl; limite++;

produciría una secuencia infinita de enteros. No es una buena práctica de programación modificar
el valor de la variable de control, por lo que evitaremos hacerlo.

Ejemplo #7: Realizar un programa que indique los números primos desde 1 hasta el número
introducido por el usuario.

/*Indica cuales números primos hay entre 1 el número ingresado*/

#include <stdio.h>

#include <stdlib.h>

#include "iostream"

#include "conio.h"

using namespace std;

int

main() {
 int num, numf, cont, x, z;

do

cout << "Dime hasta donde quieres calcular los numeros primos: ";

cin >> numf;

}while (numf<1);cout << endl;

cout<<"_______________________________________________________________";

cout << endl;

cout << endl;

for (z=1;z<=numf;z++)

cont=0;

for (x=1;x<=z;x++)

if (z%x==0)

cont++;

if (cont==2)

cout << "El numero <"<< z << "> es primo\n";

else

cout << "El numero <"<< z << "> no es primo\n";

cout <<"______________________________________________________________";
cout << endl;

cout << endl;

system("PAUSE");

return 0;

Salida:

Ejercicios propuestos:

Desarrolle correctamente los ejercicios que se plantean a continuación. Recuerde que el objetivo
es poner en práctica lo visto en este laboratorio y que usted aprenda a programar; en ese sentido,
le sugerimos que se esmere en resolverlos por cuenta propia y le haga saber a su tutor cualquier
inquietud que se presente. ¡Buena suerte!

Ejercicio #1

Escriba un programa que solicite un ángulo, introducido desde el teclado, y determine de acuerdo
a su valor a qué clase de ángulo pertenece, valide que el ángulo no sea menor que 0° ni mayor que
360°. Utilice if anidados.

Agudo: si el ángulo es menor que 90°

Recto: si el ángulo es igual a 90°

Obtuso: si el ángulo es mayor que 90° y menor que 180°

Llano: si el ángulo es igual a 180°

Cóncavo: si el ángulo es mayor que180° y menor que 360°

Completo: si el ángulo es igual a 360°

Considere las siguientes salidas:

Ejercicio #2

Escriba un programa que haga la conversión de temperatura de grados centígrados a grados

Fahrenheit y viceversa, que permita elegir que conversión quiero hacer (mediante un menú).
Utilice la estructura switch.

1 grado Centígrado = (°F -32 *) 5/9

1 grado Fahrenheit = (°C * 9 / 5) + 32

Considere las siguientes salidas:

Ejercicio #3

Elabore un programa que permita comparar una cierta cantidad de números definida e ingresada
por el usuario, para luego imprimir el menor de ellos. Permítale al usuario la posibilidad de
continuar o finalizar si así lo desea (asegúrese de limpiar la pantalla en caso de continuar). Utilice
do while y for.

Considere la salida:

Nota: El documento a subir será una carpeta con su número de carné, en dicha carpeta colocará
todos los códigos de los ejercicios y el documento del reporte en Word, a continuación, comprima
la carpeta en zip y súbala a la herramienta correspondiente en la plataforma virtual. Por favor lea
la rúbrica completa para saber que debe llevar el documento del reporte.