En el capítulo anterior agregamos un nuevo valor a nuestros programas: La capacidad de tomar decisión en función a una información que cambia durante el proceso. La estructuras de control nos permiten dirigir el flujo de las instrucciones dependiendo de una condición evaluada.
Aunque esto es funcional -de hecho como vimos anteriormente se logró un programa que cumple un objetivo- aun queda ciertas limitaciones que podemos atender, tal es el caso de si deseáramos repetir cierta tarea o líneas de códigos mientras una condición se cumpla. Para estas situaciones nos valemos de las estructuras de repetición.
WHILE
La primera estructura de repetición que veremos es el WHILE. Para estudiar su funcionamiento comencemos por conocer su sintaxis:
while (condición){
instrucciones;
...
}
Ahora, comencemos con el análisis de la estructura while:
- Para iniciar una estructura while primero se ha evaluar una condición y si ésta se cumple se ejecuta el código que se encuentra entre llaves {}.
- Si queremos que las instrucciones que se encuentren dentro del while se ejecuten, al menos una vez, debemos garantizar que la condición se cumpla, de lo contrario no se ejecutarán.
- Es indispensable que la variable a evaluar dentro de la condición pueda ser cambiada dentro del código inmerso en el while, ya que si no se hace nunca se romperá el bucle de repetición haciendo que nuestro programa se ejecute infinitamente (claro, al menos que lo cerremos desde el sistema operativo).
- Al llegar al final de la estructura (cuando se encuentra con el final de la llave }) se retorna al inicio para evaluar nuevamente la condición.
#include <stdlib.h>
#include <iostream>
using namespace std;
int main (){
char opcion = 's';
while (opcion == 's'){
cout << "Se estas convirtiendo en un buen programador" << endl;
cout << "Quieres volver a ver el mensaje? s/n" << endl;
cin >> opcion;
}
return 0;
}
Veamos con detalle el ejercicio anterior:
- Se ha creado una variable llamada opcion cuyo valor inicial es el carácter s (en minúscula).
- En la estructura de repetición while se tiene una condición que evalúa si la variable opcion es igual a s (en minúscula) entonces se ejecutará el código dentro de la estructura y, por ende, se mostrará el mensaje.
- Posteriormente se muestra un texto indicándole al usuario si desea volver a ver el mensaje confirmándolo ingresado la letra s, o n en caso de no querer volver a verlo.
- Noten: lo que ingresa el usuario se guarda en la variable opcion. A esto es lo que me refiero cuando indico que la variable que se evalúa en la condición debe poder cambiarse dentro de la misma estructura, ya que de no hacerlo opcion siempre será igual a s, por lo que el bucle se repetirá eternamente. Al volverse a evaluar la condición ahora se revisará si el usuario tecleo s o n; si es s se repite el mensaje y si es n se continua con las instrucciones debajo de la estructura de repetición, que en este caso es terminar el programa.
- Otra acotación, si por descuido o intención el usuario ingresa la S (mayúscula), al evaluar la condición ésta no se cumplirá, ya que se esta preguntando si opcion == 's', la cual esta en minúscula, para que se puedan evaluar ambas posibilidades conviene agregar lo siguiente:
- opcion == 's' || opcion == 'S'; las dos barras es un operador OR Lógico y lo que esta indicando que evalúe si opcion es s o S. Si cumple alguna de las dos se ingresará al bloque de código del WHILE.
- Veamos también la variable opcion se inicializó con s, esto fue así para garantizar que ingresará al código al menos una vez. Supongamos por un momento que no se hubiese inicializado la variable; al llegar a la condición y preguntar si opcion == 's' se obtendrá como resultado que no se cumple la condición por lo tanto no se ejecutará las instrucciones dentro del WHILE. Para confirmar eso, prueben el código quitando la inicialización, ejecútenlo y vean ocurre.
DO WHILE
La estructura WHILE obliga a evaluar la condición al inicio, por lo que si queremos que el código se ejecute al menos una vez debemos garantizar que la condición se cumpla, tal como lo vimos en el apartado anterior. En C++ se cuenta con una estructura de repetición similar al WHILE original, pero que evalúa la condición al final de la estructura, lo que permite que las instrucciones que se encuentran dentro de él se ejecuten una primera vez. La sintaxis del DO WHILE es la siguiente:
do {
instrucciones;
...
}while (condición);
Aquí podemos notar algunos cambios algo evidentes:
- El primer cambio que se observa, en sintonía con su propuesta, es que la condición se esta evaluando al final de la estructura, por lo que el bloque de instrucciones dentro del DO WHILE se ejecutarán al menos una vez.
- La instrucción while (condicion); debe terminar con un punto y coma (;) de lo contrario habrá un error en la sintaxis.
Hagamos un ejercicio para ver el funcionamiento de esta estructura:
#include <stdlib.h>
#include <iostream>
using namespace std;
int main (){
int i = 0, num;
cout << "Indique de cuál número desea saber su tabla de multiplicación" << endl;
cin >> num;
do {
cout << i << "x" << num << " = " << i*num << endl;
i = i+1;
} while (i < 11);
return 0;
}
El ejercicio anterior se diseño para que muestre la tabla de multiplicar de un número que el usuario ingrese. Hagamos su análisis:
- Se crean dos variables i que funcionará como multiplicador el cual se incrementará después de cada operación y num que es el número al que se le hará la multiplicación y será indicado por el usuario.
- Luego se le indica al usuario que ingrese el número al cual se le generará la tabla de multiplicar. El dato se guardará en la variable num.
- Se entra en la estructura DO WHILE y se muestra la multiplicación de la variable i*num. Esta línea del cout posee mucha concatenanción, esto se hizo para darle un mejor formato de vista.
- Luego se incrementa el valor de la variable i en uno (es una forma de hacerlo, más adelante mostraré otra forma de incrementar una variable).
- Y por último se evalúa la condición, la cual verá si i es menos que 11, de ser así se vuelve a repetir el código, de lo contrario se termina la estructura de repetición.
Fíjense que su objetivo son similares lo que cambia es el momento en la que se evalúa la condición, lo cual trae como consecuencia que en éste último se garantice una pasada por las instrucciones.
Bien, esto es todo con respecto a estas dos estructura, pero antes de cerrar este artículo quiero mostrarle un ejercicio con la que se unirá ambas estructura para que noten el potencial que se puede lograr con ellas: Este ejercicio combinará ambos ejercicios anteriores, es decir generará la tabla de multiplicación de un número ingresado por el usuario, una vez mostrada se le preguntará si quiere repetir la operación.
#include <stdlib.h>
#include <iostream>
using namespace std;
int main (){
char opcion = 's';
int i = 0, num;
while (opcion == 's' || opcion =='S'){
cout << "Indique de cuál número desea saber su tabla de multiplicación" << endl;
cin >> num;
do {
cout << i << "x" << num << " = " << i*num << endl;
i = i+1;
} while (i < 11);
cout << "Desea repetir la operación? s/n ";
cin >> opcion;
i = 0;
}
return 0;
}
Espero les haya gustado este capítulo, si tienen alguna duda comentén, con gusto les responderá. Hasta pronto.
0 comentarios:
Publicar un comentario