2003 Prentice Hall, Inc. All rights reserved. 1 Capítulo 2 – Estructuras de Control Índice del...

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


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


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


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


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


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


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


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


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


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.)


11


• Traducción a C++Si la nota del estudiante es mayor o igual que 60


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


12


• 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


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


sino

Imprime “Suspenso”

• Código C++if ( nota >= 60 ) cout << "Aprobado";else cout << "Suspenso";


14


• 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


15


• 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”


16


• 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";


17


• 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


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;


19

2.7 Estructura de Repetición while

• Diagrama de actividad UML del bucle while


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.


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


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









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.


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)



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



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



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



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?


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


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


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 : -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>


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


33


• 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


34


– La instrucciónIntroduce las 10 calificaciones y cuenta los aptos y no aptos


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


35


– La instrucciónImprime un resumen de resultados del examen y decide si debe

aumentar la matrícula


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++


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


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


Outline38

Introduzca el resultado (1 = apto, 2 = no apto): 1










Aptos 6

No Aptos 4











Aptos 9

No Aptos 1

Aumente matrícula


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)


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)


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.


42


• 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;


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


Outline44

24 25 return 0; // indica terminación correcta26 27 } // fin de función main

5

5

6

5

6

6


45


• 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


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


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


Outline48

1

2

3

4

5

6

7

8

9

10


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;


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


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


Outline52

1

2

3

4

5

6

7

8

9

10


53

2.14 La Estructura de Repetición for

• Diagrama de actividad en UML del lazo for


54


• 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;


55


• 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


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)


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


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


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).


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.


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).


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;

}


632.16 La Estructura switch de Selección Múltiple


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


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)


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


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.


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


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


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 );


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.


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


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.


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


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


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.


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


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;


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


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


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)


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


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


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


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


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



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


88


• 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

2003 Prentice Hall, Inc. All rights reserved. 1 Capítulo 2 – Estructuras de Control Índice del...

Documents

Transcript of 2003 Prentice Hall, Inc. All rights reserved. 1 Capítulo 2 – Estructuras de Control Índice del...