Capítulo 2 – Estructuras de Control

Capítulo 2 – Estructuras de Control
Índice del capítulo 2.1 Introducción 2.2 Algoritmos 2.3 Pseudocódigo 2.4 Estructuras de Control 2.5 La Estructura de Selección if 2.6 La Estructura de Selección if/else 2.7 La Estructura de Repetición while 2.8 Formulación de Algoritmos: Caso de Estudio 1 (Repetición Controlada por Contador) 2.9 Formulación de Algoritmos con Refinación Descendente Paso a Paso: Caso de Estudio 2 (Repetición Controlada por Centinela) Formulación de Algoritmos con Refinación Descendente Paso a Paso: Caso de Estudio 3 (Estructuras de Control Anidadas) Operadores de Asignación Operadores de Incremento y Decremento

Capítulo 2 – Estructuras de Control
Índice del capítulo Fundamentos de la Repetición Controlada por Contador La Estructura de Repetición for Ejemplos del Uso de la Estructura for La Estructura switch de Selección Múltiple La Estructura de Repetición do/while Las Instrucciones break y continue Operadores Lógicos Confusión de los Operadores de Igualdad (==) y Asignación (=) Resumen de la Programación Estructurada

Antes de escribir un programa
2.1 Introducción Antes de escribir un programa Entender a fondo el problema Contar con un enfoque cuidadosamente planificado para resolverlo Al escribir un programa Saber los tipos de “bloques de construcción” disponibles Emplear principios correctos de construcción de programas

Problemas de computación
2.2 Algoritmos Problemas de computación Pueden resolverse ejecutando una serie de acciones en un orden específico Algoritmo=procedimiento para resolver problemas en términos de: Acciones a ejecutar Orden en que se ejecutarán las acciones Ejemplo: levantarse por la mañana para ir a clase Control del Programa Especifica el orden en que se deben ejecutar las instrucciones

No se ejecuta en la computadora
2.3 Pseudocódigo Pseudocódigo Lenguaje artificial e informal usado para el desarrollo de algoritmos Similar al inglés común No es un lenguaje de programación No se ejecuta en la computadora Ayuda a “pensar” en el programa antes de escribirlo en un lenguaje de programación Fácilmente convertible en un programa de C++ Describe sólo instrucciones ejecutables No es necesario declarar variables

2.4 Estructuras de Control
Ejecución Secuencial Sentencias ejecutadas en orden Transferencia de control Siguiente sentencia a ejecutar NO es siguiente en secuencia 3 estructuras de control (Bohm y Jacopini, 1966) Estructura de Secuencia Por defecto, los programas se ejecutan secuencialmente Estructuras de Selección if (selección única), if/else (doble selección), switch (selección múltiple) Estructuras de Repetición o Lazos while, do/while, for

Palabras clave de C++ No pueden usarse como identificadores, como es el caso de los nombres de variables

Diagrama de Actividad en UML Representación gráfica de un algoritmo Símbolos conectados por flechas de transición: orden de ejecución Rectángulo redondeado (símbolo de acción) Cualquier tipo de acción Círculo negro (Estado inicial) Círculo negro sobre círculo blanco (Estado final) Romboide (símbolo de decisión) Rectángulos con esquina doblada: Anotaciones

Estructuras de control entrada única/salida única Se conecta el punto de salida de una estructura de control con el punto de entrada de la siguiente Combinación de estructuras de control Apilamiento de estructuras de control Anidamiento de estructuras de control

2.5 Estructura de Selección if
Para elegir entre alternativas de acción Ejemplo en pseudocódigo: Si la nota del estudiante es mayor o igual que 60 Imprime “Aprobado” Si la condición es cierta (true) Se ejecuta la sentencia de impresión y el programa continúa en la siguiente sentencia Si la condición es falsa (false) Se ignora la sentencia de impresión, y el programa continúa Las tabulaciones hacen que los programas se lean fácilmente C++ ignora los caracteres de espacios en blanco (tabuladores, espacios, saltos de línea, etc.)

Traducción a C++ Si la nota del estudiante es mayor o igual que 60 Imprime “Aprobado” if ( nota >= 60 ) cout << "Aprobado"; Símbolo diamante (símbolo de decisión) Indica que debe tomarse una decisión Contiene una expresión que puede ser verdadera o falsa Evalúa la condición, sigue el camino Estructura if Entrada única/Salida única

Diagrama de actividad en UML Se puede tomar una decisión a partir de cualquier expresión. cero - false no cero - true Ejemplo: 3 - 4 es true

2.6 Estructura de Selección if/else
Ejecuta la acción sólo cuando la condición es VERDADERA if/else Diferentes acciones si la condición es verdadera o falsa Pseudocódigo Si la nota del estudiante es mayor o igual a 60 Imprime “Aprobado” sino Imprime “Suspenso” Código C++ if ( nota >= 60 ) cout << "Aprobado"; else cout << "Suspenso";

