Introducción
En este laboratorio, aprenderá las instrucciones de flujo de control en C++. Aprenderá cómo usar las instrucciones if-else, switch, while, do-while y for.
Control de flujo en C++
Vista previa del contenido
Hay tres constructos básicos de control de flujo: secuencial, condicional (o de decisión) y bucle (o iteración). La estructura secuencial: el proceso de ejecución es línea por línea de arriba hacia abajo. La estructura condicional utiliza la instrucción if-else para verificar si una declaración satisface alguna condición específica y luego hacer una elección. La estructura de bucle se utiliza para ejecutar alguna operación lógica repetidamente.
Control de flujo secuencial
Un programa es una secuencia de instrucciones. El flujo secuencial es el más común y directo, donde las declaraciones de programación se ejecutan en el orden en que se escriben, de arriba hacia abajo de manera secuencial.
Control de flujo condicional
Hay varios tipos de condicionales: if-then, if-then-else, if anidado (if-elseif-elseif-...-else), switch-case y expresión condicional.
#include <iostream>
using namespace std;
int main(){
int mark;
cout<<"Ingrese un número [0-100]: ";
cin>>mark;
// if
if (mark >= 50) {
cout << "¡Felicitaciones!" << endl;
cout << "Sigue así!" << endl;
}
cout<<"Ingrese un número [0-100]: ";
cin>>mark;
// if-else
if (mark >= 50) {
cout << "¡Felicitaciones!" << endl;
cout << "Sigue así!" << endl;
} else {
cout << "¡Trata más duro!" << endl;
}
cout<<"Ingrese un número [0-100]: ";
cin>>mark;
// if anidado
if (mark >= 80) {
cout << "A" << endl;
} else if (mark >= 70) {
cout << "B" << endl;
} else if (mark >= 60) {
cout << "C" << endl;
} else if (mark >= 50) {
cout << "D" << endl;
} else {
cout << "F" << endl;
}
// switch-case
char oper;
int num1 = 1, num2 = 2, result = 0;
cout<<"Ingrese un carácter [+ - / *]: ";
cin>> oper;
switch (oper) {
case '+':
result = num1 + num2;
break;
case '-':
result = num1 - num2;
break;
case '*':
result = num1 * num2;
break;
case '/':
result = num1 / num2;
break;
default:
cout << "Operador desconocido" << endl;
}
cout<<num1<<oper<<num2<<"="<<result;
return 0;
}Salida:
Ingrese un número [0-100]: 50
¡Felicitaciones!
Sigue así!
Ingrese un número [0-100]: 40
¡Trata más duro!
Ingrese un número [0-100]: 85
A
Ingrese un carácter [+ - / *]: +
1+2=3
Operador Condicional: Un operador condicional es un operador ternario (3 operandos), de la forma booleanExpr? trueExpr : falseExpr. Dependiendo de booleanExpr, evalúa y devuelve el valor de trueExpr o falseExpr.
// devuelve ya sea "APROBADO" o "REPROBADO", y lo imprime en cout
cout << (mark >= 50)? "APROBADO" : "REPROBADO" << endl;
max = (a > b)? a : b; // La parte derecha devuelve a o b
abs = (a > 0)? a : -a; // La parte derecha devuelve a o -aLlaves: Puedes omitir las llaves { } si solo hay una declaración dentro del bloque. Por ejemplo,
if (mark >= 50)
cout << "APROBADO" << endl; // Solo una declaración, se puede omitir { } pero no se recomienda
else { // más de una declaración, se necesitan { }
cout << "REPROBADO" << endl;
cout << "¡Trata más duro!" << endl;
}Sin embargo, recomendamos que mantengas las llaves, incluso si solo hay una declaración en el bloque, para mejorar la legibilidad de tu programa.
Control de flujo de bucle
Una vez más, hay varios tipos de bucles: for-loop, while-do y do-while.
// for-loop
int sum = 0;
for (int number = 1; number <= 100; ++number) {
sum += number;
}
// while-do
int sum = 0, number = 1;
while (number <= 100) {
sum += number;
++number;
}
// do-while
int sum = 0, number = 1;
do {
sum += number;
++number;
} while (number <= 100);Pida al usuario un límite superior. Sume los enteros del 1 al límite superior dado y calcule su promedio.
/*
* Sume del 1 al límite superior dado y calcule su promedio.
*/
#include <iostream>
using namespace std;
int main() {
int sum = 0; // Almacena la suma acumulada
int upperbound;
cout << "Ingrese el límite superior: ";
cin >> upperbound;
// Sume del 1 al límite superior
for (int number = 1; number <= upperbound; ++number) {
sum += number;
}
cout << "La suma es " << sum << endl;
cout << "El promedio es " << (double)sum / upperbound << endl;
// Sume solo los números impares
int count = 0; // conteo de números impares
sum = 0; // reinicie la suma
for (int number=1; number <= upperbound; number=number+2) {
++count;
sum += number;
}
cout << "La suma de los números impares es " << sum << endl;
cout << "El promedio es " << (double)sum / count << endl;
}Salida:
Ingrese el límite superior: 15
La suma es 120
El promedio es 8
La suma de los números impares es 64
El promedio es 8
Interrumpiendo el flujo de bucle - 'break' y 'continue'
La instrucción break sale y termina el bucle actual (el más interno).
La instrucción continue aborta la iteración actual y continúa con la siguiente iteración del bucle actual (el más interno).
break y continue son estructuras pobres ya que son difíciles de leer y seguir. Utilízalos solo si es absolutamente necesario. Siempre puedes escribir el mismo programa sin utilizar break y continue.
El siguiente programa lista los números no primos entre 2 y un límite superior.
/*
* Lista los números no primos de 1 a un límite superior.
*/
#include <iostream>
#include <cmath>
using namespace std;
int main() {
int upperbound;
cout << "Ingrese el límite superior: ";
cin >> upperbound;
for (int number = 2; number <= upperbound; ++number) {
// No es primo, si hay un factor entre 2 y la raíz cuadrada de number
int maxFactor = (int)sqrt(number);
for (int factor = 2; factor <= maxFactor; ++factor) {
if (number % factor == 0) { // ¿Es factor?
cout << number << " ";
break; // Se encontró un factor, no es necesario buscar más factores
}
}
}
cout << endl;
return 0;
}Salida:
Ingrese el límite superior: 20
4 6 8 9 10 12 14 15 16 18 20
Vamos a reescribir el programa anterior para que liste todos los números primos en su lugar. Una bandera boolean llamada isPrime se utiliza para indicar si el número actual es primo. Luego se utiliza para controlar la impresión.
/*
* Lista los números primos de 1 a un límite superior.
*/
#include <iostream>
#include <cmath>
using namespace std;
int main() {
int upperbound;
cout << "Ingrese el límite superior: ";
cin >> upperbound;
for (int number = 2; number <= upperbound; ++number) {
// No es primo, si hay un factor entre 2 y la raíz cuadrada de number
int maxFactor = (int)sqrt(number);
bool isPrime = true; // Bandera boolean para indicar si number es primo
for (int factor = 2; factor <= maxFactor; ++factor) {
if (number % factor == 0) { // ¿Es factor?
isPrime = false; // number no es primo
break; // Se encontró un factor, no es necesario buscar más factores
}
}
if (isPrime) cout << number << " ";
}
cout << endl;
return 0;
}Salida:
Ingrese el límite superior: 100
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
Estudia el siguiente programa que utiliza break y continue.
/* Una serie misteriosa */
#include <iostream>
using namespace std;
int main() {
int number = 1;
while (true) {
++number;
if ((number % 3) == 0) continue;
if (number == 53) break;
if ((number % 2) == 0) {
number += 3;
} else {
number -= 3;
}
cout << number << " ";
}
cout << endl;
return 0;
}Salida:
5 4 2 7 11 10 8 13 17 16 14 19 23 22 20 25 29 28 26 31 35 34 32 37 41 40 38 43 47 46 44 49 53 52
Finalizando el programa
Hay varias maneras de terminar su programa, antes de llegar al final de las declaraciones de programación.
exit(): Puede invocar la función exit(int exitCode), en <cstdlib> (importada de "stdlib.h" de C), para terminar el programa y devolver el control al Sistema Operativo. Por convención, un código de retorno de cero indica una terminación normal; mientras que un exitCode no nulo (-1) indica una terminación anormal. Por ejemplo,
abort(): El encabezado <cstdlib> también proporciona una función llamada abort(), que se puede utilizar para terminar el programa anormalmente.
if (errorCount > 10) {
cout << "demasiados errores" << endl;
exit(-1); // Termina el programa
// O abort();
}Bucles anidados
El siguiente diagrama ilustra un bucle for anidado, es decir, un bucle for interno dentro de un bucle for externo.
/*
* Imprime un patrón de triángulo.
*/
#include <iostream>
using namespace std;
int main() {
int size = 8;
for (int row = 1; row <= size; ++row) { // Bucle externo para imprimir todas las filas
for (int col = 1; col <= size-row+1; ++col) { // Bucle interno para imprimir todas las columnas de cada fila
cout << "## ";
}
cout << endl; // Una fila ha terminado, mueva el cursor a la siguiente línea
}
return 0;
}Salida:
## ## ## ## ## ## ## #
## ## ## ## ## ## #
## ## ## ## ## #
## ## ## ## #
## ## ## #
## ## #
## #
#
La siguiente construcción se utiliza comúnmente:
while (true) { ...... }Parece ser un bucle interminable (o bucle infinito), pero por lo general se termina a través de una instrucción break o return dentro del cuerpo del bucle. Este tipo de código es difícil de leer: evítelo si es posible reescribiendo la condición.
Resumen
Introdujimos tres estructuras de control en esta sección. Son muy útiles. Puedes combinarlas. Ten cuidado con los bucles, comprueba la condición terminal, para evitar bucles interminables.
