2003 prentice hall, inc. all rights reserved. 1 capítulo 2 – estructuras de control Índice del...
TRANSCRIPT
2003 Prentice Hall, Inc. All rights reserved.
1
Capítulo 2 – Estructuras de Control
Índice del capítulo2.1 Introducción2.2 Algoritmos2.3 Pseudocódigo2.4 Estructuras de Control 2.5 La Estructura de Selección if 2.6 La Estructura de Selección if/else2.7 La Estructura de Repetición while2.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)2.10 Formulación de Algoritmos con Refinación Descendente
Paso a Paso: Caso de Estudio 3 (Estructuras de ControlAnidadas)
2.11 Operadores de Asignación2.12 Operadores de Incremento y Decremento
2003 Prentice Hall, Inc. All rights reserved.
2
Capítulo 2 – Estructuras de ControlÍndice del capítulo2.13 Fundamentos de la Repetición Controlada por Contador2.14 La Estructura de Repetición for2.15 Ejemplos del Uso de la Estructura for2.16 La Estructura switch de Selección Múltiple2.17 La Estructura de Repetición do/while2.18 Las Instrucciones break y continue2.19 Operadores Lógicos2.20 Confusión de los Operadores de Igualdad (==) y
Asignación (=)2.21 Resumen de la Programación Estructurada
2003 Prentice Hall, Inc. All rights reserved.
3
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
2003 Prentice Hall, Inc. All rights reserved.
4
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
2003 Prentice Hall, Inc. All rights reserved.
5
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
2003 Prentice Hall, Inc. All rights reserved.
6
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
2003 Prentice Hall, Inc. All rights reserved.
7
2.4 Estructuras de Control• Palabras clave de C++
– No pueden usarse como identificadores, como es el caso de los nombres de variables
Palabras Clave de C++
Palabras Clave comunes a los lenguajes de programación C y C++
auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while Palabras Clave exclusivas de C++
asm bool catch class const_cast delete dynamic_cast explicit false friend inline mutable namespace new operator private protected public reinterpret_cast static_cast template this throw true try typeid typename using virtual wchar_t
2003 Prentice Hall, Inc. All rights reserved.
8
2.4 Estructuras de Control• 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
2003 Prentice Hall, Inc. All rights reserved.
9
2.4 Estructuras de Control
• 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
2003 Prentice Hall, Inc. All rights reserved.
10
2.5 Estructura de Selección if
• Estructura de selección– 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.)
2003 Prentice Hall, Inc. All rights reserved.
11
2.5 Estructura de Selección if
• 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
2003 Prentice Hall, Inc. All rights reserved.
12
2.5 Estructura de Selección if
• 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
2003 Prentice Hall, Inc. All rights reserved.
13
2.6 Estructura de Selección if/else
• if– 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ódigoSi 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";
2003 Prentice Hall, Inc. All rights reserved.
14
2.6 Estructura de Selección if/else
• 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
2003 Prentice Hall, Inc. All rights reserved.
15
2.6 Estructura de Selección if/else
• Estructuras if/else anidadas– Una dentro de otra, evalúan múltiples casos
– Si una condición se cumple, se saltan las demás sentenciasSi la nota del estudiante es mayor o igual que 9
Imprime “MH”
sino si la nota del estudiante es mayor o igual que 8
Imprime “SB”sino
si la nota del estudiante es mayor o igual que 7 Imprime “NT” sino si la nota del estudiante es mayor o igual que 5 Imprime “AP”
sino
Imprime “SU”
2003 Prentice Hall, Inc. All rights reserved.
16
2.6 Estructura de Selección if/else
• Ejemplo
if ( nota >= 9 ) // 9 o más cout << "MH";else if ( nota >= 8 ) // 8-8,9 cout << "SB";else if ( nota >= 7 ) // 7-7,9 cout << "NT"; else if ( nota >= 5 ) // 5-5,9 cout << "AP";else // menor que 5 cout << "SU";
2003 Prentice Hall, Inc. All rights reserved.
17
2.6 Estructura de Selección if/else
• 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
2003 Prentice Hall, Inc. All rights reserved.
18
2.7 Estructura de Repetición while
• Estructura de repetición– La acción debe repetirse mientras cierta condición sea
verdadera
– PseudocódigoMientras 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 > 1000int producto = 2;
while ( producto <= 1000 )
producto = 2 * producto;
2003 Prentice Hall, Inc. All rights reserved.
19
2.7 Estructura de Repetición while
• Diagrama de actividad UML del bucle while
2003 Prentice Hall, Inc. All rights reserved.
20
2.8 Formulación de Algoritmos (Repetición Controlada por Contador)
• 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.
2003 Prentice Hall, Inc. All rights reserved.
21
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 10Introduce la siguiente calificaciónSuma la calificación al totalSuma 1 al contador de calificaciones
Da al valor medio del grupo el valor del total dividido entre 10Imprime el valor medio
• A continuación: código C++ para este ejemplo
2003 Prentice Hall, Inc.All rights reserved.
Outline22
1 // Fig. 2.7: fig02_07.cpp2 // Cálculo del promedio con repetición controlada por contador.3 #include <iostream>4 5 using std::cout;6 using std::cin;7 using std::endl;8 9 // la función main comienza la ejecución del programa10 int main()11 {12 int total; // suma de notas13 int contadorNotas; // número de notas introducidas14 int nota; // una nota15 int promedio; // valor medio de notas16 17 // fase de inicialización18 total = 0; // inicializa el total19 contadorNotas = 1; // inicializa el contador del bucle20
Declaración de variables locales
Inicialización
Es conveniente inicializar totales a 0 y contadores a 0 o 1
2003 Prentice Hall, Inc.All rights reserved.
Outline23
21 // fase de procesamiento22 while ( contadorNotas <= 10 ) { // realiza el ciclo 10 veces23 cout << "Introduce la nota: "; // solicita entrada24 cin >> nota; // lee la nota25 total = total + nota; // suma la nota al total26 contadorNotas = contadorNotas + 1;// incrementa contador27 }28 29 // fase de terminación30 promedio = total / 10; // división entera31 32 // Visualización de resultado33 cout << "El promedio del grupo es " << promedio << endl; 34 35 return 0; // indica que el programa terminó correctamente36 37 } // fin de la función main
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
El contador se ve incrementado cada vez que se ejecuta el ciclo. Finalmente, el contador provoca la finalización del bucle.
2003 Prentice Hall, Inc. All rights reserved.
242.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)
2003 Prentice Hall, Inc. All rights reserved.
252.9 Formulación de Algoritmos (Repetición Controlada por
Centinela)• 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
2003 Prentice Hall, Inc. All rights reserved.
262.9 Formulación de Algoritmos (Repetición Controlada por
Centinela)• 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
2003 Prentice Hall, Inc. All rights reserved.
272.9 Formulación de Algoritmos (Repetición Controlada por
Centinela)• 2º Refinamiento
– Refinamiento de la fase de inicializaciónInicializa las variables
puede refinarse como:Inicializa el total a ceroInicializa el contador a cero
– Refinamiento de la fase de ProcesamientoIntroduce, suma y cuenta las notas del examen
puede refinarse como: 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
2003 Prentice Hall, Inc. All rights reserved.
282.9 Formulación de Algoritmos (Repetición Controlada por
Centinela)– Refinamiento de la fase de Terminación
Calcula e imprime el promedio del grupopuede 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 promediosino 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?
2003 Prentice Hall, Inc.All rights reserved.
Outline29
1 // Fig. 2.9: fig02_09.cpp2 // Programa de promedio con repetición controlada por centinela.3 #include <iostream>4 5 using std::cout;6 using std::cin;7 using std::endl;8 using std::fixed;9 10 #include <iomanip> // manipuladores de flujo con parámetros11 12 using std::setprecision; // fija la precisión numérica de la salida13 14 // la función main comienza la ejecución del programa15 int main()16 {17 int total; // suma de notas18 int contadorNotas; // número de notas introducidas19 int nota; // valor de una nota20 21 double promedio; // número con punto decimal para el promedio22 23 // fase de inicialización24 total = 0; // inicializa total25 contadorNotas = 0; // inicializa contador de lazo
Tipo de datos double usado para representar números decimales.
Inicializo el contador a 0
2003 Prentice Hall, Inc.All rights reserved.
Outline30
26 27 // Fase de procesamiento28 // Pide la primera nota al usuario29 cout << "Introduce la nota, -1 para terminar: "; // solicitud30 cin >> nota; // lee la nota31 32 // lazo hasta que el usuario introduzca el valor centinela33 while ( nota != -1 ) { 34 total = total + nota; // suma nota al total35 contadorNotas = contadorNotas + 1; // incrementa contador36 37 cout << "Introduce la nota, -1 para terminar: "; // solicitud38 cin >> nota; // lee la siguiente nota39 40 } // fin del bucle while41 42 // fase de terminación43 // si el usuario introdujo al menos una nota ...44 if ( contadorNotas != 0 ) {45 46 // calcula el promedio de todas las notas introducidas47 promedio = static_cast< double >( total ) / contadorNotas;48
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.
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
2003 Prentice Hall, Inc.All rights reserved.
Outline31
49 // visualiza el promedio con 2 dígitos de precisión50 cout << "El promedio del grupo es " << setprecision( 2 )51 << fixed << promedio << endl;52 53 } // finaliza la parte if del if/else54 55 else // si no se introducen notas, se imprime un mensaje56 cout << "No se introdujeron notas" << endl;57 58 return 0; // indica que el programa terminó satisfactoriamente59 60 } // fin de la función main
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
Manipulador de flujo con parámetrossetprecision(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 derechaIncluir <iostream>
2003 Prentice Hall, Inc. All rights reserved.
32
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
2003 Prentice Hall, Inc. All rights reserved.
33
2.10 Formulación de Algoritmos: (Estructuras de Control Anidadas)
• Nivel superiorAnaliza los resultados de los exámenes y decide si debe aumentar la
matrícula
• Primer refinamientoInicializa 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
Inicializa las variables
puede refinarse como:
Inicializa aptos a cero
Inicializa noAptos a cero
Inicializa el contador de estudiantes (contEstud) a uno
Sólo inicializo los contadores
2003 Prentice Hall, Inc. All rights reserved.
34
2.10 Formulación de Algoritmos: (Estructuras de Control Anidadas)
– La instrucciónIntroduce las 10 calificaciones y cuenta los aptos y no aptos
puede refinarse como:
Mientras el contador de estudiantes sea menor o igual que 10Introduce el siguiente resultado
Si el estudiante es apto
Suma 1 a aptossino Suma 1 a noAptos
Suma 1 al contador de estudiantes
10 calificaciones repetición controlada por contador
Estructura if/else ANIDADA en lazo
mientras
2003 Prentice Hall, Inc. All rights reserved.
35
2.10 Formulación de Algoritmos: (Estructuras de Control Anidadas)
– La instrucciónImprime 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 estudiantesImprime “Aumente la matrícula”
• A continuación, el programa en C++
2003 Prentice Hall, Inc.All rights reserved.
Outline36
1 // Fig. 2.11: fig02_11.cpp2 // Análisis de resultados de examen.3 #include <iostream>4 5 using std::cout;6 using std::cin;7 using std::endl;8 9 // la función main inicia la ejecución del programa10 int main()11 {12 // inicializa las variables al mismo tiempo que las declara13 int aptos = 0; // número de aptos14 int noAptos = 0; // número de no aptos15 int contEstud = 1; // contador de estudiantes16 int resultado; // resultado de un examen17 18 // procesa 10 estudiantes; ciclo controlado por contador19 while ( contEstud <= 10 ) {20 21 // solicita entrada al usuario y obtiene valor22 cout << "Introduzca el resultado (1 = apto, 2 = no apto): ";23 cin >> resultado;24
Variables locales: Declaración + Inicialización
2003 Prentice Hall, Inc.All rights reserved.
Outline37
25 // si resultado es 1, incrementa aptos; if/else anidado en while26 if ( resultado == 1 ) // if/else anidado en while27 aptos = aptos + 1; 28 29 else // si resultado no es 1, incrementa no aptos 30 noAptos = noAptos + 1; 31 32 // el incremento en contEstud provoca la terminación del lazo33 contEstud = contEstud + 1; 34 35 } // fin de while36 37 // fase de terminación; muestra número de aptos y no aptos38 cout << “Aptos " << aptos << endl; 39 cout << “No Aptos " << noAptos << endl;40 41 // Si son aptos más de 8 estudiantes, imprime "aumenta matrícula"42 if ( aptos > 8 )43 cout << "Aumente matrícula " << endl; 44 45 return 0; // terminación correcta46 47 } // fin de función main
if/else anidado en while
2003 Prentice Hall, Inc.All rights reserved.
Outline38
Introduzca el resultado (1 = apto, 2 = no apto): 1
Introduzca el resultado (1 = apto, 2 = no apto): 2
Introduzca el resultado (1 = apto, 2 = no apto): 2
Introduzca el resultado (1 = apto, 2 = no apto): 1
Introduzca el resultado (1 = apto, 2 = no apto): 1
Introduzca el resultado (1 = apto, 2 = no apto): 1
Introduzca el resultado (1 = apto, 2 = no apto): 2
Introduzca el resultado (1 = apto, 2 = no apto): 1
Introduzca el resultado (1 = apto, 2 = no apto): 1
Introduzca el resultado (1 = apto, 2 = no apto): 2
Aptos 6
No Aptos 4
Introduzca el resultado (1 = apto, 2 = no apto): 1
Introduzca el resultado (1 = apto, 2 = no apto): 1
Introduzca el resultado (1 = apto, 2 = no apto): 1
Introduzca el resultado (1 = apto, 2 = no apto): 1
Introduzca el resultado (1 = apto, 2 = no apto): 2
Introduzca el resultado (1 = apto, 2 = no apto): 1
Introduzca el resultado (1 = apto, 2 = no apto): 1
Introduzca el resultado (1 = apto, 2 = no apto): 1
Introduzca el resultado (1 = apto, 2 = no apto): 1
Introduzca el resultado (1 = apto, 2 = no apto): 1
Aptos 9
No Aptos 1
Aumente matrícula
2003 Prentice Hall, Inc. All rights reserved.
39
2.11Operadores 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 formavariable = variable operador expresión;
pueden reescribirse comovariable operador= expresión;
• Otros operadores de asignaciónd -= 4 (d = d - 4)e *= 5 (e = e * 5)f /= 3 (f = f / 3)g %= 9 (g = g % 9)
2003 Prentice Hall, Inc. All rights reserved.
40
2.12Operadores 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)
2003 Prentice Hall, Inc. All rights reserved.
41
2.12 Operadores de Incremento y Decremento
• 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.
2003 Prentice Hall, Inc. All rights reserved.
42
2.12 Operadores de Incremento y Decremento
• 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++; cout << c;
2003 Prentice Hall, Inc.All rights reserved.
Outline43
1 // Fig. 2.14: fig02_14.cpp2 // Preincremento y postincremento.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 // la función main comienza la ejecución del programa9 int main()10 {11 int c; // declaración de la variable12 13 // demostración del postincremento14 c = 5; // asigna 5 a c15 cout << c << endl; // imprime 516 cout << c++ << endl; // imprime 5 y luego postincrementa17 cout << c << endl << endl; // imprime 6 18 19 // demostración del preincremento20 c = 5; // asigna 5 a c21 cout << c << endl; // imprime 522 cout << ++c << endl; // preincrementa y luego imprime 6 23 cout << c << endl; // imprime 6
2003 Prentice Hall, Inc.All rights reserved.
Outline44
24 25 return 0; // indica terminación correcta26 27 } // fin de función main
5
5
6
5
6
6
2003 Prentice Hall, Inc. All rights reserved.
45
2.12 Operadores de Incremento y Decremento
• Tabla de precedencia de operadoresOperadores Asociatividad Tipo
( ) Izquierda a derecha Paréntesis
++ -- static_cast<tipo>() Izquierda a derecha Unarios
++ -- Derecha a izquierda Unarios
* / % Izquierda a derecha Multiplicativos
+ - Izquierda a derecha Aditivos
<< >> Izquierda a derecha Inserción/extracción
< <= > >= Izquierda a derecha Relacional
== != Izquierda a derecha Igualdad
?: Derecha a izquierda Condicional
= += -= *= /= %= Derecha a izquierda Asignación
2003 Prentice Hall, Inc. All rights reserved.
46
2.13Fundamentos 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
2003 Prentice Hall, Inc.All rights reserved.
Outline47
1 // Fig. 2.16: fig02_16.cpp2 // Repetición controlada por contador.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 // la función main comienza la ejecución del programa9 int main()10 {11 int contador = 1; // inicialización12 13 while ( contador <= 10 ) { // condición de repetición14 cout << contador << endl; // muestra contador15 ++contador; // incremento16 17 } // fin de while 18 19 return 0; // indica terminación correcta20 21 } // fin de función main
Declaración
+
Inicialización
Al terminar el bucle, contador vale 11
2003 Prentice Hall, Inc.All rights reserved.
Outline48
1
2
3
4
5
6
7
8
9
10
2003 Prentice Hall, Inc. All rights reserved.
49
2.13 Fundamentos de la Repetición Controlada por Contador
• La declaraciónint 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 declaroint contador = 0;
puedo cambiar el bucle:while (++contador <= 10)
cout << contador << endl;
2003 Prentice Hall, Inc. All rights reserved.
50
2.14La Estructura de Repetición for
• Maneja todos los detalles de la repetición controlada por contador
• Formato general del lazo forfor ( inicialización; TestContinuaciónLazo;incremento )
sentencia
• Ejemplo: imprimir los enteros del 1 al 10
for(int contador = 1; contador <= 10; contador++)
No punto y coma después de la última sentencia
Palabra clave for
Nombre variable control
Separador obligatorio ;
Valor final de la variable de control para la que la
condición es cierta Separador obligatorio ;
Valor inicial de la variable de
controlCondición de
continuación del lazo
Incremento de la variable de
control
2003 Prentice Hall, Inc.All rights reserved.
Outline51
1 // Fig. 2.17: fig02_17.cpp2 // Repetición controlada por contador con la estructura for.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 // la función main comienza la ejecución del programa9 int main()10 {11 // Inicialización, condición de repetición e incremento 12 // se incluyen en el encabezado de la estructura for. 13 14 for ( int contador = 1; contador <= 10; contador++ )15 cout << contador << endl; 16 17 return 0; // indica la terminación correcta18 19 } // fin de la función main
2003 Prentice Hall, Inc.All rights reserved.
Outline52
1
2
3
4
5
6
7
8
9
10
2003 Prentice Hall, Inc. All rights reserved.
53
2.14 La Estructura de Repetición for
• Diagrama de actividad en UML del lazo for
2003 Prentice Hall, Inc. All rights reserved.
54
2.14 La Estructura de Repetición for
• Lazo for puede rescribirse como lazo whileinicializació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;
2003 Prentice Hall, Inc. All rights reserved.
55
2.14 La Estructura de Repetición for
• 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
2003 Prentice Hall, Inc. All rights reserved.
562.14 Ejemplos de uso de la Estructura for
a) Modificar variable control de 1 a 100 con incremento 1for (int i = 1; i <= 100; i++)
b) Modificar variable control de 100 a 1 con incremento -1for (int i = 100; i >= 1; i--)
c) Modificar variable control de 7 a 77 en pasos de 7for (int i = 7; i <= 77; i += 7)
d) Modificar variable control de 20 a 2 en pasos de -2for (int i = 20; i >= 2; i -= 2)
e) Modificar variable control sobre la secuencia: 2, 5, 8, 11, 14, 17, 20.for (int j = 2; j <= 20; j += 3)
f) Modificar la variable control sobre secuencia: 99, 88, 77, 66, 55, 44, 33, 22, 11, 0for (int j = 99; j >= 0; j -= 11)
2003 Prentice Hall, Inc.All rights reserved.
Outline57
1 // Fig. 2.20: fig02_20.cpp2 // Suma con for.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 // la función main comienza la ejecución del programa9 int main()10 {11 int suma = 0; // inicializa suma12 13 // suma enteros pares de 2 a 10014 for ( int numero = 2; numero <= 100; numero += 2 ) 15 suma += numero; // suma numero a suma16 17 cout << “La suma is " << suma << endl; // imprime suma18 return 0; // terminación correcta19 20 } // fin de la función main
La suma es 2550
2003 Prentice Hall, Inc. All rights reserved.
58
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, ya es la cantidad en depósito al final del año n.
n
2003 Prentice Hall, Inc.All rights reserved.
Outline59
1 // Fig. 2.21: fig02_21.cpp2 // Cálculo del interés compesto.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 using std::ios;8 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 pow16 17 // la función main comienza la ejecución del programa18 int main()19 {20 double cantidad; // cantidad depositada21 double capital = 1000.0; // capital inicial22 double interes = .05; // tasa de interés23
<cmath> fichero de cabecera necesario para la función pow (el programa no compilará sin él).
2003 Prentice Hall, Inc.All rights reserved.
Outline60
24 // Títulos de las columnas de la tabla de salida25 cout << "Año" << setw( 21 ) << "Cantidad depositada" << endl;26 27 // fijamos el formato de número en punto flotante28 cout << fixed << setprecision( 2 ); 29 30 // calculamos la cantidad en depósito para cada uno de los 10 años31 for ( int anho = 1; anho <= 10; anho++ ) {32 33 // calculamos la nueva cantidad para el año especificado34 cantidad = capital * pow( 1.0 + interes, anho );35 36 // salida de una fila de la tabla37 cout << setw( 4 ) << anho 38 << setw( 21 ) << cantidad << endl;39 40 } // fin de for 41 42 return 0; // indica finalización correcta43 44 } // fin de la función main
pow(x,y) = x elevado a y.
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.
2003 Prentice Hall, Inc.All rights reserved.
Outline61
Años Cantidad depositada
1 1050.00
2 1102.50
3 1157.63
4 1215.51
5 1276.28
6 1340.10
7 1407.10
8 1477.46
9 1551.33
10 1628.89
Los números están justificados a la derecha debido a las sentencias setw (en las líneas 4 y 21).
2003 Prentice Hall, Inc. All rights reserved.
62
2.16La Estructura switch de Selección Múltiple
• switch– Comprueba múltiples valores en el valor de una variable– Serie de etiquetas case y un caso opcional defaultswitch ( 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 sentencias break;
default: // se toma si variable no cumple ningún caso previo
sentencias break;
}
2003 Prentice Hall, Inc. All rights reserved.
632.16 La Estructura switch de Selección Múltiple
2003 Prentice Hall, Inc. All rights reserved.
64
2.16 La Estructura switch de Selección Múltiple
• 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;
ImprimeEl carácter (a) tiene el valor 97
2003 Prentice Hall, Inc.All rights reserved.
Outline65
1 // Fig. 2.22: fig02_22.cpp2 // Cuenta de calificaciones indicadas por letras.3 #include <iostream>4 5 using std::cout;6 using std::cin;7 using std::endl;8 9 // la función main comienza la ejecución del programa10 int main()11 {12 int grade; // una calificación13 int aCont = 0; // cantidad de As14 int bCont = 0; // cantidad de Bs15 int cCont = 0; // cantidad de Cs16 int dCont = 0; // cantidad de Ds17 int fCont = 0; // cantidad de Fs18 19 cout << "Introduzca las calificaciones indicadas con letras." << endl20 << "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)
2003 Prentice Hall, Inc.All rights reserved.
Outline66
22 // lazo hasta que el usuario escriba la secuencia fin-de-fichero23 while ( ( grade = cin.get() ) != EOF ) {24 25 // determina qué nota se introdujo26 switch ( grade ) { // switch anidado en while27 28 case 'A': // la nota es A29 case 'a': // o a30 ++aCont; // incrementa aCont31 break; // necesario para salir de switch32 33 case 'B': // la nota es B34 case 'b': // o b35 ++bCont; // incrementa bCont 36 break; // sale de switch37 38 case 'C': // la nota es C39 case 'c': // o c40 ++cCont; // incrementa cCont 41 break; // sale de switch42
Líneas 28-29: Compara grade (un int) con las representaciones numéricas de A y a.
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.
Líneas 30-31: No es necesario que vayan entre llaves
2003 Prentice Hall, Inc.All rights reserved.
Outline67
43 case 'D': // la nota es D44 case 'd': // o d45 ++dCont; // incrementa dCont 46 break; // sale de switch47 48 case 'F': // la nota es F49 case 'f': // o f50 ++fCont; // incrementa fCont 51 break; // sale de switch52 53 case '\n': // ignora cambios de línea, 54 case '\t': // tabuladores, 55 case ' ': // y espacios en la entrada56 break; // sale de switch57 58 default: // recoge los demás caracteres59 cout << "Letra de calificación incorrecta."60 << " Introduzca una nueva calificación." << endl;61 break; // opcional; en cualquier caso se saldrá de switch
62 63 } // fin de switch64 65 } // fin de while66
Daos cuenta de la sentencia default, que recoge todos los demás casos.
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.
2003 Prentice Hall, Inc.All rights reserved.
Outline68
67 // Salida del resumen de resultados68 cout << "\n\Los totales para cada calificación son:" 69 << "\nA: " << aCont // número de notas A70 << "\nB: " << bCont // número de notas B71 << "\nC: " << cCont // número de notas C72 << "\nD: " << dCont // número de notas D73 << "\nF: " << fCont // número de notas F74 << endl;75 76 return 0; // indica finalización correcta77 78 } // fin de función main
2003 Prentice Hall, Inc.All rights reserved.
Outline69
Introduzca las calificaciones indicadas con letras.
Teclee el carácter EOF para terminar la entrada de datos.
a
B
c
C
A
d
f
C
E
Letra de calificación incorrecta. Introduzca una nueva calificación.
D
A
b
^Z
Los totales para cada calificación son :
A: 3
B: 2
C: 3
D: 2
F: 1
2003 Prentice Hall, Inc. All rights reserved.
70
2.17La 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
• Formatodo { sentencias} while ( condición );
2003 Prentice Hall, Inc.All rights reserved.
Outline71
1 // Fig. 2.24: fig02_24.cpp2 // Uso de la estructura de repetición do/while.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 // la función main comienza la ejecución del programa9 int main()10 {11 int contador = 1; // inicializa contador12 13 do { 14 cout << contador << " "; // muestra contador15 } while ( ++contador <= 10 ); // fin de do/while 16 17 cout << endl;18 19 return 0; // indica finalización correcta20 21 } // fin de función main
1 2 3 4 5 6 7 8 9 10
Notad el preincremento en el test de continuación de lazo.
2003 Prentice Hall, Inc. All rights reserved.
72
2.18Las 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
2003 Prentice Hall, Inc.All rights reserved.
Outline73
1 // Fig. 2.26: fig02_26.cpp2 // Uso de la instrucción break en una estructura for.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 // la función main comienza la ejecución del programa9 int main()10 {11 12 int x; // x se declara aquí para poder usarla después del bucle13 14 // el bucle se repite 10 veces15 for ( x = 1; x <= 10; x++ ) {16 17 // si x es 5, finaliza el bucle18 if ( x == 5 )19 break; // rompe el bucle sólo si x es 520 21 cout << x << " "; // muestra el valor de x22 23 } // fin de for 24 25 cout << "\nSalida del ciclo con el valor de x en " << x << endl;
Sale de la estructura for cuando se ejecuta break.
2003 Prentice Hall, Inc.All rights reserved.
Outline74
26 27 return 0; // indica terminación correcta28 29 } // fin de función main
1 2 3 4
Salida del ciclo con el valor de x en 5
2003 Prentice Hall, Inc. All rights reserved.
75
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
2003 Prentice Hall, Inc.All rights reserved.
Outline76
1 // Fig. 2.27: fig02_27.cpp2 // Uso de la instrucción continue en una estructura for.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 // la función main comienza la ejecución del programa9 int main()10 {11 // lazo 10 veces12 for ( int x = 1; x <= 10; x++ ) {13 14 // si x es 5, continúa con la siguiente iteración15 if ( x == 5 )16 continue; // salta el resto del código de este ciclo17 18 cout << x << " "; // muestra el valor de x19 20 } // fin de la estructura for21 22 cout << "\nSe utiliza continue para no imprimir el valor 5" 23 << endl;24 25 return 0; // indica terminación correcta
Salta a la siguiente iteración del lazo.
2003 Prentice Hall, Inc.All rights reserved.
Outline77
26 27 } // fin de la función main
1 2 3 4 6 7 8 9 10
Se utiliza continue para no imprimir el valor 5
2003 Prentice Hall, Inc. All rights reserved.
78
2.19Operadores 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;
2003 Prentice Hall, Inc. All rights reserved.
79
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éntesisif ( !( 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
2003 Prentice Hall, Inc. All rights reserved.
80
2.19 Operadores Lógicos • Tabla de precedencia de operadores y asociatividad
Operadores Asociatividad Tipo
( ) Izquierda a derecha Paréntesis
++ -- static_cast<tipo>() Izquierda a derecha Unarios
++ -- ! Derecha a izquierda Unarios
* / % Izquierda a derecha Multiplicativos
+ - Izquierda a derecha Aditivos
<< >> Izquierda a derecha Inserción/extracción
< <= > >= Izquierda a derecha Relacional
== != Izquierda a derecha Igualdad
&& Izquierda a derecha Y lógico
|| Izquierda a derecha O lógico
?: Derecha a izquierda Condicional
= += -= *= /= %= Derecha a izquierda Asignación
, Izquierda a derecha Coma
2003 Prentice Hall, Inc. All rights reserved.
81
2.20Confusió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)
2003 Prentice Hall, Inc. All rights reserved.
82
2.20 Confusión de los Operadores de Igualdad (==) y Asignación (=)
• Ejemploif ( 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
2003 Prentice Hall, Inc. All rights reserved.
83
2.20 Confusión de los Operadores de Igualdad (==) y Asignación (=)
• 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
2003 Prentice Hall, Inc. All rights reserved.
842.21Resumen de la Programación Estructurada
• Programación estructurada– Programas más
fáciles de entender, probar, depurar y modificar
• Resumen de estructuras de control de C++– Apilamiento
– Anidamiento
2003 Prentice Hall, Inc. All rights reserved.
85
2.21Resumen de la Programación Estructurada
• Reglas de la programación estructurada– Sólo se usan estructuras de control de entrada única/salida
única
– Reglas1) 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
2003 Prentice Hall, Inc. All rights reserved.
862.21 Resumen de la Programación Estructurada
• 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
2003 Prentice Hall, Inc. All rights reserved.
872.21 Resumen de la Programación Estructurada
• Representación de la Regla 3 (Regla de Anidamiento): reemplazar cualquier rectángulo con una estructura de control
2003 Prentice Hall, Inc. All rights reserved.
88
2.21 Resumen de la Programación Estructurada
• 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