Operador condicional ternario (?:) Tres argumentos (condición, valor si true, valor si false) Escritura del código: cout << ( nota >= 60 ? "Aprobado" : "Suspenso" ); Condición Valor si verdadera Valor si falsa

Estructuras if/else anidadas Una dentro de otra, evalúan múltiples casos Si una condición se cumple, se saltan las demás sentencias Si la nota del estudiante es mayor o igual que 9 Imprime “MH” sino si la nota del estudiante es mayor o igual que Imprime “SB” sino si la nota del estudiante es mayor o igual que Imprime “NT” sino si la nota del estudiante es mayor o igual que Imprime “AP” sino Imprime “SU”

Ejemplo if ( nota >= 9 ) // 9 o más cout << "MH"; else if ( nota >= 8 ) // 8-8, cout << "SB"; else if ( nota >= 7 ) // 7-7, cout << "NT"; else if ( nota >= 5 ) // 5-5, cout << "AP"; else // menor que cout << "SU";

Instrucción compuesta Conjunto de sentencias contenidas entre un par de llaves if ( nota >= 5 ) cout << "Aprobado.\n"; else { cout << "Suspenso.\n"; cout << "Tienes que repetir curso.\n"; } Sin llaves, cout << " Tienes que repetir curso.\n"; siempre se ejecutaría Bloque Conjunto de sentencias entre llaves

2.7 Estructura de Repetición while
La acción debe repetirse mientras cierta condición sea verdadera Pseudocódigo Mientras haya más elementos en mi lista de la compra Compra el siguiente elemento y elimínalo de la lista El lazo while se repite hasta que la condición se vuelva falsa Ejemplo: encontrar la 1ª potencia de 2 > 1000 int producto = 2; while ( producto <= 1000 ) producto = 2 * producto;

2.7 Estructura de Repetición while
Diagrama de actividad UML del bucle while

2.8 Formulación de Algoritmos (Repetición Controlada por Contador)
El bucle se repite hasta que el contador alcanza un valor determinado. El contador controla nº iteraciones bucle. Repetición definida Antes de iniciar la ejecución del ciclo se conoce la cantidad de repeticiones Ejemplo Un grupo de 10 alumnos hizo un examen. Tenemos acceso a las notas de este examen (enteros en el rango de 0 a 10). Calcular el valor medio de las notas del grupo.

2.8 Formulación de Algoritmos (Repetición Controlada por Contador)
Pseudocódigo del ejemplo: Da al total el valor 0 Da al contador de calificaciones el valor 1 Mientras el contador de calificaciones sea menor o igual que 10 Introduce la siguiente calificación Suma la calificación al total Suma 1 al contador de calificaciones Da al valor medio del grupo el valor del total dividido entre 10 Imprime el valor medio A continuación: código C++ para este ejemplo

Declaración de variables locales
// Fig. 2.7: fig02_07.cpp // Cálculo del promedio con repetición controlada por contador. #include <iostream> 4 using std::cout; using std::cin; using std::endl; 8 // la función main comienza la ejecución del programa 10 int main() 11 { int total; // suma de notas int contadorNotas; // número de notas introducidas int nota; // una nota int promedio; // valor medio de notas 16 // fase de inicialización total = 0; // inicializa el total contadorNotas = 1; // inicializa el contador del bucle 20 Declaración de variables locales Inicialización Es conveniente inicializar totales a 0 y contadores a 0 o 1

21 // fase de procesamiento
while ( contadorNotas <= 10 ) { // realiza el ciclo 10 veces cout << "Introduce la nota: "; // solicita entrada cin >> nota; // lee la nota total = total + nota; // suma la nota al total contadorNotas = contadorNotas + 1;// incrementa contador } 28 // fase de terminación promedio = total / 10; // división entera 31 // Visualización de resultado cout << "El promedio del grupo es " << promedio << endl; 34 return 0; // indica que el programa terminó correctamente 36 37 } // fin de la función main El contador se ve incrementado cada vez que se ejecuta el ciclo. Finalmente, el contador provoca la finalización del bucle. Introduce la nota: 98 Introduce la nota : 76 Introduce la nota : 71 Introduce la nota : 87 Introduce la nota : 83 Introduce la nota : 90 Introduce la nota : 57 Introduce la nota : 79 Introduce la nota : 82 Introduce la nota : 94 El promedio del grupo es 81

2.9 Formulación de Algoritmos (Repetición Controlada por Centinela)
Consideremos la modificación del ejemplo: Desarrolle un programa de cálculo del promedio de un grupo que procese una cantidad arbitraria de notas cada vez que se ejecute el programa No se conoce el número de estudiantes ¿Cómo sabrá el programa cuándo terminar? Valor centinela Indica “fin de la entrada de datos” El bucle finaliza cuando se introduce el centinela Valor del centinela: no puede confundirse con una valor de entrada válido (-1 en este caso) Repetición indefinida (no se conoce el nº iteraciones)

Refinación descendente paso a paso Comenzamos con una representación del pseudocódigo de la parte superior Determina el promedio del grupo en el examen La dividimos en tareas menores, y las escribimos en el orden en que necesitan ejecutarse (1ª refinación: secuencia) Inicializa las variables Introduce, suma y cuenta las notas del examen Calcula e imprime el promedio del grupo

Muchos programas pueden dividirse en 3 fases: Inicialización Inicializa las variables del programa Procesamiento Introduce los datos de entrada, ajusta las variables del programa de acuerdo con los datos de entrada Terminación Calcula e imprime los resultados finales Ayuda a dividir los programas para la refinación descendente

2º Refinamiento Refinamiento de la fase de inicialización Inicializa las variables puede refinarse como: Inicializa el total a cero Inicializa el contador a cero Refinamiento de la fase de Procesamiento Introduce, suma y cuenta las notas del examen Introduce la primera nota (puede ser el centinela) Mientras el usuario no introduzca el valor centinela Suma esta nota al total Suma 1 al contador de calificaciones Introduce la siguiente nota (puede ser el centinela) Requiere estructura de repetición No sabemos nº notas  repetición controlada por centinela

Refinamiento de la fase de Terminación Calcula e imprime el promedio del grupo puede refinarse como: Si el contador de notas no es igual a 0 Establece el promedio como el total dividido entre el contador de notas Imprime el promedio sino Imprime “No se introdujeron notas” A veces, son necesarios más de 2 pasos de refinamiento para traducir pseudocódigo a C++ A continuación: programa C++ ¿División por cero?

Tipo de datos double usado para representar números decimales.
// Fig. 2.9: fig02_09.cpp // Programa de promedio con repetición controlada por centinela. #include <iostream> 4 using std::cout; using std::cin; using std::endl; using std::fixed; 9 10 #include <iomanip> // manipuladores de flujo con parámetros 11 12 using std::setprecision; // fija la precisión numérica de la salida 13 14 // la función main comienza la ejecución del programa 15 int main() 16 { int total; // suma de notas int contadorNotas; // número de notas introducidas int nota; // valor de una nota 20 double promedio; // número con punto decimal para el promedio 22 // fase de inicialización total = 0; // inicializa total contadorNotas = 0; // inicializa contador de lazo Tipo de datos double usado para representar números decimales. Inicializo el contador a 0

Conversión explícita o molde:
26 // Fase de procesamiento // Pide la primera nota al usuario cout << "Introduce la nota, -1 para terminar: "; // solicitud cin >> nota; // lee la nota 31 // lazo hasta que el usuario introduzca el valor centinela while ( nota != -1 ) { total = total + nota; // suma nota al total contadorNotas = contadorNotas + 1; // incrementa contador 36 cout << "Introduce la nota, -1 para terminar: "; // solicitud cin >> nota; // lee la siguiente nota 39 } // fin del bucle while 41 // fase de terminación // si el usuario introdujo al menos una nota ... if ( contadorNotas != 0 ) { 45 // calcula el promedio de todas las notas introducidas promedio = static_cast< double >( total ) / contadorNotas; 48 Importante indicar al usuario lo que debe hacer Incrementa contador sólo si nota válida Líneas 33 y 44: Apilamiento de estructuras de control Conversión explícita o molde: static_cast<double>() trata total como double temporalmente (molde o cast). Necesario pues la división de dos enteros trunca el resto. Conversión implícita o promoción: contadorNotas es un int, pero se promueve a double para evaluar la expresión, pues el numerador es double.

Manipulador de flujo con parámetros setprecision(2)
// visualiza el promedio con 2 dígitos de precisión cout << "El promedio del grupo es " << setprecision( 2 ) << fixed << promedio << endl; 52 } // finaliza la parte if del if/else 54 else // si no se introducen notas, se imprime un mensaje cout << "No se introdujeron notas" << endl; 57 return 0; // indica que el programa terminó satisfactoriamente 59 60 } // fin de la función main Manipulador de flujo con parámetros setprecision(2) imprime 2 dígitos después del punto decimal (redondeado para ajustar la precisión). Los programas que usen esto deben incluir <iomanip> fixed obliga a que la salida se imprima en formato de punto fijo (no notación científica). Además, obliga que se impriman el punto decimal y los ceros a la derecha Incluir <iostream> Introduce la nota, -1 para terminar: 75 Introduce la nota, -1 para terminar : 94 Introduce la nota, -1 para terminar : 97 Introduce la nota, -1 para terminar : 88 Introduce la nota, -1 para terminar : 70 Introduce la nota, -1 para terminar : 64 Introduce la nota, -1 para terminar : 83 Introduce la nota, -1 para terminar : 89 Introduce la nota, -1 para terminar : -1 El promedio del grupo es 82.50

2.10 Formulación de Algoritmos: (Estructuras de Control Anidadas)
Planteamiento del problema Una universidad tiene una lista de resultados de un test de 10 estudiantes (1 = apto, 2 = no apto). Escriba un programa que analice los resultados. Si son aptos más de 8 estudiantes, imprima “Aumente la Matrícula". Nótese que El programa procesa 10 resultados Número fijo  uso de lazo controlado por contador Se emplean 2 contadores Uno para contar cuántos estudiantes son aptos Otro para contar cuántos estudiantes son no aptos Cada resultado del test es 1 o 2 Si no es 1, suponemos que es 2

Nivel superior Analiza los resultados de los exámenes y decide si debe aumentar la matrícula Primer refinamiento Inicializa las variables Introduce las 10 calificaciones y cuenta los aptos y no aptos Imprime un resumen de resultados del examen y decide si debe aumentar la matrícula 2º refinamiento: Especificación de variables La instrucción puede refinarse como: Inicializa aptos a cero Inicializa noAptos a cero Inicializa el contador de estudiantes (contEstud) a uno Sólo inicializo los contadores

10 calificaciones  repetición controlada por contador La instrucción Introduce las 10 calificaciones y cuenta los aptos y no aptos puede refinarse como: Mientras el contador de estudiantes sea menor o igual que 10 Introduce el siguiente resultado Si el estudiante es apto Suma 1 a aptos sino Suma 1 a noAptos Suma 1 al contador de estudiantes Estructura if/else ANIDADA en lazo mientras

La instrucción Imprime un resumen de resultados del examen y decide si debe aumentar la matrícula puede refinarse como: Imprime el número de aptos Imprime el número de no aptos Si son aptos más de 8 estudiantes Imprime “Aumente la matrícula” A continuación, el programa en C++

Variables locales: Declaración + Inicialización
// Fig. 2.11: fig02_11.cpp // Análisis de resultados de examen. #include <iostream> 4 using std::cout; using std::cin; using std::endl; 8 // la función main inicia la ejecución del programa 10 int main() 11 { // inicializa las variables al mismo tiempo que las declara int aptos = 0; // número de aptos int noAptos = 0; // número de no aptos int contEstud = 1; // contador de estudiantes int resultado; // resultado de un examen 17 // procesa 10 estudiantes; ciclo controlado por contador while ( contEstud <= 10 ) { 20 // solicita entrada al usuario y obtiene valor cout << "Introduzca el resultado (1 = apto, 2 = no apto): "; cin >> resultado; 24 Variables locales: Declaración + Inicialización

if/else anidado en while
// si resultado es 1, incrementa aptos; if/else anidado en while if ( resultado == 1 ) // if/else anidado en while aptos = aptos + 1; 28 else // si resultado no es 1, incrementa no aptos noAptos = noAptos + 1; 31 // el incremento en contEstud provoca la terminación del lazo contEstud = contEstud + 1; 34 } // fin de while 36 // fase de terminación; muestra número de aptos y no aptos cout << “Aptos " << aptos << endl; cout << “No Aptos " << noAptos << endl; 40 // Si son aptos más de 8 estudiantes, imprime "aumenta matrícula" if ( aptos > 8 ) cout << "Aumente matrícula " << endl; 44 return 0; // terminación correcta 46 47 } // fin de función main if/else anidado en while

Introduzca el resultado (1 = apto, 2 = no apto): 1
Aptos 6 No Aptos 4 Aptos 9 No Aptos 1 Aumente matrícula

2.11 Operadores de asignación
Abreviaturas de expresiones de asignación Compilación más rápida Ejemplo: Operador de asignación de suma (+=) c = c + 3; se puede abreviar como c+=3; Sentencias de la forma variable = variable operador expresión; pueden reescribirse como variable operador= expresión; Otros operadores de asignación d -= (d = d - 4) e *= (e = e * 5) f /= (f = f / 3) g %= (g = g % 9)

2.12 Operadores de Incremento y Decremento
Operador de incremento (++) Incrementa la variable en 1 c++ es lo mismo que c += 1 (c=c+1) Operador de decremento (--) Decrementa la variable en 1 c-- es lo mismo que c -= 1 (c=c-1)

Preincremento/Predecremento (+ rápido) El operador se escribe ANTES de la variable (++c o --c) Se modifica la variable, y a continuación se evalúa la expresión. Postincremento/Postdecremento El operador se escribe DESPUÉS de variable (c++ o c--) Se ejecuta la expresión en la que está la variable, y a continuación se modifica la variable.

Si c = 5, entonces cout << ++c; c toma el valor 6, a continuación se imprime 6 cout << c++; Se imprime 5 (cout se ejecuta antes del incremento). A continuación c toma el valor 6 Cuando la variable no está en una expresión El preincremento y el postincremento tienen el mismo efecto Es lo mismo: ++c; cout << c; que c++;

// Fig. 2.14: fig02_14.cpp // Preincremento y postincremento. #include <iostream> 4 using std::cout; using std::endl; 7 // la función main comienza la ejecución del programa int main() 10 { int c; // declaración de la variable 12 // demostración del postincremento c = 5; // asigna 5 a c cout << c << endl; // imprime 5 cout << c++ << endl; // imprime 5 y luego postincrementa cout << c << endl << endl; // imprime 6 18 // demostración del preincremento c = 5; // asigna 5 a c cout << c << endl; // imprime 5 cout << ++c << endl; // preincrementa y luego imprime 6 cout << c << endl; // imprime 6

24 return 0; // indica terminación correcta 26 27 } // fin de función main 5 6

Tabla de precedencia de operadores Operadores Asociatividad Tipo ( ) Izquierda a derecha Paréntesis static_cast<tipo>() Unarios Derecha a izquierda * / % Multiplicativos + - Aditivos << >> Inserción/extracción < <= > >= Relacional == != Igualdad ?: Condicional = += -= *= /= %= Asignación

2.13 Fundamentos de la Repetición Controlada por Contador
La repetición controlada por contador requiere: Nombre de una variable de control (o contador de ciclo) Valor inicial de la variable de control La condición que prueba el valor final de la variable de control El incremento/decremento que tendrá la variable de control cada vez que se ejecute un ciclo Ejemplo: programa que imprime los números del 1 al 10

Al terminar el bucle, contador vale 11
// Fig. 2.16: fig02_16.cpp // Repetición controlada por contador. #include <iostream> 4 using std::cout; using std::endl; 7 // la función main comienza la ejecución del programa int main() 10 { int contador = 1; // inicialización 12 while ( contador <= 10 ) { // condición de repetición cout << contador << endl; // muestra contador contador; // incremento 16 } // fin de while 18 return 0; // indica terminación correcta 20 21 } // fin de función main Declaración + Inicialización Al terminar el bucle, contador vale 11

1 2 3 4 5 6 7 8 9 10

2.13 Fundamentos de la Repetición Controlada por Contador
La declaración int contador = 1; Nombra la variable de control contador Declara contador como un entero Reserva espacio en memoria para contador Da a contador un valor inicial de 1 Si declaro int contador = 0; puedo cambiar el bucle: while (++contador <= 10) cout << contador << endl;

2.14 La Estructura de Repetición for
Maneja todos los detalles de la repetición controlada por contador Formato general del lazo for for ( inicialización; TestContinuaciónLazo;incremento ) sentencia Ejemplo: imprimir los enteros del 1 al 10 for(int contador = 1; contador <= 10; contador++) Valor final de la variable de control para la que la condición es cierta Separador obligatorio ; Separador obligatorio ; Palabra clave for Nombre variable control Valor inicial de la variable de control Condición de continuación del lazo No punto y coma después de la última sentencia Incremento de la variable de control

// Fig. 2.17: fig02_17.cpp // Repetición controlada por contador con la estructura for. #include <iostream> 4 using std::cout; using std::endl; 7 // la función main comienza la ejecución del programa int main() 10 { // Inicialización, condición de repetición e incremento // se incluyen en el encabezado de la estructura for. 13 for ( int contador = 1; contador <= 10; contador++ ) cout << contador << endl; 16 return 0; // indica la terminación correcta 18 19 } // fin de la función main

1 2 3 4 5 6 7 8 9 10

Diagrama de actividad en UML del lazo for

Lazo for puede rescribirse como lazo while inicialización; while ( TestContinuaciónLazo ){ sentencia incremento; } Inicialización e incremento Para varias variables, se usan listas separadas por comas for (int i = 0, j = 0; j + i <= 10; j++, i++) cout << j + i << endl;

Lazo for terminado en ; = lazo de retardo for ( inicialización; TestContinuaciónLazo;incremento ); Puede ser incremento, decremento o cualquier modificación del contador Si la condición inicial es falsa, el lazo for NUNCA se ejecuta. Declaración variable de control en inicialización  el ámbito de la variable de control es el lazo for

2.14 Ejemplos de uso de la Estructura for
Modificar variable control de 1 a 100 con incremento 1 for (int i = 1; i <= 100; i++) Modificar variable control de 100 a 1 con incremento -1 for (int i = 100; i >= 1; i--) Modificar variable control de 7 a 77 en pasos de 7 for (int i = 7; i <= 77; i += 7) Modificar variable control de 20 a 2 en pasos de -2 for (int i = 20; i >= 2; i -= 2) Modificar variable control sobre la secuencia: 2, 5, 8, 11, 14, 17, 20. for (int j = 2; j <= 20; j += 3) Modificar la variable control sobre secuencia: 99, 88, 77, 66, 55, 44, 33, 22, 11, 0 for (int j = 99; j >= 0; j -= 11)

// Fig. 2.20: fig02_20.cpp // Suma con for. #include <iostream> 4 using std::cout; using std::endl; 7 // la función main comienza la ejecución del programa int main() 10 { int suma = 0; // inicializa suma 12 // suma enteros pares de 2 a 100 for ( int numero = 2; numero <= 100; numero += 2 ) suma += numero; // suma numero a suma 16 cout << “La suma is " << suma << endl; // imprime suma return 0; // terminación correcta 19 20 } // fin de la función main La suma es 2550

2.15 Ejemplo de Uso de la Estructura for
Programa para calcular el interés compuesto Una persona invierte 1000€ en una cuenta de ahorros que da un interés del 5%. Suponiendo que todos los intereses se quedan depositados en la cuenta, calcula e imprime la cantidad que tendrá la cuenta al final de cada año durante 10 años. Emplea la siguiente fórmula para determinar las cantidades: a = p(1+r) p es la cantidad invertida inicialmente (es decir, el capital), r es la tasa de interés anual, n es el número de años, y a es la cantidad en depósito al final del año n. n

// Fig. 2.21: fig02_21.cpp // Cálculo del interés compesto. #include <iostream> 4 using std::cout; using std::endl; using std::ios; using std::fixed; 9 10 #include <iomanip> 11 12 using std::setw; 13 using std::setprecision; 14 15 #include <cmath> // permite al programa usar la función pow 16 17 // la función main comienza la ejecución del programa 18 int main() 19 { double cantidad; // cantidad depositada double capital = ; // capital inicial double interes = .05; // tasa de interés 23 <cmath> fichero de cabecera necesario para la función pow (el programa no compilará sin él).

24 // Títulos de las columnas de la tabla de salida
cout << "Año" << setw( 21 ) << "Cantidad depositada" << endl; 26 // fijamos el formato de número en punto flotante cout << fixed << setprecision( 2 ); 29 // calculamos la cantidad en depósito para cada uno de los 10 años for ( int anho = 1; anho <= 10; anho++ ) { 32 // calculamos la nueva cantidad para el año especificado cantidad = capital * pow( interes, anho ); 35 // salida de una fila de la tabla cout << setw( 4 ) << anho << setw( 21 ) << cantidad << endl; 39 } // fin de for 41 return 0; // indica finalización correcta 43 44 } // fin de la función main Manipulador de flujo con parámetros: Fija el ancho del campo de al menos 21 caracteres. Si la salida es menor, se justifica a la derecha. pow(x,y) = x elevado a y.

Años Cantidad depositada
Los números están justificados a la derecha debido a las sentencias setw (en las líneas 4 y 21).

2.16 La Estructura switch de Selección Múltiple
Comprueba múltiples valores en el valor de una variable Serie de etiquetas case y un caso opcional default switch ( variable ) { case valor1: // se toma si variable == valor1 sentencias break; // necesario para salir del switch case valor2: case valor3: // se toma si variable == valor2 o == valor3 break; default: // se toma si variable no cumple ningún caso previo sentencias break; }

Siguiente ejemplo Programa para leer calificaciones (A-F) Muestra la cantidad de notas con cada calificación Detalles sobre caracteres Los caracteres únicos suelen almacenarse en un tipo de datos char char un entero de 1 byte chars pueden almacenarse como ints Se pueden tratar los caracteres como int o char 97 es la representación numérica de ‘a’ (ASCII) Usa comillas simples para obtener la representación numérica de un carácter cout << "El carácter (" << 'a' << ") tiene el valor " << static_cast< int > ( 'a' ) << endl; Imprime El carácter (a) tiene el valor 97

// Fig. 2.22: fig02_22.cpp // Cuenta de calificaciones indicadas por letras. #include <iostream> 4 using std::cout; using std::cin; using std::endl; 8 // la función main comienza la ejecución del programa 10 int main() 11 { int grade; // una calificación int aCont = 0; // cantidad de As int bCont = 0; // cantidad de Bs int cCont = 0; // cantidad de Cs int dCont = 0; // cantidad de Ds int fCont = 0; // cantidad de Fs 18 cout << "Introduzca las calificaciones indicadas con letras." << endl << "Teclee el carácter EOF para terminar la entrada de datos." << endl; 21 Letras de calificación como números enteros, pues EOF (definido en <iostream>) es un número entero (normalmente negativo)

Líneas 30-31: No es necesario que vayan entre llaves
// lazo hasta que el usuario escriba la secuencia fin-de-fichero while ( ( grade = cin.get() ) != EOF ) { 24 // determina qué nota se introdujo switch ( grade ) { // switch anidado en while 27 case 'A': // la nota es A case 'a': // o a aCont; // incrementa aCont break; // necesario para salir de switch 32 case 'B': // la nota es B case 'b': // o b bCont; // incrementa bCont break; // sale de switch 37 case 'C': // la nota es C case 'c': // o c cCont; // incrementa cCont break; // sale de switch 42 Líneas 28-29: Compara grade (un int) con las representaciones numéricas de A y a. Líneas 30-31: No es necesario que vayan entre llaves Línea 41: break causa la finalización de switch y el programa continúa en la primera sentencia después de la estructura switch. Si no ponemos break, se ejecuta el siguiente caso Línea 23: Las sentencias de asignación tienen un valor, que es el de la variable a la izquierda del =. El valor de esta sentencia es el devuelto por cin.get(). Esto puede usarse para inicializar múltiples variables: a = b = c = 0; cin.get() usa la notación punto (se explicará en el capítulo 6). Esta función lee un carácter del teclado (después de pulsar Enter), y lo asigna a grade. cin.get() devuelve EOF (fin-de-fichero) después de introducir el carácter EOF, para indicar el fin de los datos. EOF puede ser ctrl-d (UNIX) o ctrl-z (WINDOWS), dependiendo de tu SO.

Daos cuenta de la sentencia default, que recoge todos los demás casos.
case 'D': // la nota es D case 'd': // o d dCont; // incrementa dCont break; // sale de switch 47 case 'F': // la nota es F case 'f': // o f fCont; // incrementa fCont break; // sale de switch 52 case '\n': // ignora cambios de línea, case '\t': // tabuladores, case ' ': // y espacios en la entrada break; // sale de switch 57 default: // recoge los demás caracteres cout << "Letra de calificación incorrecta." << " Introduzca una nueva calificación." << endl; break; // opcional; en cualquier caso se saldrá de switch 62 } // fin de switch 64 } // fin de while 66 Este test es necesario porque se pulsa Enter después de cada letra de nota. Esto añade un carácter de nueva línea que debe ser eliminado. Asimismo, queremos ignorar cualquier espacio en blanco. Daos cuenta de la sentencia default, que recoge todos los demás casos.

67 // Salida del resumen de resultados
cout << "\n\Los totales para cada calificación son:" << "\nA: " << aCont // número de notas A << "\nB: " << bCont // número de notas B << "\nC: " << cCont // número de notas C << "\nD: " << dCont // número de notas D << "\nF: " << fCont // número de notas F << endl; 75 return 0; // indica finalización correcta 77 78 } // fin de función main

Introduzca las calificaciones indicadas con letras.
Teclee el carácter EOF para terminar la entrada de datos. a B c C A d f E Letra de calificación incorrecta. Introduzca una nueva calificación. D b ^Z Los totales para cada calificación son : A: 3 B: 2 C: 3 D: 2 F: 1

2.17 La Estructura de Repetición do/while
Similar a la estructura while Prueba la condición de continuación del ciclo al final, no al principio El cuerpo del lazo se ejecuta al menos una vez Formato do { sentencias } while ( condición );

Notad el preincremento en el test de continuación de lazo.
// Fig. 2.24: fig02_24.cpp // Uso de la estructura de repetición do/while. #include <iostream> 4 using std::cout; using std::endl; 7 // la función main comienza la ejecución del programa int main() 10 { int contador = 1; // inicializa contador 12 do { cout << contador << " "; // muestra contador } while ( ++contador <= 10 ); // fin de do/while 16 cout << endl; 18 return 0; // indica finalización correcta 20 21 } // fin de función main Notad el preincremento en el test de continuación de lazo.

2.18 Las Instrucciones break y continue
Sentencia break Salida inmediata de while, for, do/while, switch El programa continúa en la primera sentencia después de la estructura Usos comunes Salida antes de tiempo de un bucle Saltar el resto de una estructura switch

Sale de la estructura for cuando se ejecuta break.
// Fig. 2.26: fig02_26.cpp // Uso de la instrucción break en una estructura for. #include <iostream> 4 using std::cout; using std::endl; 7 // la función main comienza la ejecución del programa int main() 10 { 11 int x; // x se declara aquí para poder usarla después del bucle 13 // el bucle se repite 10 veces for ( x = 1; x <= 10; x++ ) { 16 // si x es 5, finaliza el bucle if ( x == 5 ) break; // rompe el bucle sólo si x es 5 20 cout << x << " "; // muestra el valor de x 22 } // fin de for 24 cout << "\nSalida del ciclo con el valor de x en " << x << endl; Sale de la estructura for cuando se ejecuta break.

26 return 0; // indica terminación correcta 28 29 } // fin de función main Salida del ciclo con el valor de x en 5

2.18 Las Instrucciones break y continue
Instrucción continue Usada en while, for, do/while Salta el resto del cuerpo del lazo Continúa con la siguiente iteración del ciclo Estructuras while y do/while Tras la ejecución de la instrucción continue, se evalúa de inmediato la prueba de continuación del ciclo Estructura for Se ejecuta la expresión de incremento A continuación, se evalúa la prueba de continuación del ciclo

Salta a la siguiente iteración del lazo.
// Fig. 2.27: fig02_27.cpp // Uso de la instrucción continue en una estructura for. #include <iostream> 4 using std::cout; using std::endl; 7 // la función main comienza la ejecución del programa int main() 10 { // lazo 10 veces for ( int x = 1; x <= 10; x++ ) { 13 // si x es 5, continúa con la siguiente iteración if ( x == 5 ) continue; // salta el resto del código de este ciclo 17 cout << x << " "; // muestra el valor de x 19 } // fin de la estructura for 21 cout << "\nSe utiliza continue para no imprimir el valor 5" << endl; 24 return 0; // indica terminación correcta Salta a la siguiente iteración del lazo.

26 27 } // fin de la función main
Se utiliza continue para no imprimir el valor 5

Usados como condiciones en lazos y sentencias if && (Y lógico )
2.19 Operadores Lógicos Usados como condiciones en lazos y sentencias if && (Y lógico ) verdadero si las dos condiciones son verdaderas == y >= tienen mayor precedencia que && if ( género == 1 && edad >= 65 ) ++mujeresMayores; Error: 3<x<7 Hay que poner: 3<x && x<7 || (O lógico) verdadero si cualquiera de las condiciones es verdadera if ( mediaCuatrimestre >= 9 || examenFinal >= 9 ) cout << "La nota del estudiante es A" << endl;

! (NO lógico, negación lógica)
2.19 Operadores Lógicos ! (NO lógico, negación lógica) Devuelve verdadero cuando su condición es falsa, y viceversa ! tiene mayor precedencia que ==  paréntesis if ( !( nota == valorCentinela ) ) cout << "La siguiente nota es " << nota << endl; Alternativa: if ( nota != valorCentinela ) cout << "La siguiente nota es " << nota << endl; Orden de precedencia: ! && || Todos se asocian de izquierda a derecha

Tabla de precedencia de operadores y asociatividad
2.19 Operadores Lógicos Tabla de precedencia de operadores y asociatividad Operadores Asociatividad Tipo ( ) Izquierda a derecha Paréntesis static_cast<tipo>() Unarios ! Derecha a izquierda * / % Multiplicativos + - Aditivos << >> Inserción/extracción < <= > >= Relacional == != Igualdad && Y lógico || O lógico ?: Condicional = += -= *= /= %= Asignación , Coma

2.20 Confusión de los Operadores de Igualdad (==) y Asignación (=)
Error común No suelen producir errores de sintaxis Aspectos que causan el problema Cualquier expresión que produzca un valor puede servir en la parte de decisión de cualquier estructura de control Cero = falso, Distinto-de-cero = verdadero Las sentencias de asignación producen un valor (asignado a la variable de la izquierda del operador de asignación)

Ejemplo if ( codigoPago == 4 ) cout << "¡Tienes una extra!" << endl; Si el código de pago es 4, se da una bonificación Si == es reemplazado por = if ( codigoPago = 4 ) cout << "¡Tienes una extra!" << endl; El codigoPago se fija en 4 (no importa el valor que tuviera antes) La sentencia es verdadera (pues 4 es distinto de cero) Se da la bonificación en cualquier caso

Lvalues (valores izquierdos) Expresiones que pueden utilizarse del lado izquierdo de un operador de asignación Pueden ser modificados (variables) x = 4; Rvalues (valores derechos) Sólo aparecen al lado derecho de las asignaciones Constantes, como números (no se puede poner 4 = x;) Lvalues pueden usarse como rvalues, pero no viceversa

2.21 Resumen de la Programación Estructurada
Programas más fáciles de entender, probar, depurar y modificar Resumen de estructuras de control de C++ Apilamiento Anidamiento

Reglas de la programación estructurada Sólo se usan estructuras de control de entrada única/salida única Reglas 1) Comienza por el “diagrama de flujo más sencillo” 2) Cualquier rectángulo (acción) puede reemplazarse con dos rectángulos (acciones) en secuencia 3) Cualquier rectángulo (acción) puede reemplazarse con cualquier estructura de control (secuencia, if, if/else, switch, while, do/while o for) 4) Las reglas 2 y 3 pueden aplicarse con la frecuencia que se desee y en cualquier orden

Representación de la Regla 1: comienzo por una única acción Representación de la Regla 2 (Regla de apilamiento): reemplazar cualquier rectángulo con una secuencia de rectángulos

Representación de la Regla 3 (Regla de Anidamiento): reemplazar cualquier rectángulo con una estructura de control

Cualquier programa C++ puede expresarse en términos de: Secuencia Selección if, if/else, o switch Cualquier selección puede reescribirse como una sentencia if Repetición while, do/while o for Cualquier estructura de repetición puede reescribirse como una sentencia while Combinadas de dos formas: Apilamiento Anidamiento

Capítulo 2 – Estructuras de Control

Presentaciones similares

Presentación del tema: "Capítulo 2 – Estructuras de Control"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback

Iniciar la sesión

Autorizarse a través de una red social:

Capítulo 2 – Estructuras de Control

Presentaciones similares

Presentación del tema: "Capítulo 2 – Estructuras de Control"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback