C++ Volumen I: Fundamentos
por Carlos Eduardo G´ omez Montoya Juli´ an Esteban Guti´ errez Posada
ii
C++ Volumen I: Fundamentos No est´a permitida la reproducci´on total o parcial de esta obra, ni su tratamiento o transmisi´on por cualquier m´etodo sin autorizaci´on escrita del editor. Car´atula: Luis Eduardo Sep´ ulveda Rodr´ıguez Derechos reservados c Noviembre 2001 ° ISBN: 958 - 33 - 2665 - 8 Este libro fue editado usando LATEX 2ε Impresi´on: POL Editores Calle 32 # 27-56 Armenia, Q. Tel´efono: (6) 740 22 21 Nit: 7.538.895 - 0 E-Mail: pol@telesat.com.co Editor: Carlos Eduardo G´omez Montoya Apartado A´ereo: 632 Armenia Tel´efono Celular: 459 18 97 E-Mail: charlie@quimbaya.uniquindio.edu.co Armenia, Quind´ıo - Colombia
´Indice general 1. Introducci´ on
1
1.1. Algoritmos de la vida diaria . . . . . . . . . . . . . . . . . . . Ama de casa.
1
. . . . . . . . . . . . . . . . . . . . . .
2
. . . . . . . . . . . . . . . . . .
3
. . . . . . . . . . . . . . . . .
3
. . . . . . . . . . . . . . . . . . .
4
1.2. Agrupaci´on de actividades . . . . . . . . . . . . . . . . . . . .
5
1.3. Decisiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
1.4. Repeticiones . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
Empleado de oficina. Profesor Universitario. Cajero autom´atico.
2. Conceptos b´ asicos
7
2.1. Historia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
2.2. Identificadores . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
2.2.1. Identificadores v´alidos . . . . . . . . . . . . . . . . . .
8
2.2.2. Identificadores no v´alidos . . . . . . . . . . . . . . . . .
9
2.3. Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . .
9
2.3.1. Char . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.3.2. N´ umeros enteros . . . . . . . . . . . . . . . . . . . . . 11 2.3.3. N´ umeros de punto flotante . . . . . . . . . . . . . . . . 12 2.4. Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 iii
´INDICE GENERAL
iv
2.5. Funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 2.6. Expresiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 2.6.1. Expresiones aritm´eticas . . . . . . . . . . . . . . . . . . 16 2.6.2. Expresiones l´ogicas . . . . . . . . . . . . . . . . . . . . 16 2.6.3. Expresiones de asignaci´on . . . . . . . . . . . . . . . . 18 2.7. Otros operadores . . . . . . . . . . . . . . . . . . . . . . . . . 18 Prueba de escritorio 1.
. . . . . . . . . . . . . . . . . 20
2.8. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 Prueba de escritorio 2.
. . . . . . . . . . . . . . . . . 26
Prueba de escritorio 3.
. . . . . . . . . . . . . . . . . 26
3. Estructura secuencial
27
3.1. Compilar y ejecutar un programa . . . . . . . . . . . . . . . . 27 3.2. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 28 1: Suma de dos enteros.
. . . . . . . . . . . . . . . . . 29
2: Calcular el ´area de un c´ırculo.
. . . . . . . . . . . . 31
3: Conversi´on de temperaturas.
. . . . . . . . . . . . 32
4: Conversi´on de ´angulos. ´ 5: Area de un tri´angulo.
. . . . . . . . . . . . . . . . 34 . . . . . . . . . . . . . . . . 35
3.3. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 36 4. Funciones
39
4.1. Estructura de una funci´on . . . . . . . . . . . . . . . . . . . . 39 Estructura de una funci´on. Funci´on que suma dos enteros. Funci´on que llama a otra.
. . . . . . . . . . . . . . . 40 . . . . . . . . . . . . . 40 . . . . . . . . . . . . . . . 40
4.2. Recomendaciones y generalidades . . . . . . . . . . . . . . . . 41 4.3. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 42 6: Suma de dos enteros.
. . . . . . . . . . . . . . . . . 43
´INDICE GENERAL
v
7: Calcular el ´area de un c´ırculo.
. . . . . . . . . . . . 46
8: Conversi´on de temperaturas.
. . . . . . . . . . . . 48
9: Conversi´on de ´angulos.
. . . . . . . . . . . . . . . . 50
´ 10: Area de un tri´angulo.
. . . . . . . . . . . . . . . . 52
4.4. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 53 5. Decisiones simples
55
Estructura general del if - 1.
. . . . . . . . . . . . . . 56
Estructura general del if - 2.
. . . . . . . . . . . . . . 56
5.1. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 57 11: Divisi´on por cero.
. . . . . . . . . . . . . . . . . . 58
12: An´alisis del presupuesto mensual.
. . . . . . . . . 59
13: Verificaci´on del rango de un entero corto. 14: Pago de horas extras a un trabajador. 15: Rendimiento de un CDT.
. . . . . 61 . . . . . . . 64
. . . . . . . . . . . . . . 66
5.2. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 69 6. Decisiones anidadas
73
6.1. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 74 16: Comisi´on a pagar a un vendedor.
. . . . . . . . . 75
17: Valor de la matr´ıcula por categor´ıas. 18: Encontrar el mayor de tres enteros.
. . . . . . . 79 . . . . . . . . 81
19: Aviso para cambio de aceite.
. . . . . . . . . . . . 84
20: Clasificaci´on de tres enteros.
. . . . . . . . . . . . 86
6.2. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 89
´INDICE GENERAL
vi 7. Decisiones m´ ultiples
95
Estructura general del switch.
. . . . . . . . . . . . . 96
7.1. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 97 21: C´alculos de Geometr´ıa Anal´ıtica.
. . . . . . . . . 97
22: Valor de la cuota fija de un pr´estamo. 23: Identificaci´on de caracteres.
. . . . . . . 102
. . . . . . . . . . . . 105
24: Resultado de la operaci´on de dos n´ umeros. 25: C´alculo del valor de la pensi´on.
. . . . 108
. . . . . . . . . . 111
7.2. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 115 8. Ciclo do - while
123
Lista secuencial de 1000 enteros.
. . . . . . . . . . . . 124
Estructura general del ciclo do - while.
. . . . . . . . 124
8.1. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 125 26: Lista de mil enteros positivos.
. . . . . . . . . . . 126
27: Impresi´on de un rango de n´ umeros.
. . . . . . . . 127
28: Impresi´on de un rango de n´ umeros con validaci´on.
128
29: Tabla de multiplicar de un valor ingresado.
. . . . 130
30: Multiplicaci´on a partir de sumas sucesivas.
. . . . 132
8.2. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 133 9. Ciclo while
137
Estructura general del while.
. . . . . . . . . . . . . . 137
9.1. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 138 31: Encontrar el mayor.
. . . . . . . . . . . . . . . . . 138
32: N´ umero de pares e impares. 33: Estad´ıstica sobre notas. 34: M´aximo Com´ un Divisor. Figura de longitud 6.
. . . . . . . . . . . . 139 . . . . . . . . . . . . . . . 142 . . . . . . . . . . . . . . 144
. . . . . . . . . . . . . . . . . . 147
´INDICE GENERAL 35: Figura.
vii . . . . . . . . . . . . . . . . . . . . . . . . 147
9.2. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 149 10.Ciclo for
153
Estructura general del for.
. . . . . . . . . . . . . . . 153
10.1. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 155 36: Divisi´on a partir de restas.
. . . . . . . . . . . . . 155
37: M´ınimo Com´ un M´ ultiplo.
. . . . . . . . . . . . . 157
38: Tabla trigonom´etrica.
. . . . . . . . . . . . . . . . 159
Salida de n´ umero de punto flotante con formato. 39: Plan de amortizaci´on.
. . . . . . . . . . . . . . . . 162
Figuras de 1 y 4 flechas, de longitud 5. 40: Figura.
. . . 161
. . . . . . . . 166
. . . . . . . . . . . . . . . . . . . . . . . . 167
10.2. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 170 11.Arreglos unidimensionales
173
Elementos de un arreglo.
. . . . . . . . . . . . . . . . 174
Acceso directo a las posiciones de un arreglo.
. . . . . 175
Acceso indirecto a las posiciones de un arreglo.
. . . . 175
Acceso a un arreglo usando ciclos do - while y for.
. . 176
11.1. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 176 41: Sumar los elementos de un arreglo. 42: Orden inverso.
. . . . . . . . . . . . . . . . . . . . 179
43: Dividir en pares e impares. 44: Eliminar un dato. 45: Insertar y desplazar.
. . . . . . . . 176
. . . . . . . . . . . . . 184
. . . . . . . . . . . . . . . . . . 187 . . . . . . . . . . . . . . . . 190
11.2. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 193
´INDICE GENERAL
viii 12.Matrices
197
Acceso directo a las posiciones de una matriz.
. . . . 199
Acceso indirecto a las posiciones de una matriz. Acceso a un arreglo usando el ciclo for.
. . . 199
. . . . . . . . 200
12.1. Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . 201 46: Inicializar la Matriz Identidad.
. . . . . . . . . . . 201
47: Suma de los elementos de la diagonal.
. . . . . . . 204
48: Imprimir la transpuesta de una matriz. 49: Intercambiar dos filas.
. . . . . . 210
. . . . . . . . . . . . . . . 212
50: Cuadrados m´agicos de orden impar.
. . . . . . . . 215
12.2. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . 219 13.Para el Volumen II
221
13.1. Manejo de Excepciones . . . . . . . . . . . . . . . . . . . . . . 221 51: Excepciones 1.
. . . . . . . . . . . . . . . . . . . . 222
52: Excepciones 2.
. . . . . . . . . . . . . . . . . . . . 224
53: Excepciones 3.
. . . . . . . . . . . . . . . . . . . . 226
13.2. Cadenas de caracteres . . . . . . . . . . . . . . . . . . . . . . 228 54: Cadenas 1.
. . . . . . . . . . . . . . . . . . . . . . 229
55: Cadenas 2.
. . . . . . . . . . . . . . . . . . . . . . 231
56: Cadenas 3.
. . . . . . . . . . . . . . . . . . . . . . 232
13.3. Argumentos del m´etodo main . . . . . . . . . . . . . . . . . . 233 57: Argumentos 1.
. . . . . . . . . . . . . . . . . . . . 234
Resultado Argumentos 1. 58: Argumentos 2.
. . . . . . . . . . . . . . . . 235 . . . . . . . . . . . . . . . . . . . . 235
13.4. Archivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236 59: Archivos de acceso secuencial.
. . . . . . . . . . . 238
Excepcion por falla en el archivo de salida. Excepcion por falla en el archivo de entrada. 60: Archivos de acceso directo.
. . . . . . 240 . . . . . 241
. . . . . . . . . . . . . 242
´INDICE GENERAL
.
Bibliograf´ıa
ix
247
x
´INDICE GENERAL
Cap´ıtulo 1 Introducci´ on Antes de entrar en detalles con respecto a los conceptos fundamentales de los lenguajes de programaci´on, es importante tener claridad sobre el contexto en el que se pueden apoyar. Un lenguaje de programaci´on es una definici´on formal de instrucciones que a primera vista parecen de una complejidad muy alta. Con dichas instrucciones es posible resolver problemas planteados de forma algor´ıtmica. Un algoritmo es un conjunto de instrucciones que permiten resolver un problema determinado. Se caracteriza por tener un n´ umero finito de instrucciones y no dar lugar a ning´ un tipo de ambig¨ uedad. Muchas veces, en la vida diaria estamos en contacto con situaciones que se pueden comportar de forma similar a las que usualmente se resuelven utilizando este tipo de lenguajes. Una receta de cocina donde no se especifican tiempos y cantidades exactas, no se considera un algoritmo. Pero los pasos que aprendimos en la escuela para calcular la suma, resta, multiplicaci´on o divisi´on s´ı se pueden llamar algoritmos.
1.1.
Algoritmos de la vida diaria
Generalmente las personas tenemos la costumbre de “programar”las diferentes actividades del d´ıa, a pesar de que la mayor´ıa no lo hace de forma 1
´ CAP´ITULO 1. INTRODUCCION
2
consciente. Es decir, algunas personas usan una agenda para registrar sus compromisos m´as importantes y otras solo conf´ıan en su memoria. Unas personas prefieren programar sus actividades a corto plazo (el d´ıa o parte de ´el, el d´ıa siguiente o la semana), mediano plazo (la quincena o el mes) y largo plazo. Ejemplos: 1. Ama de casa Un ama de casa, a grandes rasgos, divide su tiempo de tal manera que le alcance para: Ver “Ama de casa”. Ama de casa Servir el desayuno Organizar la casa Preparar el almuerzo Servir la cena
No se especifican detalles por ejemplo a qu´e hora realiza cada actividad, ni otros pormenores como por ejemplo su aseo personal o si descansa leyendo u observando la televisi´on. 2. Empleado de oficina Un empleado de una empresa cualquiera, a diferencia del ejemplo anterior puede tener ciertas diferencias de acuerdo al cargo que desempe˜ na. Podr´ıa organizar su d´ıa m´as o menos as´ı: Ver “Empleado de oficina”. En este caso, no se puede detallar el conjunto de actividades espec´ıficas de su trabajo o si almuerza en la oficina, cerca de ella o en su casa. De igual manera quedan muchas actividades complementarias que no son mencionadas.
1.1. ALGORITMOS DE LA VIDA DIARIA
3
Empleado de oficina Organizacion personal Desayunar Desplazarse al lugar de trabajo Realizar las actividades propias de su trabajo Desplazarse a su casa Cenar
3. Profesor universitario El caso de un profesor en la universidad es diferente a los anteriores. La siguiente puede ser la distribuci´on de su tiempo en horas de la ma˜ nana. Ver “Profesor Universitario”. Profesor Universitario 5:45 6:15 6:30 7:00 9:00 10:00 12:00
a.m. a.m. a.m. a.m. a.m. a.m. a.m.
Organizacion personal Desayunar Desplazarse a la universidad Clase de Calculo I Asesoria a Estudiantes Clase de Geometria Analitica Desplazarse a su casa
Se puede observar que podr´ıa ser un caso particular del ejemplo 2, por tratarse de una persona que va a su trabajo. En este ejemplo, es importante el d´ıa y la hora, porque no todos los d´ıas ni en los mismos horarios atiende las mismas asignaturas o asesor´ıas.
´ CAP´ITULO 1. INTRODUCCION
4 4. Retiro por cajero autom´atico
Una persona necesita seguir ciertos pasos para retirar su dinero del cajero autom´atico. Ver “Cajero autom´atico”. Cajero autom´ atico Introducir la tarjeta Retirar la tarjeta Digitar la clave SI la clave no es valida, ENTONCES Termina la transaccion SINO Leer un menu con las opciones Elegir Retiro en efectivo Elegir o digitar la cantidad SI la cantidad es <= al saldo disponible Y la cantidad es <= al monto maximo permitido Y el cajero dispone de esa cantidad ENTONCES Recoger el dinero Recoger el recibo SINO Termina la transaccion
Es natural hoy en d´ıa ir a un cajero electr´onico con el prop´osito de retirar dinero en efectivo. El cajero tiene un monto m´aximo permitido de entrega, al igual que el cliente tiene un saldo sobre el cual puede hacer el retiro. En casos extremos hay que contar con que el dinero que tiene almacenado el cajero puede escasear. No todas las personas hacen exactamente lo mismo aunque tengan afinidad en su actividad principal, ni establecen lo que deben hacer de la misma manera o con el mismo grado de detalle.
´ DE ACTIVIDADES 1.2. AGRUPACION
1.2.
5
Agrupaci´ on de actividades
Tal como est´an escritos los tres ejemplos anteriores, se puede apreciar que el d´ıa est´a dividido en actividades que a su vez pueden dividirse en pasos m´as detallados. Por ejemplo, preparar el almuerzo en el ejemplo 1, se puede realizar paso a paso siguiendo una receta de cocina particular. Desplazarse a su lugar de trabajo en los ejemplos 2 y 3, puede ser la suma de diferentes actividades parciales como salir de la casa, ir al paradero de bus, esperar la ruta correspondiente, montarse al bus, esperar el recorrido, bajarse en el paradero adecuado y caminar a la oficina.
1.3.
Decisiones
Los ejemplos mencionados corresponden a programaci´on secuencial. Es decir, funcionan perfectamente mientras no se presenten eventualidades, como por ejemplo amanecer enfermo y tener urgencia de ir al m´edico. Por m´as programado que se tenga el d´ıa, esa eventualidad obliga a tomar decisiones que afectar´an el normal desarrollo de las actividades siguientes. Por ejemplo, si el desplazamiento a la oficina se realiza en bus, pero se est´a haciendo tarde, es muy probable que el empleado tome la decisi´on de irse en taxi. El ama de casa puede tener planeado hacer de almuerzo cierto plato, pero justo en el momento en que va a iniciar su preparaci´on se entera de que algunos ingredientes hacen falta. En ese momento debe tomar una decisi´on antes de que sea tarde. Su decisi´on ser´a ir a comprar lo que hace falta o cambiar el men´ u que va a ofrecer, de tal manera que pueda prepararse con los ingredientes que hayan en el momento. En el caso del retiro de dinero en un cajero autom´atico, es importante considerar decisiones porque el cajero debe verificar la identidad del cliente mediante la tarjeta e intentar comprobar si se trata efectivamente del due˜ no de la tarjeta, solicitando la clave. Adem´as, existen posibles solicitudes que no pueden ser realizadas debido a condiciones que se deben cumplir para efectuar el retiro. Finalmente se puede decir que para la entrega del recibo
´ CAP´ITULO 1. INTRODUCCION
6
es indispensable que el cajero tenga suministro de papel. Esta condici´on no fue considerada.
1.4.
Repeticiones
Es importante tener en cuenta que en la mayor´ıa de los casos, las personas deben seguir una rutina de lunes a viernes, y el fin de semana lo utilizan para disfrutar con su familia el tiempo libre. Todas las semanas tienen m´as o menos el mismo comportamiento. El caso del profesor universitario, todas las semanas tiene las mismas clases los d´ıas lunes, otras los martes, y as´ı ocurre con los dem´as d´ıas de la semana. Para el empleado de oficina, si debe subir escaleras para llegar a su oficina, lo har´a hasta que se terminen las escaleras que debe subir. El ama de casa si debe quitar la c´ascara de las papas para preparar el almuerzo, con seguridad que lo har´a mientras no haya terminado de pelar las que haya escogido. En conclusi´on, podemos esperar que algunas actividades se repitan, pero con diferente frecuencia lo que quiere decir que dentro de una actividad puede estar incluida una cantidad de veces que se debe realizar otra.
Cap´ıtulo 2 Conceptos b´ asicos 2.1.
Historia
El Lengueje C++ evolucion´o a partir de Lenguaje C, el cual evolucion´o a partir de dos lenguajes previos, el BCPL, desarrollado por Martin Richards desarroll´o en 1967 y Lenguaje B, desarrollado por Ken Thompson, en 1970. Tanto BCPL como Lenguaje B eran lenguajes sin tipos (no tipados). Dennis Ritchie de Laboratorios Bell llev´o a cabo la evoluci´on de Lenguaje C a partir de Lenguaje B y lo implement´o originalmente en una computadora DEC PDP-11 en 1972. C utiliza muchos concpetos importantes de BCPL y B al tiempo que a˜ nade tipos de datos y otras caracter´ısticas. En un principio C se hizo famoso como el lenguaje de desarrollo del sistema operativo Unix. Hoy en d´ıa, pr´acticamente todos los sistemas operativos importantes se escriben en C y/o C++. Durante las u ´ltimas dos d´ecadas se han producido compiladores de C para casi todas las clases de computadoras. C es independiente del hardware, es decir, el c´odigo fuente de C es altamente portable, lo que significa que se puede compilar casi en cualquier computadora. No obstante, a medida que pas´o el tiempo fueron apareciendo diferentes versiones de este lenguaje con variaciones que las hizo ligeramente incompatibles, en contradicci´on con una de las m´as importantes caracter´ısticas de Lenguaje C, como es la portabilidad.
7
´ CAP´ITULO 2. CONCEPTOS BASICOS
8
Por esta raz´on, en 1989 fue aprobado el est´andar, el cual fue publicado en 1990, bajo el nombre oficial ANSI1 / ISO2 9899: 1990. Este est´andar se conoce mundialmente como ANSI C. C++ fue desarrollada por Bjarne Stroustrup a principios de la d´ecada de 1980 en los laboratorios Bell. C++ ofrece varias caracter´ısticas nuevas al C donde la m´as destacada es la programaci´on orientada a objetos. Los objetos son en esencia, componentes de software reutilizables que modelan cosas del mundo real. Los creadores de software est´an descubriendo que el empleo de un dise˜ no y un enfoque de implementaci´on modular orientado a objetos puede hacer a los grupos de desarrollo de software mucho m´as productivos que lo que era posible con las t´ecnicas de programaci´on tradicionales. Los programas orientados a objetos son m´as f´aciles de escribir, comprender, corregir y modificar. C++ es un lenguaje h´ıbrido, es decir, es posible programar al estilo C, al estilo C++ o una mezcla de ambos.
2.2.
Identificadores
Un identificador en C++ es una unidad significativa de un programa que puede representar variablesconstantes, tipos de datos, y funciones, entre otros. No olvide que el nombre que le asigne a un identificador debe ayudar a relacionarlo con su contenido. Adem´as, debe ser pr´actico en su utilizaci´on, porque nombres muy largos pueden complicar la escritura del c´odigo. Muy cortos pueden confundir al usuario. Un identificador debe comenzar por una letra, puede incluir n´ umeros, el subrayado y no puede incluir espacios en blanco ni caracteres especiales. C++ es sensible a las may´ usculas, por lo tanto, es distinto escribir AREA, area y Area.
2.2.1.
Identificadores v´ alidos
Los siguientes son algunos ejemplos de identificadores v´alidos en C++. 1 2
American National Standard Institute International Standards Organization
2.3. TIPOS DE DATOS
9
area, suma, producto, promedio, sueldo, nota1, nota2, nota3, nota_final
2.2.2.
Identificadores no v´ alidos
Algunos identificadores no v´alidos en C++ pueden ser: primera nota y nota 2, por la aparici´on del espacio en blanco; 1_pago y %final por no comenzar con letra. Tampoco se pueden utilizar como identificadores palabras reservadas de Lenguaje C++ que aparecen en la tabla 2.1. 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
Cuadro 2.1: Palabras reservadas
2.3.
Tipos de datos
La tabla 2.2 contiene los tipos de datos primitivos en C++.
´ CAP´ITULO 2. CONCEPTOS BASICOS
10
Tipo de dato
Tama˜ no en bits
Rango
char
8
-128 a +127
unsigned char
8
0 a +255
int
16
-32768 a +32767
unsigned int
16
0 a +65535
long
32
-2.147.483.648 a 2.147.483.647
32
0 a 4.294.967.295
32
3.4E-38 a 3.4E+38
64
1.7E-308 a 1.7E+308
80
3.4E-4932 a 1.1E+4932
unsigned long float double long double
Cuadro 2.2: Tipos de Datos
2.3. TIPOS DE DATOS
2.3.1.
11
Char
El tipo de datos char es utilizado para representar un car´acter encerrado entre comitas simples, como por ejemplo ’a’, ’G’, ’8’, etc. El valor de un dato de tipo char corresponde al equivalente en el conjunto de caracteres ASCII3 , compuesta por 256 caracteres. Existen unos caracteres especiales, com´ unmente llamados secuencias de escape, los cuales ser´an usados m´as adelante. Ver tabla 2.3. Secuencia de escape
Descripci´ on
\n
Salto al comienzo de la siguiente l´ınea
\t
Salto al siguiente tope de tabulaci´on
\r
Salto al comienzo de la l´ınea actual
\\
Sirve para imprimir el caracter \
\’
Sirve para imprimir el caracter ’
\"
Sirve para imprimir el caracter " Cuadro 2.3: Secuencias de escape
2.3.2.
N´ umeros enteros
Los n´ umeros enteros se dividen en los siguientes tipos de datos, de acuerdo a su longitud en bits, lo cual determina su rango de operaci´on. Los tipos de datos primitivos son: int, undigned int, long y unsigned long. 3
American Standard Code for Information Interchange
´ CAP´ITULO 2. CONCEPTOS BASICOS
12
2.3.3.
N´ umeros de punto flotante
C++ tiene los datos correspondientes a los n´ umeros reales de precisi´on sencilla (float) y doble precisi´on (double). Es decir, representan aquellos n´ umeros que poseen punto decimal. Pueden ser reales decimales, como por ejemplo 120.5, 253482.6, 0.687, o reales exponenciales, los cuales se expresan en potencias de 10. Tambi´en se conocen como n´ umeros expresados en notaci´on cient´ıfica. Por ejemplo: -3.5E3 equivale a -3500.0 4.5E-4 es 0.00045 Los datos demasiado grandes, pierden precisi´on al ser escritos en notaci´on cient´ıfica, debido a las aproximaciones.
2.4.
Operadores
Un operador es un s´ımbolo utilizado para la manipulaci´on de datos. Se clasifican en: Aritm´ eticos: Utilizados para representar operaciones matem´aticas como suma (+), resta o diferencia (-), multiplicaci´on o producto (*), divisi´on (/), m´odulo o residuo de la divisi´on (%). Relacionales: Los operadores relacionales se utilizan para la comparaci´on de datos, mayor que (>), menor que (<), mayor o igual que (>=), menor o igual que (<=), igual que (==) o diferente de (!=). El resultado de una comparaci´on es un valor l´ogico (Verdadero o Falso). L´ ogicos: Son utilizados para agrupar dos o m´as comparaciones o para invertir o negar un valor l´ogico. Estos operadores son: conjunci´on (&&), disyunci´on (||) y negaci´on (!). La conjunci´on es normalmente llamada (Y). Dos o m´as comparaciones agrupadas con (&&) dar´an como resultado Verdadero siempre y cuando todas las comparaciones sean Verdaderas. En otro caso el resultado ser´a Falso.
2.4. OPERADORES
13
De forma similar, la disyunci´on es llamada (O). Si se tienen varias comparaciones agrupadas con el operador (||), el resultado ser´a Falso, s´ı y solo si todas las comparaciones son Falsas. En otro caso, el resultado ser´a Verdadero. De asignaci´ on: Es el operador utilizado para llevar datos a la memoria, a trav´es de identificadores. El operador de asignaci´on es (=). De signo: Es el operador utilizado para darle sentido positivo (+) o negativo (-) a un n´ umero. De agrupaci´ on: Son los s´ımbolos que se utilizan para modificar el orden en que se deben utilizar los diferentes operadores. Este orden se conoce como jerarqu´ıa, precedencia o prioridad de operadores. El operador de agrupaci´on es ( ). Ver tabla 2.4. ( ) + - (signo) * / % + < > <= >= == != ! && || = Cuadro 2.4: Jerarqu´ıa, precedencia o prioridad de operadores
La uni´on de constantes y variables con operadores forman expresiones. Para evitar confusiones tenga en cuenta:
´ CAP´ITULO 2. CONCEPTOS BASICOS
14
Si entre dos o m´as operadores la prioridad es equivalente, se resuelve el que aparezca primero de izquierda a derecha. Esto incluye los par´entesis. De haber par´entesis anidados, se resuelven primero los m´as internos.
Ejemplo: ( 2 * ( 3 + 4 ) * 8 ) * 5 + 2 * ( 8 + 4 + ( 3 * 2 ) + 1 ) Realice los siguientes pasos para determinar el resultado. Observe que hay dos par´entesis principales. Primero se debe resolver el que est´a m´as a la izquierda, es decir, ( 2 * ( 3 + 4 ) * 8 ). Internamente, hay un producto, una suma entre par´entesis y otro producto. Debe resolverse entonces el par´entesis ( 3 + 4 ) cuyo resultado es 7. ( 2 * ( 3 + 4 ) * 8 ) * 5 + 2 * ( 8 + 4 + ( 3 * 2 ) + 1 ) ( 2 * 7 * 8 ) * 5 + 2 * ( 8 + 4 + ( 3 * 2 ) + 1 ) Dentro del primer par´entesis se encuentran dos multiplicaciones. Primero se resuelve 2 * 7, quedando as´ı: ( 14 * 8 ) * 5 + 2 * ( 8 + 4 + ( 3 * 2 ) + 1 ) Ahora, se multiplica 14 * 8 112 * 5 + 2 * ( 8 + 4 + ( 3 * 2 ) + 1 ) A continuaci´on escogemos el par´entesis que estaba pendiente y dentro de ´el la multiplicaci´on de 3 * 2. 112 * 5 + 2 * ( 8 + 4 + 6 + 1 ) El proceso de soluci´on de las sumas es en orden de aparici´on, de izquierda a derecha.
2.5. FUNCIONES
15 112 * 5 + 2 * ( 12 + 6 + 1 ) 112 * 5 + 2 * ( 18 + 1 ) 112 * 5 + 2 * 19
En este momento han desaparecido los par´entesis. Ahora, seguimos con las multiplicaciones y luego la suma. 560 + 2 * 19 560 + 38 598 En la figura 2.1 se puede apreciar la transformaci´on desde la expresi´on inicial hasta el resultado.
Figura 2.1: Prioridad en los operadores aritm´eticos
2.5.
Funciones
El nombre formal que recibe la agrupaci´on de instrucciones es Funci´on. Los lenguajes de programaci´on tienen funciones predefinidas, muchas de las cuales conducen a resultados de operaciones matem´aticas. Ver tabla 2.5.
´ CAP´ITULO 2. CONCEPTOS BASICOS
16
Funci´on predefinida en C++ sin ( X ) cos ( X ) sqrt( X ) pow ( X, Y ) exp ( X )
Funci´on matem´atica Seno de X, para X en radianes Seno de X, para X en radianes Ra´ız cuadrada de X Potencia de X Y eX , e = 2.718281 ...
Cuadro 2.5: Funciones matem´aticas m´as comunes en C++
Se debe tener en cuenta que las funciones matem´aticas mencionadas son algunas de las que C++ tiene disponibles en un archivo especial que presta soporte matem´atico al lenguaje, llamado math.h el cual ser´a utilizado m´as adelante.
2.6.
Expresiones
Una expresi´on es una combinaci´on de n´ umeros, variables, constantes, funciones y operadores. Debe tenerse en cuenta que no se pueden combinar de cualquier manera, es decir, se deben agrupar de forma coherente.
2.6.1.
Expresiones aritm´ eticas
Son operaciones donde intervienen los operadores aritm´eticos. Analice cuidadosamente la forma como se agrupan ciertos elementos utilizando par´entesis de tal manera que no se presente ninguna ambig¨ uedad. Ver tabla 2.6. Observe que si en el numerador va un signo de suma o resta, debe ir entre par´entesis. En el caso del denominador, el par´entesis debe ir si existe cualquier operador. Si hay dudas, es mejor escribir los par´entesis.
2.6.2.
Expresiones l´ ogicas
La expresiones l´ogicas son las que conducen a un resultado de Falso o Verdadero. Cuando una expresi´on es una sola comparaci´on, se llama expresi´on
2.6. EXPRESIONES
17
Algebra
C++
3 5
3/5
3+4 5
(3 + 4)/5
3+4 5−2
(3 + 4)/(5 − 2)
3∗4 5∗8
3 ∗ 4/(5 ∗ 8)
3 2+6 4
3/((2 + 6)/4)
Cuadro 2.6: Conversi´on de expresiones algebr´aicas
Nota < 3.0 3 * a + 5 * b / c == 0 X1 != X2 A + B >= C + D 2 * D != Z Cuadro 2.7: Expresiones l´ogicas simples
´ CAP´ITULO 2. CONCEPTOS BASICOS
18
l´ogica simple. Esta expresi´on puede tener en uno o los dos extremos una expresi´on aritm´etica. Ver tabla 2.7. Las expresiones que resultan de unir expresiones l´ogicas simples con operadores l´ogicos dan lugar a las operaciones l´ogicas m´ ultiples. Ver tabla 2.8. a > b && X != 0 Horas >= 40 || Sueldo < 500000 (X == 1) || ( X == -1 ) && ( Min < 1 ) Ret <= Saldo && Ret <= Monto_Max && Ret <= Caja Cuadro 2.8: Expresiones l´ogicas m´ ultiples
2.6.3.
Expresiones de asignaci´ on
Generalmente son valores constantes o el resultado de una expresi´on aritm´etica la cual es asignada a una variable o el valor inicial de una constante. Pueden existir conflictos entre tipos de datos, por lo que se recomienda especial atenci´on al momento de usarlos para evitar interpretaciones equivocadas. Sucede lo mismo con los rangos que maneja cada tipo de dato en particular. Ver tabla 2.9.
2.7.
Otros operadores
En C++ se utilizan operadores que tienen influencia sobre un solo operando. Este tipo de operadores se conoce con el nombre de operadores monarios o unarios. Ver la tabla 2.10 Ver Prueba de escritorio 1.
2.7. OTROS OPERADORES
19
a = 5 Definitiva = ( Nota1 + Nota2 + Nota3 ) / 3.0 I = I + 1 Suma = Suma + X Promedio = Suma / N Peso = Peso * 0.03 Cuadro 2.9: Expresiones de asignaci´on
Operador
Ejemplo
Significado
++
I++, ++I
I = I + 1
--
I--, --I
I = I - 1
+=
X += 3
X = X + 3
-=
X -= 2
X = X - 2
*=
X *= 7
X = X * 7
/=
X /= 2
X = X / 2
Cuadro 2.10: Otros operadores en C++
´ CAP´ITULO 2. CONCEPTOS BASICOS Prueba de escritorio 1
20
a = 2; b = 3; b += a; c = a++; ++b; b *= 2; c--; c = ++a;
An´ alisis En la tabla 2.11 se analiza la prueba de escritorio 1. Instrucciones a = 2; b = 3;
a
b
2
3
b += a; c = a++;
5 3
++b;
2 6
b *= 2;
12
c--; c = ++a;
c
1 4
4
Cuadro 2.11: An´alisis Prueba de Escritorio 1 Observe detalladamente la diferencia entre ++a y a++. El primero se conoce como preincremento. El segundo se llama posincremento. En el caso del preincremento, primero se realiza el incremento y luego se usa la variable con su nuevo valor. En el caso del posincremento, primero se usa la variable con el valor actual y luego se incrementa. Sucede lo mismo con el predecremento.
2.8. EJERCICIOS
2.8.
21
Ejercicios
1. Indique cu´ales de los siguientes valores son de tipo int, float, char o ninguno. Complete la tabla 2.12. Valor
Tipo de dato
Valor
’A’
48
23.58
7
-8.43
TRES
5
31
2.1
’e’
’TRES’
19
5.25
’y’
-6
A
’17.98’
’perro’
-8
215
’C’
2001
-1230
0.00
962
-12.0356
’Eusebio’
2000.0
Tipo de dato
Cuadro 2.12: Ejercicios sobre tipos de datos
´ CAP´ITULO 2. CONCEPTOS BASICOS
22
2. Indique si los siguientes indentificadores se pueden utilizar o no, completando la siguiente tabla 2.13. Responda Si o No y Porqu´e No. Identificador
Si o No
Porque
Arm nota 3 sueldo_basico dato1 area base Radio 5nota Aaa Pagototal Interes X %int Y 2 Entrada Dist Cuadro 2.13: Ejercicios sobre identificadores
2.8. EJERCICIOS
23
3. Escriba qu´e tipo de expresiones son las siguientes. Pueden ser de asignaci´on, l´ogicas o aritm´eticas. Ver tabla 2.14 Expresion
Tipo de expresion
a = b a = 5 && b > 3 3 + 5 * 8 - 9 * 3 area = 3.14 * r * r area > 1 c + 5 * 7 < b * b a = b * 3 b > c + a a > b && c < d a = a + a b = a + 1 c == d * 54 - f S % 2 == 1 a = pow
( 2 , c )
sqrt ( X ) > 4.0 Cuadro 2.14: Ejercicios sobre expresiones
´ CAP´ITULO 2. CONCEPTOS BASICOS
24
4. Pasar a C++ las expresiones aritm´eticas de la tabla 2.15. q c21 + c22 q
√ 1+3 2−4 2+3X 2 −X 4 +X
l 2 − c3 b A2 + B 2 + C 2 D2 + E 2 + F 2 A + BCD − EF 3 G √ √ G3 + 2 3X (4X 3 − b2 + Z)3 + 2X 3 Y (X 4 − 2Y 3 )1/2 + X + 4Y 3X + 4 − (−3X 2 + 4XY )3 2X 3 Y + 3XY X 5 + 2X 4 + 3X 3 − 2X 2 +X 2X 3 − X 2 + X 4X
√ 3X 2 +1
−
2X 3 X4 + Y
A2 + 3X X
2 −X
4X 3 − X 2 + X X + Y + Z 2X−3 + X 2 Cuadro 2.15: Ejercicios sobre expresiones aritm´eticas
2.8. EJERCICIOS
25
5. Eval´ ue paso a paso cada una de las siguientes expresiones de asignaci´on y determine el valor asignado a la variable. a = ( 20 + ( 10 + 5 * 2 ) * 4 ) / ( pow ( 2, 3 ) - 6 ) * sqrt ( ( 40 - 8 ) / 8 ) b = 6 * 3 + 2 - 5 * pow ( 3 , 2 ) c = 3 / (5 -2 ) + 1 d = 4 * 3 + ( 17 - 2 ) / 5 e = 12 * 5 + ( 17 + 3 ) / 5 f = pow ( 4 , 2 ) * 8 - 55 g = ( ( pow ( 2, 8 ) - 15 * 4 - 4 ) / sqrt ( 4 ) ) + ( 4 * pow ( 5, 2 ) -7 * 2 * 20 )| 6. Escriba las expresiones aritm´eticas que corresponden a cada una de las siguientes expresiones de asignaci´on en C++. a = ( bmy + bmn ) * h / 2 b = sqrt ( pow ( x2 - x1, 2 ) + pow ( y2 - y1 , 2 ) ) c = sqrt ( s * ( s - a ) * ( s - b ) * ( s - c ) ) d = ( a + b
+ c ) / ( b + e ) +
f
e = ( pow ( a, b ) + 3 ) / ( sqrt ( 16 * x * x ) - y * y ) 7. Encuentre los valores finales de a, b, c y d, enteras, teniendo en cuenta que los valores de las variables van cambiando a medida que se eval´ ua cada expresi´on. Ver Prueba de escritorio 2.
´ CAP´ITULO 2. CONCEPTOS BASICOS Prueba de escritorio 2
26
a = 5 b = 2 c= a + b d = 15 % 20 + c * b / 2 a = a + b + c + d b = ( ( pow ( b, ( pow ( c - 4 , b ) + 1 ) / b - 1 ) + b * b ) * sqrt ( ( b + c + 1 ) - 4 ) + ( d - b ) ) * b - a + 20 c = b - 165 d = b + 2 * sqrt ( 64 )
8. Encuentre los valores finales de a, b, c y d, enteras. Ver Prueba de escritorio 3. Prueba de escritorio 3 a b c d a b
= = = = = =
15 20 a a % b + pow * ( c = b d = a +
b ( 2 * b ) + b * c / 2 b + c + d ( ( ( 4 + pow ( 2 + a, 5 ) ) / ( b / 2 ) ) ( 10 + a ) - pow ( 2, 3 ) ) - 4, 2 ) + 15 250 + 13 2 * sqrt ( 100 + 28 * 2 - 12 )
Cap´ıtulo 3 Estructura secuencial La programaci´on secuencial es una serie de comandos o instrucciones una tras otra, con el fin de resolver un problema determinado. Una instrucci´on es ejecutada a continuaci´on de otra y todas son ejecutadas en el orden indicado. Instrucci´ on 1 Instrucci´ on 2 Instrucci´ on 3 .. . Instrucci´ on n
Las instrucciones b´asicas normalmente se pueden clasificar en: instrucciones para solicitar datos al usuario, c´alculos o procesamiento de datos para producir informaci´on y por supuesto entrega o impresi´on de resultados.
3.1.
Compilar y ejecutar un programa
Todo programa que se escriba en C++ deber´a ser compilado para que las instrucciones que el programador ha escrito sean entendidas por el procesador. Compilar es el proceso de conversi´on del lenguaje C++ a lenguaje de m´aquina para que ella lo interprete. 27
CAP´ITULO 3. ESTRUCTURA SECUENCIAL
28
Para compilar un archivo en C++, deber´a utilizar alguna de las siguientes instrucciones, de acuerdo a la versi´on del programa o sistema operativo. Ver tabla 3.1. Instrucci´on g++ nombre.cpp -o nombre tcc nombre.cpp bcc nombre.cpp
Compilador - Sistema Operativo g++ para Linux Turbo C++ para DOS - Windows Borland C++ para DOS - Windows
Cuadro 3.1: Compilar un programa en C++ Es importante anotar que aunque las instrucciones de compilaci´on mencionadas en la tabla 3.1 no son las u ´nicas, pero s´ı las m´as utilizadas. Para ejecutar un programa, simplemente escriba el nombre del archivo ejecutable generado por la orden de compilaci´on. A continuaci´on se presentan una serie de ejemplos o problemas resueltos, en los cuales se utilizan diferentes comandos. En la medida que vayan apareciendo, ser´an explicados.
3.2.
Problemas resueltos
1. Dados dos n´ umeros enteros que ingresan por teclado, sumarlos e imprimir el resultado. Suma = A + B Ver programa 1 “Suma de dos enteros”. A continuaci´on se explicar´an cada una de las instrucciones que componen el programa 1. La l´ınea #include <iostream.h> indica a C++ que debe incluir todas las funciones de manejo de flujos para entrada y salida, previamente construidos y al servicio del usuario. La tabla 3.2 muestra los archivos de bibliotecas de funciones m´as representativos de C++. Observe la segunda l´ınea del programa (// P_Sec_01), la cual corresponde a un comentario. Los comentarios se utilizan para facilitar al
3.2. PROBLEMAS RESUELTOS
29
Programa 1 - Suma de dos enteros #include <iostream.h> // P_Sec_01 void main ( void ) { int A, B, Suma; cout << "SUMA DE DOS ENTEROS!!\n"; cout << "Primer cin >> A;
numero: ";
cout << "Segundo numero: "; cin >> B; Suma = A + B; cout << "Suma
: " << Suma;
}
Biblioteca iostream.h stdio.h math.h graphics.h conio.h stdio.h string.h ctype.h stdlib.h
Descripci´ on Biblioteca para el manejo de flujos de entrada y salida. Biblioteca est´andar de entrada y salida. Es el conjunto de funciones matem´aticas. Contiene las funciones para la elaboraci´on de gr´aficas. Contiene funciones que manejan entrada y salida por la consola. Solo es v´alida en DOS - Windows. Biblioteca est´andar de entrada y salida. Contiene funciones para el manejo de cadenas de caracteres. Contiene funciones para validaci´on de tipos de datos. Es la biblioteca est´andar. Cuadro 3.2: Principales bibliotecas de C++
30
CAP´ITULO 3. ESTRUCTURA SECUENCIAL programador la lectura y comprensi´on del c´odigo escrito ya sea por ´el mismo o por otros programadores. Los comentarios son ignorados en el proceso de compilaci´on. Para escribir un comentario, simplemente se escriben dos caracteres / seguidos y el comentario terminar´a al finalizar la l´ınea. En este caso, el comentario corresponde al nombre del archivo que contiene el c´odigo fuente del ejemplo, cuya extensi´on es .cpp. Todo programa en C++ debe tener al menos una funci´on, llamada main. En este caso, la instrucci´on void main ( void ) indica que se est´a definiendo la funci´on principal del programa, llamada main. M´as adelante tendremos una explicaci´on m´as detallada de esta definici´on. El conjunto de instrucciones que forman la funci´on main se agrupa utilizando los s´ımbolos { y } los cuales indican el comienzo y el final de un bloque de c´odigo. Es importante anotar que si una variable es declarada dentro de un bloque, tiene alcance u ´nicamente al interior del bloque en que se encuentra, es decir, no se puede utilizar por fuera del bloque. Las variables de este programa son de tipo entero. La declaraci´on es int A, B, Suma;. La instrucci´on cout << "SUMA DE DOS ENTEROS!!\n" ; permite imprimir en el dispositivo est´andar de salida, normalmente la pantalla, el mensaje encerrado entre comillas. El caracter de escape \n se utiliza para obligar un salto al inicio del siguiente rengl´on. A continuaci´on, se leen los datos A y B, acompa˜ nados de los respectivos mensajes en pantalla que ayudan a identificar el dato a leer. La instrucci´on cin es la utilizada para este fin. Observe que el s´ımbolo << es utilizado para indicar flujo de salida, es decir, se utiliza normalmente en una impresi´on por pantalla, mientras que el flujo de entrada >> es utilizado regularmente para ingresar datos desde el teclado. Para calcular el resultado de la suma de los dos enteros, simplemente se utiliza la expresi´on de asignaci´on, donde se escribe la expresi´on aritm´etica correspondiente a la derecha del signo =. Finalmente, es necesario informar el resultado obtenido. Es la misma instrucci´on de imprimir en la pantalla mencionada anteriormente, enviando el valor de la variable Suma al flujo de salida.
3.2. PROBLEMAS RESUELTOS
31
2. Calcular el ´area de un c´ırculo dada la longitud del radio. Area = π × r2 Ver programa 2 “Calcular el ´area de un c´ırculo”. Programa 2 - Calcular el ´ area de un c´ırculo #include <iostream.h> // P_Sec_02 const double PI = 3.1415926; void main ( void ) { double Radio, Area; cout << "AREA DEL CIRCULO!!\n"; cout << "Radio: "; cin >> Radio; Area = PI * Radio * Radio; cout << "Area : " << Area; }
En el programa 2 se puede apreciar que algunos componentes son muy similares al primero. Tenga en cuenta que debe conservar la estructura inicial, incluyendo la biblioteca iostream.h. La definici´on de la funci´on principal (main) se compone de instrucciones equivalentes al programa P_Sec_01.cpp. Dentro de las instrucciones propias del programa, encontramos las variables |Area|y Radio son de tipo double.
CAP´ITULO 3. ESTRUCTURA SECUENCIAL
32
Finalmente, se aplica la f´ormula adecuada y se imprime el resultado. Observe el uso de la constante de tipo double llamada PI, la cual permite utilizar el valor de PI = 3.1415926 dentro del programa. Las constantes, como su nombre lo indican, no pueden ser modificadas dentro de un programa, despu´es de su definici´on. En caso de incluir en el programa la biblioteca math.h, se puede utilizar la constante M_PI, con un mejor grado de aproximaci´on, donde sobrar´ıa definir la constante PI al iniciar el programa. 3. Convertir una temperatura dada en grados Fahrenheit a grados cent´ıgrados. Cent =
´ 5 ³ × F ahr − 32 9
Ver programa 3 “Conversi´on de temperaturas”. Programa 3 - Conversi´ on de temperaturas #include <iostream.h> // P_Sec_03 const double CONSFAHR1 = 5.0 / 9.0; const double CONSFAHR2 = 32.0; void main ( void ) { double Fahr, Cent; cout << "TEMPERATURA!!\n";
En el programa 3 se puede notar que se utilizan constantes donde una de ellas corresponde al resultado de una operaci´on aritm´etica (5.0/9.0), mientras la otra es un valor. Recuerde que una constante no puede puede ser modificada dentro del programa. Observe que se utiliza el cero a continuaci´on del punto separador decimal. El prop´osito de hacerlo de
3.2. PROBLEMAS RESUELTOS
33
Continuaci´ on programa 3 cout << "Fahrenheit : "; cin >> Fahr; Cent = CONSFAHR1 * ( Fahr - CONSFAHR2 ); cout << "Centigrados: " << Cent; }
esta forma es para que C++ se entere de que no puede hacer divisi´on entre dos enteros. Es importante anotar que no es obligatorio utilizar constantes. Sin embargo, se recomienda su uso para facilitar la realizaci´on de modificaciones, la interpretaci´on y la lectura del c´odigo fuente de un programa. Otra recomendaci´on es mantener los nombres de los identificadores que corresponden a constantes en letras may´ usculas, para que se puedan diferenciar r´apidamente. Con respecto a la l´ogica del programa, la entrada de datos, el c´alculo y la salida correponde al enunciado del problema. 4. Convertir la medida de un ´angulo expresado en grados, minutos y segundos, a radianes. Grados = Grados + M/60 + S/3600
Radianes =
Grados × π 180
Ver programa 4 “Conversi´ on de ´angulos”. El programa 4, como novedad incluye dos f´ormulas, donde el resultado de la primera es incorporado en la segunda, por medio del identificador Grados.
CAP´ITULO 3. ESTRUCTURA SECUENCIAL
34
Programa 4 - Conversi´ on de ´ angulos #include <iostream.h> // P_Sec_04 const const const const
double double double double
PI GRAD_MIN GRAD_SEG MEDIO_CIRCULO
= 3.1415926; = 60.0; = 3600.0; = 180.0;
void main ( void ) { double Grados, Minutos, Segundos, Radianes; cout << "CONVERSION DE ANGULOS!!\n"; cout << "Grados cin >> Grados;
: ";
cout << "Minutos : "; cin >> Minutos; cout << "Segundos: "; cin >> Segundos; Grados
+= Minutos / GRAD_MIN + Segundos / GRAD_SEG;
Radianes = Grados * PI / MEDIO_CIRCULO; cout << "Angulo en radianes: " << Radianes; }
3.2. PROBLEMAS RESUELTOS
35
5. Calcular el ´area de un tri´angulo conociendo las longitudes de los tres lados. s= ´ Area =
p
a+b+c 2
s × (s − a) × (s − b) × (s − c)
´ Ver programa 5 “Area de un tri´angulo”. ´ Programa 5 - Area de un tri´ angulo #include <iostream.h> #include <math.h> // P_Sec_05 void main ( void ) { const double SEMI = 2.0; double L1, L2, L3, S, Area; cout << "AREA DEL TRIANGULO!!\n";
En el programa 5 se utiliza la constante local a la funci´on main. A diferencia de las constantes declaradas en los programas anteriores es que SEMI solo es reconocida dentro de la funci´on main, mientras las otras son reconocidas en toda el programa. Adem´as, la funci´on sqrt corresponde a la operaci´on ra´ız cuadrada, definida dentro de la biblioteca math.h. Si se olvida incluir esta biblioteca, C++ genera un mensaje de error, por desconocer la funci´on sqrt.
CAP´ITULO 3. ESTRUCTURA SECUENCIAL Continuaci´ on programa 5
36
cout << "Lado 1 cin >> L1;
: ";
cout << "Lado 2 cin >> L2;
: ";
cout << "Lado 3 cin >> L3;
: ";
S
= ( L1 + L2 + L3 ) / SEMI;
Area = sqrt ( S * (S-L1) * (S-L2) * (S-L3)
);
cout << "El area es: " << Area; }
3.3.
Problemas propuestos
Antes de resolver cualquier ejercicio, lea detenidamente el enunciado, identifique los datos que necesita, cu´ales son conocidos y cu´ales no. Los datos desconocidos generalmente est´an asociados a f´ormulas matem´aticas que debe tener a la mano. No olvide que la respuesta del programa debe estar de acuerdo con los requerimientos del enunciado. Documente y use identificadores representativos para que se puedan entender m´as f´acilmente sus programas. 1. Dado un n´ umero natural n, calcular la suma de los primeros n n´ umeros naturales. n × (n + 1) Suma = 2 2. Calcular el valor de una compra de unos d´olares, conociendo el valor de la tasa representativa del mercado (TRM) en pesos. P esos = D´ olares × T RM
3.3. PROBLEMAS PROPUESTOS
37
3. De un estudiante conocemos la nota 1 (N1 ), la nota 2 (N2 ), la nota de trabajos (NT ) y el Examen final (EF ). Calcular la nota definitiva (ND ) aplicando los porcentajes 20%, 20%, 30% y 30%, respectivamente. Tenga en cuenta que 20% equivale a 0.2 y 30% es igual a 0.3. ND = N1 × 20 % + N2 × 20 % + NT × 30 % + EF × 30 % 4. Dados dos puntos del plano cartesiano P (X1 , Y1 ) y Q(X2 , Y2 ), hallar las coordenadas del punto medio. Xm =
X1 + X2 2
Ym =
Y1 + Y2 2
5. En una competencia cicl´ıstica se hace un recorrido de una distancia medida en Km, en un tiempo total medido en horas (H), minutos (M ), segundos (S) y cent´esimas de segundo (CS ). Calcular la velocidad en Km por hora. Tenga en cuenta que una hora equivale a 60 minutos, un minuto a 60 segundos y un segundo a 100 cent´esimas de segundo. T iempo = H + M/60 + S/3600 + CS /360000 V elocidad =
Distancia T iempo
6. Dada la longitud del lado (L) de un cubo, calcular el ´area de la base (AB ), el ´area lateral (AL ), y el volumen (V ). AB = L2
AL = 4 × AB
V = L3
7. Hallar el deteminante de una matriz 2 x 2, de la forma: µ ¶ a b c d Determinante = a × d − b × c
38
CAP´ITULO 3. ESTRUCTURA SECUENCIAL
8. Calcular el rendimiento de un CDT en una entidad financiera, conociendo el monto, el plazo en d´ıas y la tasa de inter´es anual. Observe que por tener el plazo en dias, la tasa de inter´es anual se divide entre 360. M onto × Inter´ es × P lazo Rendimiento = 360 9. Dado el monto de un cr´edito (M ), el plazo (P ) y tasa de interes anual (I), calcular la cuota fija mensual (C) que se debe cancelar a una entidad financiera. M × I × (I + 1)P C= (I + 1)P − 1 10. Dados tres puntos del plano cartesiano P (X1 , Y1 ); Q(X2 , Y2 ) y R(X3 , Y3 ), correspondientes a los v´ertices de un tri´angulo, hallar su ´area y su per´ımetro. p DistanciaP −Q = a = (X2 − X1 )2 + (Y2 − Y1 )2 s= ´ Area =
p
a+b+c 2
s × (s − a) × (s − b) × (s − c) P erimetro = 2 × s
Cap´ıtulo 4 Funciones Si un programa tuviera u ´nicamente la funci´on main, el c´odigo ser´ıa demasiado largo y complejo, dif´ıcil de leer, modificar, actualizar y depurar. Para facilitar estas tareas, es recomendable utilizar funciones. Las funciones adem´as permiten modularizar programas (dividir un programa extenso en partes m´as f´aciles de manejar), reutilizar el c´odigo (aprovechar funciones ya escritas y probadas en otros programas en programas nuevos) y evitar la repetici´on de c´odigo en un programa (fragmentos que se utilicen varias veces en un mismo programa).
4.1.
Estructura de una funci´ on
Las funciones tienen una estructura general como la siguiente: Ver “Estructura de una funci´on”.
Ejemplo Ver “Funci´ on que suma dos enteros”. Para utilizar una funci´on (hacer el llamado), es importante tener en cuenta el tipo de dato que devuelve, su identificador y los argumentos que se deben proporcionar, a fin de evitar errores. Ver “Funci´ on que llama a otra”. 39
CAP´ITULO 4. FUNCIONES
40
Estructura de una funci´ on tipo_de_valor_devuelto Nombre_funcion ( lista_de_parametros ) { declaracion_variables_locales lista_de_instrucciones }
Funci´ on que suma dos enteros int Suma ( int Numero1, int Numero2 ) { int Resultado; Resultado = Numero1 + Numero2; return Resultado; }
Funci´ on que llama a otra int Calculo_Prueba ( void ) { int A, B, S; A = 10; B = 50; S = Suma ( A, B ); return S; }
4.2. RECOMENDACIONES Y GENERALIDADES
41
Tenga en cuenta la diferencia entre los t´erminos par´ametros y argumentos. En la funci´on Suma, Numero1 y Numero2 son par´ametros y Resultado es una variable local de tipo entero. En Calculo_Prueba, no hay par´ametros (void) mientras que los argumentos con los cuales se pasa informaci´on a la funci´on Suma son A y B. Sus variables locales son A, B y S, enteras.
4.2.
Recomendaciones y generalidades
Cualquier programa escrito en C++ se compone de al menos una funci´on llamada main (principal). Esta funci´on tiene especificadas todas las instrucciones que se van a ejecutar en el programa, escritas en el orden que determine el programador. El nombre de una funci´on es un identificador v´alido. Es importante utilizar nombres muy claros y significativos para aumentar la claridad de un programa. Despu´es de creada una funci´on, pasar´a a ser una instrucci´on m´as del lenguaje, dentro del programa en que se encuentre. Asi, se ampl´ıan las posibilidades del usuario. Las variables declaradas dentro de una funci´on, tendr´an alcance local, es decir, solo tendr´an sentido dentro de la funci´on. Al terminar la ejecuci´on de dicha funci´on, estas variables desaparecen. Cuando una funci´on necesita de otra, generalmente le proporciona informaci´on al hacer el llamado (usando su identificador), a trav´es de argumentos, los cuales se llamar´an par´ametros dentro de la funci´on que recibe dicha informaci´on. Los par´ametros se consideran variables locales. Aunque no es obligatorio, los nombres de los par´ametros no deben ser los iguales a los nombres de los argumentos para evitar ambig¨ uedades. Una funci´on debe estar escrita de tal manera que sea muy clara la tarea que desempe˜ na (una y solo una). En otras palabras, una funci´on debe ser f´acil de describir mediante una frase que no tenga conectores l´ogicos.
CAP´ITULO 4. FUNCIONES
42
En caso de tener necesidad de realizar varias tareas en una funci´on, deber´an hacerse los llamados a funciones que realicen tareas individuales. Con respecto a la longitud, en lo posible, una funci´on no debe ocupar m´as de una p´agina. Ser´ıa ideal que no ocupara m´as de media. Al construir programas como una colecci´on de funciones peque˜ nas se facilita su escritura, depuraci´on, mantenimiento y modificaci´on.
4.3.
Problemas resueltos
En esta secci´on se mostrar´an los mismos ejemplos del cap´ıtulo anterior, aprovechando los beneficios que ofrecen las funciones. Cuando se utilicen funciones que hacen parte de otros programas, simplemente se har´a la referencia a la p´agina en la que se utiliz´o por primera vez y se encuentra su explicaci´on. A diferencia de los programas que se explicaban al finalizar cada uno, ahora se har´an los comentarios pertinentes al finalizar cada funci´on. 1. Dados dos n´ umeros enteros que ingresan por teclado, sumarlos e imprimir el resultado. Suma = A + B Ver programa 6 “Suma de dos enteros”. En el programa 6, la funci´on principal tiene como objetivo llamar las funciones necesarias para entregar la suma de dos enteros dados por el usuario. Usa tres variables locales, A, B y Suma. Imprime en pantalla un t´ıtulo con el objetivo del programa. Realiza dos veces el llamado a la funci´on Entrada_Int, retornando en las variables A y B. Al hacer el llamado a la funci´on se le pasa como argumento una cadena de caracteres (mensaje entre comillas), que ayuda a identificar el dato que el usuario va a ingresar.
4.3. PROBLEMAS RESUELTOS
43
Programa 6 - Suma de dos enteros #include <iostream.h> // P_Fun_01 // Prototipos int Entrada_Int ( char Msj[] ); int Calculo ( int Numero1, int Numero2 ); void Salida_Int ( char Msj[], int Numero ); // Programa principal void main ( void ) { int A, B, Suma; cout << "SUMA DE DOS ENTEROS!!\n"; A = Entrada_Int B = Entrada_Int Suma = Calculo Salida_Int }
( ( ( (
"Primer Numero: " "Segundo Numero: " A, B "Suma : ", Suma
); ); ); );
CAP´ITULO 4. FUNCIONES
44
La variable Suma recibe el valor que retorna la funci´on Calculo, al cual se le pasan como argumentos los valores de A y B. Finaliza el programa con el llamado a la funci´on Salida_Int, a la cual se le pasan dos argumentos, una cadena de caracteres que acompa˜ na la salida y un valor entero que se desea imprimir, en este caso, el valor de Suma. Tenga presente que aunque no es necesario alinear los operadores de asignaci´on, ni los par´entesis, un programa es mucho m´as f´acil de leer si el programador se toma unos minutos adicionales para mejorar la apariencia del c´odigo que est´a escribiendo. Continuaci´ on programa 6 int Entrada_Int ( char Msj[] ) { int Numero; cout << Msj; cin >> Numero ; return
Numero;
}
La funci´on Entrada_Int tiene como objetivo retornar un dato de tipo entero, ingresado por el usuario. El par´ametro Msj contiene el mensaje que se quiere imprimir (argumento dado en el llamado a la funci´on) para ayudar al usuario a identificar el dato a leer. El valor contenido en la variable local Numero es retornado a la funci´on que la ha llamado, generalmente para asignarlo a una variable. Esta funci´on ser´a utilizada en este libro cada vez que se necesite ingresar un n´ umero entero. En virtud de la reutilizaci´on de c´odigo, no se volver´a a explicar. Simplemente se har´a una referencia a esta p´agina. La funci´on Calculo tiene dos par´ametros Numero1 y Numero2. Estos dos par´ametros toman los valores que la funci´on llamante ha entregado
4.3. PROBLEMAS RESUELTOS
45
Continuaci´ on programa 6 int Calculo ( int Numero1, int Numero2 ) { return Numero1 + Numero2; }
como argumentos. El objetivo es retornar la suma de ellos. Continuaci´ on programa 6 void Salida_Int ( char Msj[], int Numero ) { cout << Msj << Numero << endl; }
La funci´on Salida_Int imprime en la pantalla un mensaje y un n´ umero entero que la funci´on llamante pasa como argumentos en los par´ametros Msj y Numero. Al igual que en la funci´on Entrada_Int, esta funci´on ser´a utilizado cada vez que se necesite imprimir un entero, caso en el cual se har´a la referencia respectiva. 2. Calcular el ´area de un c´ırculo dada la longitud del radio. Area = π × r2 Ver programa 7 “Calcular el ´area de un c´ırculo”. El objetivo de este programa es llamar las funciones necesarias para entregar el ´area de un c´ırculo cuando el usuario ha proporcionado la longitud del radio.
CAP´ITULO 4. FUNCIONES
46
Programa 7 - Calcular el ´ area de un c´ırculo #include <iostream.h> // P_Fun_02 const double PI = 3.1415926; // Prototipos double Entrada_Double ( char Msj[] ); double Calculo ( double Numero ); void Salida_Double ( char Msj[], double Numero ); void main ( void ) { double Area, Radio; cout << "AREA DEL CIRCULO!!\n"; Radio = Entrada_Double ( "Radio: " Area = Calculo ( Radio Salida_Double ( "Area : ", Area }
); ); );
4.3. PROBLEMAS RESUELTOS
47
Continuaci´ on programa 7 double Entrada_Double ( char Msj[] ) { double Numero; cout << Msj; cin >> Numero; return Numero; }
La diferencia fundamental con el programa anterior radica en el uso de variables de tipo double, lo que obliga a utilizar Entrada_Double y Salida_Double. La funci´on Entrada_Double, es similar a Entrada_Int, de la p´agina 44, pero retornando un valor de tipo double. Continuaci´ on programa 7 double Calculo ( double Numero ) { return PI * Numero * Numero; }
La funci´on Calculo, encuentra el ´area de un c´ırculo donde el radio est´a representado por el par´ametro Numero. Retorna un valor de tipo double. umero Salida_Double es similar a Salida_Int (p´agina 45), pero el n´ que imprime es de tipo double. Ser´a referenciada en cualquier utilizaci´on posterior.
CAP´ITULO 4. FUNCIONES Continuaci´ on programa 7
48
void Salida_Double ( char Msj[], double Numero ) { cout << Msj << Numero << endl; }
3. Convertir una temperatura dada en grados Fahrenheit a grados cent´ıgrados. ´ 5 ³ Cent = × F ahr − 32 9 Ver programa 8 “Conversi´on de temperaturas”. Programa 8 - Conversi´ on de temperaturas #include <iostream.h> // P_Fun_03 const double CONSFAHR1 = 5.0/9.0; const double CONSFAHR2 = 32.0; // Prototipos double Entrada_Double ( char Msj[] ); double Calculo ( double Numero ); void Salida_Double ( char Msj[], double Numero );
Este programa hace el llamado de las funciones necesarias para imprimir el resultado de convertir una temperatura dada por el usuario en grados Fahrenheit a grados Cent´ıgrados. Usa variables locales de tipo double, al igual que dos constantes.
4.3. PROBLEMAS RESUELTOS
49
Continuaci´ on programa 8 void main ( void ) { double Fahr, Cent; cout << "TEMPERATURA!!\n"; Fahr = Entrada_Double ( "Fahrenheit : " ); Cent = Calculo ( Fahr ); Salida_Double ( "Centigrados: ", Cent ); }
La entrada de la temperatura se hace mediante el llamado a la funci´on Entrada_Double, visto en la p´agina 47. Continuaci´ on programa 8 double Calculo ( double Numero ) { return CONSFAHR1 * ( Numero - CONSFAHR2 ); }
La funci´on Calculo recibe la temperatura en grados Fahrenheit y retorna su equivalente en grados cent´ıgrados. Para ello, recibe en el par´ametro Numero la temperatura y hace uso de las constantes definidas al inicio del programa. Para la salida del resultado, utilizamos la funci´on Salida_Double de la p´agina 48.
CAP´ITULO 4. FUNCIONES
50
4. Convertir la medida de un ´angulo expresado en grados, minutos y segundos, a radianes. Grados = Grados + M/60 + S/3600
Radianes =
Grados × π 180
Ver programa 9 “Conversi´on de ´angulos”. Programa 9 - Conversi´ on de ´ angulos #include <iostream.h> // P_Fun_04 const const const const
double double double double
PI GRAD_MIN GRAD_SEG MEDIO_CIRCULO
= 3.1415926; = 60.0; = 3600.0; = 180.0;
// Prototipos double Entrada_Double ( char Msj[] ); double Calc_Rad ( double Gr, double Mn, double Sg ); void Salida_Double ( char Msj[], double Numero );
Este programa imprime el equivalente de un ´angulo suministrado en Grados, Minutos y Segundos, a Radianes, utilizando las funciones Entrada_Double vista en la p´agina 47, Calc_Rad y Salida_Double de la p´agina 48.
4.3. PROBLEMAS RESUELTOS
51
Continuaci´ on programa 9 void main ( void ) { double Grados, Minutos, Segundos, Radianes; cout <<
"CONVERSION DE ANGULOS!!\n";
Grados = Entrada_Double Minutos = Entrada_Double Segundos = Entrada_Double Radianes = Calc_Rad Salida_Double
( ( ( ( (
"Grados : " "Minutos : " "Segundos: " Grados, Minutos, Segundos "Radianes: ", Radianes
); ); ); ); );
}
Continuaci´ on programa 9 double Calc_Rad ( double Gr, double Mn, double Sg ) { Gr += Mn / GRAD_MIN + Sg / GRAD_SEG; return Gr * PI / MEDIO_CIRCULO; }
La funci´on Calc_Rad realiza un c´alculo temporal en la variable Gr y luego la conversi´on aplicando las respectivas f´ormulas. Es de tener en cuenta que al pasar valores de datos a una funci´on, lo que se est´a pasando es una copia del valor respectivo. Por lo tanto, si dentro de una funci´on se realiza alguna modificaci´ on al par´ ametro recibido, no se modifica la variable original, como en caso de Calc_Rad con el valor del par´ ametro Gr.
CAP´ITULO 4. FUNCIONES
52
5. Calcular el ´area de un tri´angulo conociendo las longitudes de los tres lados. s= ´ Area =
a+b+c 2
p
s × (s − a) × (s − b) × (s − c)
´ Ver programa 10 “Area de un tri´angulo”. ´ Programa 10 - Area de un tri´ angulo #include<iostream.h> #include<math.h> // P_Fun_05 const double SEMI = 2.0; // Prototipos double Entrada_Double ( char Msj[] ); double Calculo ( double N1, double N2, double N3 ); void Salida_Double ( char Msj[], double Numero ); void main ( void ) { double L1, L2, L3, S, Area; cout << "AREA DEL TRIANGULO!!\n"; L1 = Entrada_Double L2 = Entrada_Double L3 = Entrada_Double Area = Calculo Salida_Double }
( ( ( ( (
"Lado 1 : "Lado 2 : "Lado 3 : L1, L2, L3 "El area es:
" " "
); ); ); ); ", Area );
4.4. PROBLEMAS PROPUESTOS
53
El programa 10 imprime el ´area de un tri´angulo cuando el usuario ha proporcionado las longitudes de los tres lados. Usamos las funciones Entrada_Double, (p´agina 47) y Salida_Double (p´agina 48). Continuaci´ on programa 10 double Calculo ( double N1, double N2, double N3 ) { double S; S = ( N1 + N2 + N3 ) / SEMI; return sqrt ( S * (S-N1) * (S-N2) * (S-N3) ); }
La funci´on Calculo usa la informaci´on que recibe en sus tres par´ametros para calcular el ´area del tri´angulo. Usa un c´alculo temporal (Semiper´ımetro).
4.4.
Problemas propuestos
As´ı como los ejemplos de este cap´ıtulo fueron los mismos del cap´ıtulo anterior, convertidos de tal manera que usaran funciones, sugerimos que los problemas a resolver en este cap´ıtulo sean los mismos de la p´agina 36, usando funciones.
54
CAP´ITULO 4. FUNCIONES
Cap´ıtulo 5 Decisiones simples En vista de que no todos los problemas se pueden resolver de forma secuencial, C++ permite el uso de las decisiones simples mediante el uso de la estructura if. El if (estructura de decisi´on simple) permite definir dos conjuntos de instrucciones que se deben ejecutar de acuerdo al resultado de una expresi´on l´ogica. En todos los casos, se puede escoger un solo bloque de instrucciones de tal manera que el otro es ignorado. Puede ocurrir que el segundo bloque est´e vac´ıo, caso en el cual simplemente la ejecuci´on de las instrucciones del primer bloque dependen exclusivamente del resultado de la expresi´on l´ogica, tambi´en llamada condici´on. Ver “Estructura general del if - 1”. En cualquier caso, la condici´on tendr´a que tomar un valor de verdad, el cual puede ser verdadero o falso. No es posible evitarlos o escogerlos a los dos, al mismo tiempo. Por lo tanto, se dice que la decisi´on es excluyente. A pesar de que siempre se intenta escribir programas lo m´as f´aciles de leer y entender, a veces se requiere del criterio de FALSO es igual a cero y VERDADERO es diferente de cero, por lo cual es posible encontrar programas con decisiones como por ejemplo: Ver “Estructura general del if - 2”.
55
56
CAP´ITULO 5. DECISIONES SIMPLES Estructura general del if - 1 Instrucciones antes de la decision if ( condicion ) { Instrucciones en caso de que condicion sea verdadero } else { Instrucciones en caso de que condicion sea falso } Instrucciones despues de la decision
Estructura general del if - 2 Instrucciones antes de la decision if ( valor ) { Instrucciones en caso de que valor sea diferente de cero } else { Instrucciones en caso de que valor sea cero } Instrucciones despues de la decision
5.1. PROBLEMAS RESUELTOS
57
Muchas personas intentan resumir el c´odigo de un programa eliminando los s´ımbolos de agrupaci´on { } cuando el bloque se compone de una sola instrucci´on. Aunque es muy respetable y no genera errores al momento de compilar, no es recomendable porque dificulta la legibilidad y sobre todo el proceso de actualizaci´on de los programas.
5.1.
Problemas resueltos
1. Elabore un programa que realice la divisi´on entre dos enteros, evitando la divisi´on por cero. Cociente =
Dividendo Divisor
Ver programa 11 “Divisi´ on por cero”. El manejo de la decisi´on en el programa 11 es con respecto a cero. Es decir, si el Divisor es diferente de cero, se ejecuta el bloque de instrucciones que se escribieron a continuaci´on de la condici´on. En caso de que sea falsa la condici´on, se ejecuta el bloque de instrucciones que est´a a continuaci´on de la palabra else. Para la entrada de los datos correspondientes al Dividendo y Divisor, se utiliza la funci´on Entrada_Int de la p´agina 44. La funci´on Calc_Cociente realiza la divisi´on entre dos enteros llamados (Dividendo y Divisor) que dentro de esta funci´on est´an representados por los par´ametros Numero1 y Numero2, respectivamente. Para la entrega de los resultados se utiliza la funci´on Salida_Int de la p´agina 45.
CAP´ITULO 5. DECISIONES SIMPLES
58
Programa 11 - Divisi´ on por cero #include <iostream.h> // P_Dec_01 // Prototipos int Entrada_Int ( char Msj[] ); int Calc_Cociente ( int Numero1, int Numero2 ); void Salida_Int ( char Msj[], int Numero ); void main ( void ) { int Dividendo, Divisor, Cociente; cout << "DIVISION POR CERO!!\n"; Dividendo = Entrada_Int ( "Dividendo: " ); Divisor = Entrada_Int ( "Divisor : " ); if ( Divisor != 0 ) { Cociente = Calc_Cociente( Dividendo, Divisor ); Salida_Int ( "Resultado: ", Cociente ); } else { cout << "ERROR!! Division por cero."; } }
5.1. PROBLEMAS RESUELTOS
59
Continuaci´ on programa 11 int Calc_Cociente ( int Numero1, int Numero2 ) { return Numero1 / Numero2; }
2. De un trabajador se tienen el n´ umero de horas trabajadas, el valor de la hora y su presupuesto mensual de gastos. Mediante un programa que solicite estos datos desde el teclado, calcule el salario y determine si su ingreso es suficiente para cubrir los gastos o no. Ingreso = N u´mero de horas × V alor de la hora Ver programa 12 “An´ alisis del presupuesto mensual”. Programa 12 - An´ alisis del presupuesto mensual #include <iostream.h> // P_Dec_02 // Prototipos int double double void
Entrada_Int Entrada_Double Calculo_Ingreso Verificar
( ( ( (
char char int double
Msj[] Msj[] NH, double VH Ing, double Pre
void main ( void ) { int N_Horas; double V_Hora, Ingreso, Presup;
); ); ); );
CAP´ITULO 5. DECISIONES SIMPLES Continuaci´ on programa 12
60
cout << "PRESUPUESTO!!\n"; N_Horas = V_Hora = Presup = Ingreso = Verificar
Entrada_Int ( Entrada_Double ( Entrada_Double ( Calculo_Ingreso( (
"Numero de horas : " ); "Valor hora : " ); "Presupuesto mensual: " ); N_Horas, V_Hora ); Ingreso, Presup );
}
Las funciones Entrada_Int de la p´agina 44 y Entrada_Double de la p´agina 47, permiten leer los datos desde el teclado. Estos datos son los argumentos al llamar la funci´on Calculo_Ingreso para el c´alculo del salario del empleado. Finalmente las variables Ingreso y Presup se pasan como argumentos a la funci´on Verificar. Continuaci´ on programa 12 double Calculo_Ingreso ( int NH, double VH ) { return NH * VH; }
La funci´on Calculo_Ingreso recibe como par´ametros los argumentos con los cuales ha sido llamado, con el prop´osito de retornar el ingreso del empleado. La funci´on Verificar es un ejemplo de c´omo tomar una decisi´on para seleccionar el mensaje adecuado de acuerdo al comportamiento de la condici´on.
5.1. PROBLEMAS RESUELTOS
61
Continuaci´ on programa 12 void Verificar ( double Ing, double Pre ) { if ( Ing >= Pre ) { cout << "El ingreso alcanza!!" ; } else { cout << "No es suficiente!!" ; } }
3. Verificar si un n´ umero est´a dentro del rango de los enteros cortos (short). Ver programa 13 “Verificaci´ on del rango de un entero corto”. Programa 13 - Verificaci´ on del rango de un entero corto #include <iostream.h> // P_Dec_03 const long LIMITE_INF = -32768; const long LIMITE_SUP = 32767; // Prototipos long Entrada_Long ( char Msj[] ); void Verificar ( long Num );
El programa 13 usa dos constantes de tipo long para establecer los l´ımites inferior y superior. Adem´as, mediante funciones se lee el n´ umero
CAP´ITULO 5. DECISIONES SIMPLES Continuaci´ on programa 13
62
void main ( void ) { long Entero; cout << "RANGO DE ENTEROS!!\n"; Entero = Entrada_Long ( "Numero : " ); Verificar ( Entero ); }
que es necesario verificar y al pasarlo como argumento a la funci´on Verificar se imprime un resultado en la pantalla. Continuaci´ on programa 13 long Entrada_Long ( char Msj[] ) { long Numero; cout << Msj; cin >> Numero; return
Numero;
}
La funci´on Entrada_Long es similar a Entrada_Int especificado en la p´agina 44. La funci´on Verificar imprime un mensaje de acuerdo a la condici´on. En este caso, la condici´on utiliza el conector l´ogico ||, para indicar que si el n´ umero al cual est´a representando el par´ametro Num est´a o no por fuera del rango especificado por las constantes LIMITE_INF y LIMITE_SUP.
5.1. PROBLEMAS RESUELTOS
63
Continuaci´ on programa 13 void Verificar ( long Num ) { if ( Num < LIMITE_INF || Num > LIMITE_SUP ) { cout << "Esta por fuera del rango!!"; } else { cout << "Puede ser un Entero!!"; } }
4. Elabore un programa que solicite la entrada del n´ umero de horas y el valor de cada hora trabajada por un empleado. El pago se calcular´a teniendo en cuenta que debe trabajar 160 horas en el mes. En caso de tener horas extras tendr´a una bonificaci´on del 20%. P ago Horas N ormales = NHoras × VHora
P ago Horas Extras = NH.Extras × VHora × 120 %
P ago = P ago Horas N ormales + P ago Horas Extras Ver programa 14 “Pago de horas extras a un trabajador”. El programa 14 utiliza las funciones Entrada_Int de la p´agina 44 y Entrada_Double de la p´agina 47. Utiliza la funci´on Calculo_Pago y el resultado que retorna lo almacena en la variable Pago.
CAP´ITULO 5. DECISIONES SIMPLES
64
Programa 14 - Pago de horas extras a un trabajador #include <iostream.h> // P_Dec_04 const int HORAS_BASE = 160; const int MIN_H_EXTR = 0; const double PORC_INC = 120.0 / 100.0; // Prototipos int double double void
Entrada_Int Entrada_Double Calculo_Pago Salida_Double
( ( ( (
char char int char
Msj[] Msj[] NH, double VH Msj[], double Numero
); ); ); );
void main ( void ) { int N_Horas; double V_Hora, Pago; cout << "HORAS EXTRAS!!\n"; N_Horas = Entrada_Int V_Hora = Entrada_Double Pago = Calculo_Pago Salida_Double }
( ( ( (
"Numero de horas "Valor hora N_Horas, V_Hora "Valor a pagar
: " : "
); ); ); : ", Pago );
5.1. PROBLEMAS RESUELTOS
65
Continuaci´ on programa 14 double Calculo_Pago ( int NH, double VH ) { int H_Extras, H_Normal; if ( NH > HORAS_BASE ) { H_Extras = NH - HORAS_BASE; H_Normal = HORAS_BASE; } else { H_Extras = MIN_H_EXTR; H_Normal = NH; } return H_Normal * VH + H_Extras * VH * PORC_INC; }
En la funci´on Calculo_Pago es importante tener en cuenta el manejo de las operaciones que se deben realizar cuando se quiere calcular un porcentaje. Para la entrega de los resultados se utiliza la funci´on Salida_Double de la p´agina 48. 5. Calcular el rendimiento de un CDT en una entidad financiera conociendo el monto, el plazo en d´ıas y la tasa de inter´es anual. Si el rendimiento supera el monto m´aximo permitido diario (especificado por el usuario) se debe pagar un impuesto a una tasa de inter´es, tambi´en ingresada por el usuario. Rendimiento = ½ Descuento =
M onto × P lazo × T asa 360
Rendimiento × T asa impuesto 0
CAP´ITULO 5. DECISIONES SIMPLES
66
Si el rendimiento supera la tasa diaria permitida se debe calcular el impuesto. En otro caso, no hay impuesto y se asigna como 0. P ago = Rendimiento − Descuento Ver programa 15 “Rendimiento de un CDT”. Programa 15 - Rendimiento de un CDT #include <iostream.h> // P_Dec_05 const double DIAS = 360.0; const double CONST_PORC = 100.0; const double MINIMO_DESC = 0.0; // Prototipos int Entrada_Int ( char double Entrada_Double ( char double Calc_Rend ( double double double Calc_Desc ( double int double Calc_Pago ( double void Salida_Double ( char
Msj[] Msj[] Mon, Tas Ren, Pla, Ren, Msj[],
); ); int Pla, ); double double double double
Max, Imp ); Des ); Numero );
El programa 15 utiliza las funciones Entrada_Int de la p´agina 44 y Entrada_Double de la p´agina 47. Utiliza las funciones Calc_Rend, Calc_Desc, y Calc_Pago para determinar el rendimiento, el descuento y el pago de un CDT.
5.1. PROBLEMAS RESUELTOS
67
Continuaci´ on programa 15 void main ( void ) { int Plazo; double Monto, Tasa, Maximo, Impuesto; double Rendto, Descuento, Pago; cout << "RENDIMIENTO CDT CON RETENCION!!\n"; Monto Plazo Tasa Maximo Impuesto
= = = = =
Entrada_Double Entrada_Int Entrada_Double Entrada_Double Entrada_Double
( ( ( ( (
"Monto del CDT "Plazo en dias "Interes anual ( 9% = 9 ) "Maximo valor diario "Tasa Impuesto ( 7% = 7 )
: : : : :
Rendto = Calc_Rend ( Monto, Plazo, Tasa Descuento = Calc_Desc ( Rendto, Maximo, Plazo, Impuesto Pago = Calc_Pago ( Rendto, Descuento Salida_Double Salida_Double Salida_Double
( "Rendimiento ( "Descuento ( "Valor a pagar
" " " " "
); ); ); ); ); ); ); );
: ", Rendto ); : ", Descuento ); : ", Pago );
}
Continuaci´ on programa 15 double Calc_Rend ( double Mon, int Pla, double Tas ) { return Mon * Pla * Tas / CONST_PORC / DIAS; }
CAP´ITULO 5. DECISIONES SIMPLES
68
En la funci´on Calc_Rend se calcula el rendimiento del CDT, usando la f´ormula especificada. Continuaci´ on programa 15 double Calc_Desc ( double Ren, double Max, int Pla, double Imp ) { double Desc; if ( Ren > Max * Pla ) { Desc = Ren * Imp / CONST_PORC; } else { Desc = MINIMO_DESC; } return Desc; }
La funci´on Calc_Desc se encarga de calcular el descuento, aplicando la f´ormula correspondiente. En caso de no superar la cantidad diaria, el descuento es el menor descuento especificado en la constante MINIMO_DESC. Continuaci´ on programa 15 double Calc_Pago ( double Ren, double Des ) { return Ren - Des; }
5.2. PROBLEMAS PROPUESTOS
69
Para la funci´on Calc_Pago se utiliza la f´ormula indicada, con los datos que se le suministren al momento de hacer el llamado en la funci´on principal. Para la entrega de los resultados se utiliza la funci´on Salida_Double de la p´agina 48.
5.2.
Problemas propuestos
1. Dado un n´ umero real cualquiera, imprimir su valor absoluto. ½ |x| =
x, si x ≥ 0 −x, si x < 0
2. De un empleado se conoce su sueldo actual. Si ´este es mayor o igual a $500.000, se le aumenta un 8%. En caso contrario, se le aumenta el 10%. SueldoN uevo = SueldoActual × 1,08 SueldoN uevo = SueldoActual × 1,1 3. Dadas tres notas de un estudiante, calcular la definitiva por promedio y un mensaje que indique si gan´o o perdi´o el curso. La nota m´ınima necesaria para aprobar es 3.0. P romedio =
N1 + N 2 + N3 3
4. Dado un n´ umero r y los coeficientes de una ecuaci´on cuadr´atica, imprima un mensaje que indique si r es ra´ız de la ecuaci´on, utilizando el m´etodo de sustituci´on. a × r2 + b × r + c = 0
CAP´ITULO 5. DECISIONES SIMPLES
70
5. Dado el precio de un art´ıculo, la cantidad de art´ıculos a comprar y el valor entregado por el cliente, calcular la devuelta (si le alcanza) o imprimir un mensaje que le indique que le hace falta dinero para pagar la cuenta. Cuenta = Cantidad × P recio Devuelta = V alorP agado − Cuenta 6. Dados dos puntos del plano cartesiano P (X1 , Y1 ) y Q(X2 , Y2 ), hallar la pendiente de la recta que pasa por ellos. Si x1 = x2, la pendiente no existe. P endiente =
Y2 − Y1 X2 − X1
7. Dados dos n´ umeros racionales en la forma ab y dc , realice la suma teniendo en cuenta que los denominadores no pueden ser ceros. a c a×d+b×c + = b d b×d 8. Dada una ecuaci´on de segundo grado, encontrar las soluciones. Si el discirminate es cero o positivo, hay soluciones reales. Si es negativo, las soluciones son imaginarias. x=
−b ±
√
b2 − 4 × a × c 2×a
9. Hallar la inversa de una matriz de 2 x 2 de la forma: µ ¶ a b A= c d La inversa es: 1 det(A)
µ
d −b −c a
Verifique que el determinante no sea cero.
¶
5.2. PROBLEMAS PROPUESTOS
71
10. Hallar la soluci´on u ´nica de un sistema de ecuaciones de 2 x 2 dados los coeficientes de las variables y los t´erminos independientes por la regla de Cramer. Si el determinante de la matriz de coeficientes es cero, el sistema no tiene soluci´on u ´nica.
aX + bY = c dX + eY = f ¯ ¯ ¯ a b ¯ ¯ ¯ Det = ¯ d e ¯ ¯ ¯ ¯ c b ¯ ¯ ¯ DetX = ¯ f e ¯
¯ ¯ a c DetY = ¯¯ d f DetX Det DetY Y = Det
X=
¯ ¯ ¯ ¯
72
CAP´ITULO 5. DECISIONES SIMPLES
Cap´ıtulo 6 Decisiones anidadas Existen problemas algor´ıtmicos que no se pueden realizar con una sola decisi´on, sino que requiere de una serie de decisiones, a veces una tras otra y otras veces unas dentro (dependientes) de otras. Cuando se tiene una decisi´on dentro del bloque de instrucciones a ejecutar dentro de otra decisi´on se dice que son decisiones anidadas. Por ejemplo, se pide calcular la comisi´on a pagar a un vendedor de acuerdo a su categor´ıa y al valor de las ventas realizadas seg´ un la tabla 6.1. Categor´ıa 1
2
Ventas 0 - 1.999.999 2.000.000 - 5.000.000 5.000.001 en adelante 0 1.000.000 2.000.001 3.000.001
Comisi´ on ( %) 0 3 5
999.999 - 2.000.000 - 3.000.000 en adelante
3
0 2 4 6 5
Cuadro 6.1: Ejercicio Ventas
73
CAP´ITULO 6. DECISIONES ANIDADAS
74
Se debe realizar primero un an´alisis para saber la forma de resolver el problema. Una forma acostumbrada por muchos programadores es realizar un ´arbol de decisiones similar al de la figura 6.1. Observe detalladamente esta gr´afica especialmente las diferentes condiciones y las f´ormulas respectivas.
´ Figura 6.1: Arbol de decisiones Note que en este tipo de tablas 1.999.999 quiere decir ventas menores, pero no iguales a 2.000.000. Sucede lo mismo con 999.999, es decir, ventas inferiores a 1.000.000.
6.1.
Problemas resueltos
1. Calcular la comisi´on a un vendedor de acuerdo a la tabla 6.1. Ver programa 16 “Comisi´ on a pagar a un vendedor”. En el programa 16 se puede notar que las decisiones se han dejado para que sean resueltas dentro de la funci´on Calculo_Com. El manejo de constantes en este programa es muy importante porque si se desean modificar los rangos o los porcentajes, se puede resolver cambiando estos valores. El manejo de las entradas se hace con las funciones Entrada_Int de la p´agina 44 y Entrada_Double de la p´agina 47.
6.1. PROBLEMAS RESUELTOS
75
Programa 16 - Comisi´ on a pagar a un vendedor #include <iostream.h> // P_Ani_01 const double CAT1_TOPE1 = const double CAT1_TOPE2 =
2000000.0; 5000000.0;
const double CAT2_TOPE1 = const double CAT2_TOPE2 = const double CAT2_TOPE3 =
1000000.0; 2000000.0; 3000000.0;
const double PORC_R1_C1 = 0.0 / 100.0; const double PORC_R2_C1 = 3.0 / 100.0; const double PORC_R3_C1 = 5.0 / 100.0; const const const const
double double double double
PORC_R1_C2 PORC_R2_C2 PORC_R3_C2 PORC_R4_C2
const double PORC_C3
= = = =
0.0 2.0 4.0 6.0
/ / / /
100.0; 100.0; 100.0; 100.0;
= 3.0 / 100.0;
// Prototipos int double double void
Entrada_Int Entrada_Double Calculo_Com Salida_Double
( ( ( (
char char int char
Msj[] Msj[] Cat, double Ven Msj[], double Numero
); ); ); );
CAP´ITULO 6. DECISIONES ANIDADAS
76
Continuaci´ on programa 16 void main ( void ) { int Categoria; double Ventas, Comision; cout << "COMISIONES DE VENTAS!!\n"; Categoria = Entrada_Int ( "Categoria : " Ventas = Entrada_Double ( "Ventas : "
); );
Comision
);
= Calculo_Com
Salida_Double
( Categoria, Ventas ( "Comision
: ", Comision );
}
Continuaci´ on programa 16 double Calculo_Com ( int Cat, double Ven ) { double Porc_Com; if ( Cat == 1 ) { if ( Ven <= CAT1_TOPE1 ) { Porc_Com = PORC_R1_C1; } else { if ( Ven <= CAT1_TOPE2 ) { Porc_Com = PORC_R2_C1; }
6.1. PROBLEMAS RESUELTOS Continuaci´ on programa 16 else { Porc_Com = PORC_R3_C1; } } } else { if ( Cat == 2 ) { if ( Ven <= CAT2_TOPE1 ) { Porc_Com = PORC_R1_C2; } else { if ( Ven <= CAT2_TOPE2 ) { Porc_Com = PORC_R2_C2; } else { if ( Ven <= CAT2_TOPE3 ) { Porc_Com = PORC_R3_C2; } else { Porc_Com = PORC_R4_C2; } } } }
77
CAP´ITULO 6. DECISIONES ANIDADAS Continuaci´ on programa 16
78
else { Porc_Com = PORC_C3; } } return Ven * Porc_Com; }
La funci´on Calculo_Com es un poco extenso a pesar de que una de las recomendaciones iniciales sugiere que la longitud no debe pasar de una p´agina y en lo posible no debe ser mayor a media (ver 41). Esta parte es la relacionada con la categor´ıa 1, en la cual se analizan los tres rangos posibles para la variable Ventas, que al pasar como argumento a esta funci´on es representada por el par´ametro Ven. La parte final del programa 16 permite calcular la comisi´on en caso de que la categor´ıa no sea ni 1 ni 2. Se supone, por descarte que la categor´ıa debe ser 3 para realizar un c´alculo correcto. Si por equivocaci´on o a prop´osito el usuario ingresa la categor´ıa como 4, el programa realiza los c´alculos como si fuera categor´ıa 3. Finalmente, la salida se realiza usando la funci´on Salida_Double de la p´agina 48. 2. Calcular el valor a pagar por concepto de matr´ıcula de acuerdo a la categor´ıa y al n´ umero de materias registradas, de acuerdo a la tabla 6.2. Este programa calcula la matr´ıcula de acuerdo a las condiciones fijadas en la tabla 6.2. Si cambian las condiciones, puede facilitarse la correcci´on del programa gracias a la utilizaci´on de constantes. El manejo de las entradas se hace con la funci´on Entrada_Int de la p´agina 44.
6.1. PROBLEMAS RESUELTOS Categoria 1 2 3 4
79
Valor Matricula 100.000 + nmat * 50.000 200.000 + nmat * 30.000 nmat * 70.000 350.000
Cuadro 6.2: Datos Ejemplo Matr´ıcula
Ver programa 17 “Valor de la matr´ıcula por categor´ıas”. Programa 17 - Valor de la matr´ıcula por categor´ıas #include <iostream.h> // P_Ani_02 const double C_FIJO_1 = 100000.0; const double C_FIJO_2 = 200000.0; const const const const
double double double double
V_MAT_1 V_MAT_2 V_MAT_3 MATRIC
= 50000.0; = 30000.0; = 70000.0; = 350000.0;
// Prototipos int Entrada_Int ( char Msj[] ); double Calc_Matricula ( int Cat, int Mat ); void Salida_Double ( char Msj[], double Numero );
Para el c´alculo de la matr´ıcula se requiere de dos datos que la funci´on llamante pasa como argumentos. En la variable Numero se almacena el resultado que se retorna. La salida se realiza usando la funci´on Salida_Double de la p´agina 48.
CAP´ITULO 6. DECISIONES ANIDADAS
80
Continuaci´ on programa 17 void main ( void ) { int Cat, N_Mat; double V_Materia, Pago; cout << "VALOR DE LA MATRICULA\n"; Cat = Entrada_Int N_Mat = Entrada_Int Pago
( "Categoria : " ( "Numero de materias : "
= Calc_Matricula ( Cat, N_Mat
Salida_Double
( "Valor a pagar
}
Continuaci´ on programa 17 double Calc_Matricula ( int Cat, int Mat ) { double Numero; if ( Cat == 1 ) { Numero = C_FIJO_1 + Mat * V_MAT_1; } else { if ( Cat == 2 ) { Numero = C_FIJO_2 + Mat * V_MAT_2; }
); ); );
: ", Pago );
6.1. PROBLEMAS RESUELTOS
81
Continuaci´ on programa 17 else { if ( Cat == 3 ) { Numero = Mat * V_MAT_3; } else { Numero = MATRIC; } } } return Numero; }
3. Encontrar el mayor de tres enteros diferentes que ingresan por teclado. Ver programa 18 “Encontrar el mayor de tres enteros”. Programa 18 - Encontrar el mayor de tres enteros #include <iostream.h> // P_Ani_03 // Prototipos int Entrada_Int ( char Msj[] ); int Mayor ( int A, int B, int C ); void Salida_Int ( char Msj[], int Numero );
CAP´ITULO 6. DECISIONES ANIDADAS Continuaci´ on programa 18
82
void main ( void ) { int N_1, N_2, N_3, May; cout << "EL MAYOR DE TRES NUMEROS!!\n"; N_1 = Entrada_Int N_2 = Entrada_Int N_3 = Entrada_Int
( "Primer numero : " ( "Segundo numero : " ( "Tercer numero : "
); ); );
May = Mayor
( N_1, N_2, N_3
);
Salida_Int
( "El mayor es
: ", May
);
}
El manejo de las entradas se hace con la funci´on Entrada_Int de la p´agina 44. La funci´on Mayor se encarga de determinar cu´al de los tres valores dados como argumentos es el mayor. Continuaci´ on programa 18 int Mayor ( int A, int B, int C ) { int Numero; if ( A > B ) { if ( A > C ) { Numero = A; }
6.1. PROBLEMAS RESUELTOS
83
Continuaci´ on programa 18 else { Numero = C; } } else { if ( B > C ) { Numero = B; } else { Numero = C; } } return Numero; }
En la funci´on Mayor se busca el n´ umero m´as grande sin utilizar conectores l´ogicos. Se recomienda la construcci´on de un ´arbol de decisiones para facilitar su comprensi´on. La salida se hace con Salida_Int. Ver p´agina 45. 4. Conociendo el kilometraje actual de un autom´ovil y el kilometraje en el cual se le realiz´o el u ´ltimo cambio de aceite. De acuerdo a la diferencia, indique si es oportuno el cambio de aceite (Diferencia <= 6000 Km y Diferencia >= 4500 Km); si es urgente (diferencia > 6000) o cu´antos kil´ometros hacen falta (diferencia < 4500 Km). Se debe cambiar el aceite a los cada 6000 Km. Ver programa 19 “Aviso para cambio de aceite”. El programa 19 utiliza la funci´on Entrada_Double para el ingreso de los datos correspondientes a kilometraje actual y anterior. Esta funcion se encuentra en la p´agina 47.
CAP´ITULO 6. DECISIONES ANIDADAS
84
Programa 19 - Aviso para cambio de aceite #include <iostream.h> // P_Ani_04 const double ALERTA = 4500.0; const double TOPE = 6000.0; // Prototipos double Entrada_Double ( char Msj[] ); double Diferencia ( double Act, double Ant ); void Verificar ( double K ); void main ( void ) { double Km_Ant, Km_Act, Km; cout << "CAMBIO DE ACEITE!!\n"; Km_Act = Entrada_Double ( "Km actual : " ); Km_Ant = Entrada_Double ( "Km ultimo cambio : " ); Km
= Diferencia
Verificar }
( Km_Act, Km_Ant
);
( Km
);
6.1. PROBLEMAS RESUELTOS
85
La funci´on Diferencia se encarga de realizar el c´alculo, mientras que Verificar se realiza la toma de decisiones para escoger el mensaje adecuado. Continuaci´ on programa 19 double Diferencia ( double Act, double Ant ) { return Act - Ant; }
La funci´on Diferencia es un c´alculo sencillo. Retorna la diferencia entre los dos datos que le han entregado como argumentos en la funci´on principal. Continuaci´ on programa 19 void Verificar ( double K ) { double Falta; Falta = TOPE - K; if ( K < ALERTA ) { cout << "Faltan " << Falta << " Km para el proximo cambio"; }
Verificar se encarga de calcular los kil´ometros que hacen falta para realizar al pr´oximo cambio de aceite. Este c´alculo hace parte de la informaci´on que debe imprimir.
CAP´ITULO 6. DECISIONES ANIDADAS Continuaci´ on programa 19
86
else { if ( K < TOPE ) { cout << "El cambio debe hacerlo pronto!!" << "\nFaltan " << Falta << " Km."; } else { cout << "URGENTE Cambio de Aceite"; } } }
5. Dados tres enteros diferentes, encuentre el mayor, el del medio y el menor, sin utilizar conectores l´ogicos. Ver programa 20 “Clasificaci´ on de tres enteros”. Programa 20 - Clasificaci´ on de tres enteros #include <iostream.h> // P_Ani_05 // Prototipos int Entrada_Int ( char Msj[] ); void Ordenar_Tres ( int A, int B, int C ); void Salida_Int ( char Msj[], int Numero );
Los n´ umeros enteros ingresan gracias a la funci´on Entrada_Int (ver p´agina 44. El programa 20 llama a la funci´on Ordenar_Tres para que determine el mayor.
6.1. PROBLEMAS RESUELTOS
87
Continuaci´ on programa 20 void main ( void ) { int N_1, N_2, N_3; cout <<
"CLASIFICACION DE TRES ENTEROS!!\n";
N_1 = Entrada_Int N_2 = Entrada_Int N_3 = Entrada_Int
( "Primer numero : " ); ( "Segundo numero : " ); ( "Tercer numero : " );
Ordenar_Tres
( N_1, N_2, N_3
);
}
Continuaci´ on programa 20 void Ordenar_Tres ( int A, int B, int C ) { int May, Med, Men; if ( A > B ) { if ( A > C ) { if ( B > C ) { May = A; Med = B; Men = C; }
CAP´ITULO 6. DECISIONES ANIDADAS
88
La funci´on Ordenar_Tres es un poco extenso. Desafortunadamente no siempre se pueden seguir todas las recomendaciones de la p´agina 41. La primera parte realiza las comparaciones entre cada posible par de n´ umeros cuando el primero es mayor que el segundo. Continuaci´ on programa 20 else { May = A; Med = C; Men = B; } } else { May = C; Med = A; Men = B; } } else { if ( B > C ) { if ( A > C ) { May = B; Med = A; Men = C; }
La segunda parte de la funci´on Ordenar_Tres se encarga de las comparaciones cuando el primero n´ umero no es mayor que el segundo.
6.2. PROBLEMAS PROPUESTOS
89
Continuaci´ on programa 20 else { May = B; Med = C; Men = A; } } else { May = C; Med = B; Men = A; } } Salida_Int ( "El mayor Salida_Int ( "El medio Salida_Int ( "El menor
: ", May ); : ", Med ); : ", Men );
}
Al finalizar se encarga de imprimir los tres n´ umeros. Debe imprimirlos en la misma funci´on debido a que no es posible retornar tres valores enteros. Usa la funci´on Salida_Int visto en la p´agina 45.
6.2.
Problemas propuestos
1. Muestre en pantalla el siguiente men´ u: 1. 2. 3. 4.
Convertir Convertir Convertir Convertir
de de de de
pulgadas a cent´ımetros cent´ımetros a pulgadas kil´ometros a metros metros a kil´ometros.
CAP´ITULO 6. DECISIONES ANIDADAS
90
En cada opci´on haga la conversi´on e imprima el resultado correspondiente. 1 pulgada = 2.54 cm 1 Km = 1000 m. 2. Solicite la entrada de la categor´ıa de un vendedor y las ventas del u ´ltimo mes. Calcule el pago teniendo en cuenta la tabla 6.3. No olvide que los porcentajes se deben escribir correctamente (3 % = 0,03). Categor´ıa 1 2 3 4
Ventas
Hasta 1.000.000 1.000.001 - 2.000.000 2.000.001 en adelante
5
B´ asico 100.000 200.000 300.000 1.000.000 0 100.000 200.000
Comisi´ on 3% 2% 1% 0% 3% 5% 10%
Cuadro 6.3: Datos problema propuesto 2 P ago = B´ asico + V entas × P orcentajeComisi´on
3. Dado el salario asignado a un empleado, calcular el impuesto sobre el salario recibido y el valor a pagar, de acuerdo a las siguientes consideraciones. Los primeros $250.000 no tienen impuesto; los segundos $250.000 tienen impuesto del 2%, los terceros $250.000 tienen un descuento del 4% adicional y el resto, 5% adicional. Tenga presente que un porcentaje del 4 % se escribe 0,04.
0, (Sal − 250,000) × 2 %, Imp = (Sal − 500,000) × 4 % + 5,000, (Sal − 750,000) × 5 % + 15,000,
si si si si
Sal ≤ 250,000 Sal ∈ (250,000, 500,000] Sal ∈ (500,000, 750,000] Sal > 750,000
6.2. PROBLEMAS PROPUESTOS
91
4. Leer el precio de un art´ıculo e imprimir el valor a pagar, teniendo en cuenta la tabla 6.4. No olvide que 5 % = 0,05. Precio Descuento 1 - 10.000 0% 10.001 - 20.000 5% 20.001 - 30.000 8% 30.001 en adelante 10% Cuadro 6.4: Datos problema propuesto 4 P ago = P recio − P recio × Descuento
5. Dado el valor de x, calcule el valor de y como resultado de la siguiente funci´on compuesta.
−x, x + 3, y= x, 10, 2
si si si si
x < −5 x ∈ [−5, 2] x ∈ (2, 5) x≥5
6. Dados tres valores enteros, correspondientes a las longitudes de un tri´angulo, determine el tipo de tri´angulo, is´osceles, escaleno, equil´atero; o si estas longitudes no corresponden a los lados de un tri´angulo. Si las longitudes de los lados son L1 , L2 y L3 , un tri´angulo se puede formar siempre y cuando s × (s − L1 ) × (s − L2 ) × (s − L3 ) > 0 s=
L1 + L2 + L3 2
92
CAP´ITULO 6. DECISIONES ANIDADAS
7. Dadas tres notas parciales de un curso que se aprueba con 3.0, calcular la nota m´ınima con la cual se aprueba el curso, teniendo en cuenta que todas las notas tienen igual porcentaje. Imprimir un mensaje de acuerdo a la nota m´ınima que debe obtener el estudiante, as´ı: “P erdi´ o el curso”, “T odavia se puede”, “N ecesita una buena nota”, “Es f a ´cil ganarla”, M ensaje : “La tiene casi ganada”, acticamente ya gan´ o”, “P r´ “M uy dif icil de perder”, “F elicitaciones Y a gan´ o”,
si si si si si si si si
N otaM in N otaM in N otaM in N otaM in N otaM in N otaM in N otaM in N otaM in
> 5,0 ∈ [4,0, 5,0] ∈ [3,5, 4,0) ∈ [3,0, 3,5) ∈ [2,0, 3,0) ∈ [1,0, 2,0) ∈ [0,1, 1,0) ≤ 0,0
N otaM in = 4 × 3,0 − (N1 + N2 + N3 ) 8. Halle los coeficientes de una ecuaci´on cuadr´atica, teniendo en cuenta todas las posibilidades, que no tenga ra´ıces reales, que no sea ecuaci´on cuadr´atica, etc. a × x2 + b × x + c es cuadr´ atica, si a 6= 0,0 √ 2−4×a×c x = −b ± b2 × , si b2 − 4 × a × c ≥ 0,0 a x∈ / R, si b2 − 4 × a × c < 0,0 9. De un estudiante se tienen 3 notas parciales. Se desea obtener la nota definitiva aplicando los porcentajes 30%, 30% y 40% respectivamente. De acuerdo a la definitiva en este curso, recibira un descuento para el proximo curso (si lo gana) o una multa (si lo pierde), de acuerdo a la siguiente tabla. Debe solicitar el valor del curso. Ver tabla 6.5.
6.2. PROBLEMAS PROPUESTOS Definitiva Descuento 0.0 - 0.9 1.0 - 1.9 2.0 - 2.9 3.0 - 3.4 10% 3.5 - 3.9 20% 4.0 - 4.4 30% 4.5 - 5.0 40%
93 Multa 40% 20% 10%
Cuadro 6.5: Datos problema propuesto 9 Def = N1 × 0,3 + N2 × 0,3 + N3 × 0,4 P recio = P recio + P recio × M ulta P recio = P recio − P recio × Descuento 10. Solicitar la fecha de nacimiento de una persona y la fecha actual en forma de aa mm dd. Si la fecha se ingresa correctamente, imprimir un mensaje si es mayor de edad o no.
A˜ nos = A˜ noActual − A˜ noN aci´o M eses = M esActual − M esN aci´o D´ıas = D´ıaActual − D´ıaN aci´o nos > 18 si A˜ si A˜ nos = 18 y M eses > 0 M ayor de edad : si A˜ nos = 18 y M eses = 0 y D´ıas ≥ 0
94
CAP´ITULO 6. DECISIONES ANIDADAS
Cap´ıtulo 7 Decisiones m´ ultiples Algunos problemas resueltos utilizando decisiones anidadas, por ejemplo, aquellos que examinan un dato de tipo entero o caracter, pueden resolverse m´as f´acilmente con decisiones m´ ultiples, porque se aumenta la claridad y facilidad para leer un c´odigo fuente, lo mismo que detectar errores y aumentar las opciones sin complicar la programaci´on. En el caso de la vida diaria, cuando se tiene un men´ u con opciones, por ejemplo un restaurante, los canales en el televisor o en un cajero electr´onico, nos encontramos con la posibilidad de elegir entre m´ ultiples (dos o m´as) alternativas. El switch (estructura de decisi´on m´ ultiple) permite definir cualquier n´ umero de bloques de instrucciones que se deben ejecutar de acuerdo al valor de una variable de tipo entero o caracter. En todos los casos, se puede escoger un solo bloque de instrucciones que se ejecutan hasta encontrar la instrucci´on break, de tal manera que los dem´as bloques de instrucciones son ignorados. Por ejemplo, si se desea hacer un programa que pueda realizar una operaci´on aritm´etica de acuerdo al valor de la variable Op, la cual generalmente ha sido le´ıda previamente, lo mismo que las variables a y b. Ver “Estructura general del switch”.
95
96
´ CAP´ITULO 7. DECISIONES MULTIPLES Estructura general del switch switch ( Op ) { case 1 : Numero break; case 2 : Numero break; case 3 : Numero break; default: Numero break; }
= a + b; = a - b; = a * b; = a / b;
Es importante tener en cuenta: El tipo de dato de la variable que se utiliza para controlar el switch, en este caso Op puede ser entero o caracter, es decir, no se aceptan datos de tipo flotante. No se aceptan rangos. En esos casos es indispensable mencionar cada caso posible en forma individual o utilizar decisiones anidadas. No es necesario que los casos posibles tengan un orden especial. Generalmente se escriben en orden por facilidad de lectura y claridad. Cada opci´on posible a considerar va precedida de la palabra case. La etiqueta default es utilizada en el caso de que ninguno de los dem´as casos coincidan con la variable de control del switch. Adem´as, su uso es opcional. Es decir, muchas veces no se escribe, y cuando aparece, a pesar de ser posible su ubicaci´on en cualquier lugar entre los casos posibles, se recomienda escribirla al final. Si no se utiliza default, y ninguno de los casos es igual a la variable de control no se ejecuta ninguno de los bloques de instrucciones. La instrucci´on break es opcional al final de cada caso. Es decir, si es omitida, el control del programa contin´ ua con la siguiente opci´on
7.1. PROBLEMAS RESUELTOS
97
hasta encontrar esta instrucci´on o el final de la estructura de decisi´on m´ ultiple. Ver p´agina 110.
7.1.
Problemas resueltos
1. Programa de Geometr´ıa Anal´ıtica. Ver programa 21 “C´ alculos de Geometr´ıa Anal´ıtica”. Programa 21 - C´ alculos de Geometr´ıa Anal´ıtica #include <iostream.h> #include <math.h> // P_Mul_01 // Prototipos int double int void void void void void
Entrada_Int Entrada_Double Ver_Menu Menu Pendiente Distancia Punto_Medio Salida_Double
( ( ( ( ( ( ( (
char Msj[] char Msj[] void int Op void void void char Msj[], double Numero
void main ( void ) { int Opcion; cout << "GEOMETRIA ANALITICA!!\n"; Opcion = Ver_Menu ( ); Menu ( Opcion ); }
); ); ); ); ); ); ); );
´ CAP´ITULO 7. DECISIONES MULTIPLES
98
Este programa ejecuta la funci´on Ver_Menu el cual devuelve un valor de tipo entero que se almacenar´a en la variable Opcion, la cual alimenta la funci´on Menu. Continuaci´ on programa 21 int Ver_Menu ( void ) { int Numero; cout << "1. Pendiente de recta " << endl; cout << "2. Distancia entre dos puntos " << endl; cout << "3. Coordenadas del punto medio " << endl; cout << endl; Numero = Entrada_Int ( "Elija una opcion: " ); cout << endl; return Numero; }
La funci´on Ver_Menu se encarga de capturar el valor que el usuario ingresa por teclado. Para poder ingresar este valor, el usuario debe conocer las diferentes opciones. Utiliza la funci´on Entrada_Int de la p´agina 44. La funci´on Menu recibe un valor que dentro de esta funci´on ser´a llamado Op y se encargar´a de controlar el switch. De acuerdo al valor obtenido har´a el llamado a la funci´on que corresponda.
7.1. PROBLEMAS RESUELTOS
99
Continuaci´ on programa 21 void Menu ( int Op ) { switch ( Op ) { case 1: Pendiente ( ); break; case 2: Distancia ( ); break; case 3: Punto_Medio ( ); } }
Continuaci´ on programa 21 void Pendiente ( void ) { double X1, Y1, X2, Y2, M; X1 Y1 X2 Y2
= = = =
Entrada_Double Entrada_Double Entrada_Double Entrada_Double
( ( ( (
"X1: "Y1: "X2: "Y2:
" " " "
); ); ); );
cout << endl; if ( X1 != X2 ) { M = ( Y2 - Y1 ) / ( X2 - X1 ); Salida_Double ( "La pendiente es: ", M ); }
La funci´on Pendiente se encarga de calcular la pendiente de la recta que pasa por los puntos (X1 ,Y1 ) y (X2 ,Y2 ), si existe. En caso de
´ CAP´ITULO 7. DECISIONES MULTIPLES Continuaci´ on programa 21
100
else { cout << "La pendiente NO EXISTE!!\n"; } }
ser una l´ınea vertical, donde la pendiente no existe, imprime en pantalla un mensaje que lo indica. Utiliza las funciones Entrada_Double y Salida_Double de las p´aginas 47 y 48, respectivamente. P endiente =
Y2 − Y1 , si X1 6= X2 X2 − X1 N o existe, si X1 = X2
Continuaci´ on programa 21 void Distancia ( ) { double X1, Y1, X2, Y2, Dist; X1 Y1 X2 Y2
= = = =
Entrada_Double Entrada_Double Entrada_Double Entrada_Double
( ( ( (
"X1: "Y1: "X2: "Y2:
" " " "
); ); ); );
Dist = sqrt ( pow ( X2 - X1, 2.0 ) + pow ( Y2 - Y1, 2.0 ) ); Salida_Double }
( "\nLa distancia es: ", Dist );
7.1. PROBLEMAS RESUELTOS
101
La funci´on Distancia calcula la distancia entre los dos puntos despu´es de leer las coordenadas. p Distancia = (X2 − X1 )2 + (Y2 − Y1 )2 Continuaci´ on programa 21 void Punto_Medio ( ) { double X1, Y1, X2, Y2, X_M, Y_M; X1 Y1 X2 Y2
= = = =
Entrada_Double Entrada_Double Entrada_Double Entrada_Double
( ( ( (
"X1: "Y1: "X2: "Y2:
" " " "
); ); ); );
X_M = ( X1 + X2 ) / 2.0; Y_M = ( Y1 + Y2 ) / 2.0; cout << endl; cout << "Coordenadas del punto medio: " << X_M << " , " << Y_M << endl; }
La funci´on Punto_Medio calcula las coordenadas del punto medio entre los dos puntos especificados. XM =
X1 + X2 2
YM =
Y1 + Y2 2
´ CAP´ITULO 7. DECISIONES MULTIPLES
102
2. Valor de la cuota fija de un pr´estamo en una entidad financiera, conociendo el monto (M), el plazo en meses (P) y la tasa de inter´es anual. M × I × (I + 1)P C= (I + 1)P − 1 Tenga en cuenta que I corresponde a la tasa de inter´es mensual. Ver programa 22 “Valor de la cuota fija de un pr´estamo”. Programa 22 - Valor de la cuota fija de un pr´ estamo #include <iostream.h> #include <math.h> // P_Mul_02 // Prototipos int double int int double void
Entrada_Int Entrada_Double Ver_Menu Elegir_Plazo Calc_Cuota Salida_Double
( ( ( ( ( (
char Msj[] ); char Msj[] ); void ); int Op ); double Mnt, int Pla, double I_Anl ); char Msj[], double Numero );
void main ( void ) { double Monto, Int_Anual, Int_Mensual, Cuota; int Plazo, Opcion; cout << "CUOTA MENSUAL DE UN CREDITO!!\n";
Este programa permite calcular el valor de la cuota mensual de un cr´edito en una entidad financiera conociendo el monto, el inter´es anual y el plazo. Para la entrada de los datos Monto e Int_Anual se utiliza la funci´on Entrada_Double de la p´agina 47. Plazo es seleccionado de un
7.1. PROBLEMAS RESUELTOS
103
Continuaci´ on programa 22 Monto
= Entrada_Double ( "Monto del credito
Opcion
= Ver_Menu
(
: " ); );
Int_Anual = Entrada_Double ( "Interes anual (20% = 20): " ); Plazo Cuota
= Elegir_Plazo = Calc_Cuota
Salida_Double
( Opcion ( Monto, Plazo, Int_Anual
); );
( "Cuota mensual: ", Cuota
);
}
men´ u usando la funci´on Elegir_Plazo, el cual devuelve un valor que es almacenado en la variable Plazo. La funci´on Calc_Cuota recibe los datos necesarios y retorna el resultado en la variable Cuota. Finalmente se utiliza la funci´on Salida_Double de la p´agina 48. Continuaci´ on programa 22 int Ver_Menu ( void ) { int Numero; cout << endl; cout cout cout cout cout
<< << << << <<
"1. "2. "3. "4. "5.
12 24 36 48 60
meses meses meses meses meses
" " " " "
<< << << << <<
endl; endl; endl; endl; endl;
´ CAP´ITULO 7. DECISIONES MULTIPLES Continuaci´ on programa 22
104
Numero = Entrada_Int ( "\nElija una opcion: " ); cout << endl; return
Numero;
}
La funci´on Ver_Menu se encarga de mostrar las opciones en la pantalla y leer el n´ umero digitado por el usuario. Este n´ umero le´ıdo se regresa a la funci´on que llam´o a Ver_Menu. Continuaci´ on programa 22 int Elegir_Plazo ( int Op ) { int Numero; switch ( Op ) { case 1 : Numero break; case 2 : Numero break; case 3 : Numero break; case 4 : Numero break; default: Numero } return Numero; }
= 12; = 24; = 36; = 48; = 60;
7.1. PROBLEMAS RESUELTOS
105
La funci´on Elegir_Plazo recibe como par´ametro la opci´on elegida por el usuario en la funci´on Ver_Menu. Su objetivo es asignar el valor correspondiente a la variable Numero, valor que es retornado. Continuaci´ on programa 22 double Calc_Cuota ( double Mnt, int Pla, double I_Anl ) { double Numero, Int_Mes, Aux; Int_Mes = I_Anl /100.0 / 12.0; Aux = pow ( Int_Mes + 1.0 , Pla ); Numero = Mnt * Int_Mes * Aux / ( Aux - 1.0 ); return Numero; }
Calc_Cuota recibe los datos correspondientes al monto, plazo y tasa de inter´es anual, para calcular y retornar el valor de la cuota mensual del cr´edito. 3. Identificaci´on de caracteres Ver programa 23 “Identificaci´ on de caracteres”. Programa 23 - Identificaci´ on de caracteres #include <iostream.h> // P_Mul_03 // Prototipos void Verificar ( char Car ); void Casos ( char Op );
´ CAP´ITULO 7. DECISIONES MULTIPLES
106
Este programa lee un caracter el cual ser´a almacenado en la variable Car. Con este valor se hace el llamado a la funci´on Verificar. Continuaci´ on programa 23 void main ( void ) { char Car; cout << "IDENTIFICACION DE CARACTERES!!\n"; cout << "Digite un caracter cin
: " ;
>> Car;
cout << endl; cout << "El caracter a procesar es : " << Car << endl; cout << "El caracter es : " ; Verificar
( Car );
}
Continuaci´ on programa 23 void Verificar ( char Car ) { if ( Car >= ’0’ && Car <= ’9’ ) { Casos ( Car ); }
La funci´on Verificar recibe como par´ametro el caracter ingresado por el usuario y determina si corresponde a un d´ıgito, una letra o un s´ımbolo. En caso se que el caracter sea un d´ıgito, llamar´a a la funci´on Casos.
7.1. PROBLEMAS RESUELTOS
107
Continuaci´ on programa 23 else { if ( Car >= ’A’ && Car >= ’Z’ || Car >= ’a’ && Car >= ’z’ ) { cout << "Es una letra"; } else { cout << "Es un simbolo"; } } }
Continuaci´ on programa 23 void Casos ( char Op ) { switch ( Op ) { case ’0’ : cout << break; case ’1’ : cout << break; case ’2’ : cout << break; case ’3’ : cout << break; case ’4’ : cout << break; case ’5’ : cout << break;
"Cero
";
"Uno
";
"Dos
";
"Tres
";
"Cuatro"; "Cinco ";
´ CAP´ITULO 7. DECISIONES MULTIPLES Continuaci´ on programa 23
108
case ’6’ : cout << break; case ’7’ : cout << break; case ’8’ : cout << break; default : cout <<
"Seis
";
"Siete "; "Ocho
";
"Nueve ";
} }
La funci´on Casos imprime en la pantalla el texto correspondiente al n´ umero que se recibe como par´ametro. 4. Resultado de la operaci´on de dos n´ umeros Ver programa 24 “Resultado de la operaci´ on de dos n´ umeros”. Programa 24 - Resultado de la operaci´ on de dos n´ umeros #include <iostream.h> // P_Mul_04 // Prototipos int char int void
Entrada_Int Entrada_Char Operacion Salida_Int
( ( ( (
char char int char
Msj[] ); Msj[] ); Numero1, char Op, int Numero2 ); Msj[], int Numero );
Este programa lee desde el teclado dos enteros y un caracter que especifica la operaci´on aritm´etica que debe realizar. Efect´ ua el c´alculo y muestra los resultados. Utiliza las funciones Entrada_Int explicada en la p´agina 44 y Entrada_Char.
7.1. PROBLEMAS RESUELTOS
109
Continuaci´ on programa 24 void main ( void ) { int Num1, Num2, Resultado; char Operador; cout << "MENU DE OPERACIONES!!\n"; Num1 Num2
= Entrada_Int = Entrada_Int
( "Primer numero ( "Segundo numero
: " : "
); );
Operador
= Entrada_Char ( "Operador
: "
);
Resultado
= Operacion
( Num1, Operador, Num2
);
Salida_Int ( "El resultado es : ", Resultado }
Continuaci´ on programa 24 char Entrada_Char ( char Msj[] ) { char Caracter; cout << Msj; cin >> Caracter; return }
Caracter;
);
´ CAP´ITULO 7. DECISIONES MULTIPLES
110
La funci´on Entrada_Char, muy similar a las funciones de entrada de datos usados a lo largo del libro. Continuaci´ on programa 24 int Operacion { int Numero;
( int Numero1, char Op, int Numero2 )
switch ( Op ) { case ’+’ : Numero = Numero1 + Numero2; break; case ’-’ : Numero = Numero1 - Numero2; break; case ’*’ : case ’.’ : case ’x’ : case ’X’ : Numero = Numero1 * Numero2; break; case ’/’ : Numero = Numero1 / Numero2; break; default : cout << "ERROR!!" << endl; Numero = 0; } return Numero; }
La funci´on Operacion recibe como par´ametros el primer n´ umero, el caracter que identifica la operaci´on aritm´etica a realizar y el segundo entero. Realiza el c´alculo y retorna el resultado en la variable Numero. Es de anotar que algunas opciones de la estructura switch no llevan la instrucci´on break. En otras palabras, el control del programa contin´ ua con las siguientes instrucciones hasta encontrar un breako el final del switch. Ver p´agina 97. Finalmente se utiliza la funci´on Salida_Int de la p´agina 45.
7.1. PROBLEMAS RESUELTOS
111
5. C´alculo del valor de la pensi´on Ver programa 25 “C´ alculo del valor de la pensi´ on”. Programa 25 - C´ alculo del valor de la pensi´ on #include <iostream.h> // P_Mul_05 // Prototipos int char double double double double void
Entrada_Int Entrada_Char Seleccion1 Seleccion2 Seleccion3 Calculo
( ( ( ( ( (
char Msj[] char Msj[] int Op int Gr char Op double Cargo, double Costo, double Transp Salida_Double ( char Msj[], double Numero
); ); ); ); ); ); );
void main ( void ) { int Estrato, Grado; char Transp; double Cargo_Fijo, Costo_Grado, Transporte, Pago; cout << "COSTO MATRICULA!!\n" ;
Este programa calcula el costo de la pensi´on en un colegio, conociendo el grado, el estrato social y si tiene o no sobrecosto por el transporte. Utiliza las funciones Entrada_Int y Entrada_Char ya explicados.
´ CAP´ITULO 7. DECISIONES MULTIPLES Continuaci´ on programa 25
112
Grado Estrato Transp Cargo_Fijo Costo_Grado Transporte Pago
= = = = = = =
Entrada_Int Entrada_Int Entrada_Char Seleccion1 Seleccion2 Seleccion3 Calculo
( ( ( ( ( ( (
"Grado : " ); "Estrato : " ); "Transporte? (S/N) : " ); Estrato ); Grado ); Transp ); Cargo_Fijo, Costo_Grado, Transporte ); Salida_Double ( "El costo de la matricula es: ", Pago ); }
Continuaci´ on programa 25 double Seleccion1 ( int Op ) { double Numero; switch ( Op ) { case 1 : Numero break; case 2 : Numero break; case 3 : Numero break; case 4 : Numero break;
= 6000; = 8000; = 10000; = 12000;
La funci´on Seleccion1 se encarga de retornar el valor del cargo fijo conociendo el estrato social, utilizando una estructura de decisi´on m´ ultiple.
7.1. PROBLEMAS RESUELTOS Continuaci´ on programa 25 case 5 : Numero = 14000; break; case 6 : Numero = 16000; break; default: cout << "ERROR!!" << endl; Numero = 0; } return Numero; }
Continuaci´ on programa 25 double Seleccion2 { double Numero; if ( Gr < 5 ) { Numero = 20000; } else { if ( Gr < 10 ) { Numero = 30000; } else { Numero = 40000; } }
( int Gr )
113
´ CAP´ITULO 7. DECISIONES MULTIPLES Continuaci´ on programa 25
114
return Numero; }
La funci´on Seleccion2 se encarga de retornar el costo seg´ un el grado recibido como par´ametro, utilizando una estructura de decisi´on anidada. Continuaci´ on programa 25 double Seleccion3 { double Numero;
( char Op )
if ( Op == ’S’ || Op == ’s’ ) { Numero = 35000; } else { Numero = 0; } return Numero; }
La funci´on Seleccion3 se encarga de retornar el costo del transporte de acuerdo a la opci´on digitada por el usuario. Utiliza una estructura de decisi´on simple.
7.2. PROBLEMAS PROPUESTOS
115
Continuaci´ on programa 25 double Calculo ( double Cargo, double Costo, double Transp ) { double Numero; Numero = Cargo + Costo + Transp; return Numero; }
La funci´on Calculo se encarga de realizar la sumatoria de los valores que componen el valor de la pensi´on. Los resultados se pueden ver en la pantalla gracias al llamado a la funci´on Salida_Double.
7.2.
Problemas propuestos
1. Dados el sueldo actual y la categor´ıa de un empleado, calcular el aumento correspondiente de acuerdo a la tabla 7.1. Categor´ıa 1 2 3 4
Porcentaje de Aumento 12% 10% 8% 6%
Cuadro 7.1: Datos problema propuesto 1 SueldoN uevo = SueldoActual + SueldoActual × P orcentajeAumento
´ CAP´ITULO 7. DECISIONES MULTIPLES
116
2. En una empresa se le hace descuento a los empleados por concepto de ahorro, de acuerdo al estrato social en que vive, con base en la tabla 7.2. Caclcule e imprima el valor a descontar. Estrato 1 2 3 4 5 6
Porcentaje de Descuento 2% 2% 4% 6% 8% 10%
Cuadro 7.2: Datos problema propuesto 2 Descuento = SueldoActual × P orcentajeDescuento
3. Se ingresa el n´ umero de ejes de un veh´ıculo. Hallar el valor que debe pagar por peaje, de acuerdo a la tabla 7.3: No. Ejes 2 3 4 5 6
Peaje 4.000 5.000 7.000 11.000 15.000
Cuadro 7.3: Datos problema propuesto 3
4. De un empleado se conoce la categor´ıa 1, 2, 3 ´o 4 y el sueldo b´asico. El empleado posee una bonificaci´on y un descuento de acuerdo a la tabla 7.4.
7.2. PROBLEMAS PROPUESTOS Categor´ıa 1 2 3 4
117
Bonificaci´ on 15% 10% 8% 0%
Descuento 2.0% 1.5% 1.0% 0.0%
Cuadro 7.4: Datos problema propuesto 4 P ago = SActual + SActual × Bonif icaci´ on − SActual × Descuento
5. Calcular el pago de la comisi´on sobre las ventas a un vendedor de acuerdo al tipo de vendedor como est´a en la tabla 7.5. Tipo de vendedor A B C D
Comision 8% 6% 4% 2%
Cuadro 7.5: Datos problema propuesto 5 Comisi´ on = V entas × P orcentajeComisi´on
6. En un lavautos se cobra el servicio de la lavada de acuerdo al tipo de veh´ıculo. En caso de que el carro tenga 8 a˜ nos o m´as de antig¨edad, el costo se incrementa un 20%. Solicitar el a˜ no actual, el modelo y el tipo de veh´ıculo. Tenga en cuenta la tabla 7.6.
´ CAP´ITULO 7. DECISIONES MULTIPLES
118
Tipo de veh´ıculo peque˜ no Automovil mediano de lujo sencillo Campero de lujo cabina sencilla Camioneta doble cabina
Valor lavada 4.000 5.000 6.000 5.000 8.000 6.000 8.000
Cuadro 7.6: Datos problema propuesto 6
7. Se realiz´o un estudio para determinar el costo diario promedio de hospitalizaci´on de un paciente, en d´olares, de acuerdo al tipo de enfermedad que sufre el paciente. Adem´as, se pudo establecer que si el paciente tiene una edad entre 10 y 25 a˜ nos de edad, el costo promedio diario se incrementa en un 15%. Con base en la siguiente tabla, calcule e imprima el costo total que se le cobrar´ıa a un paciente, conociendo el n´ umero de d´ıas que permanecer´a hospitalizado. Exprese el resultado en pesos, con una tasa de cambio de $2.500. Ver tabla 7.7. Tipo de Enfermedad 1 2 3 4
Costo promedio diario en d´ olares 28 26 18 34
Cuadro 7.7: Datos problema propuesto 7 CostoHospital = N o.Dias × CostoDiario ½ CostoHospital × 1,15, si Edad ∈ [10, 25] IncrementoEdad = 0, si Edad ∈ / [10, 25] Costopesos = (CostoHospital + IncrementoEdad ) ∗ 2,500
7.2. PROBLEMAS PROPUESTOS
119
8. Calcular el valor de la matr´ıcula en la Universidad, de acuerdo al estrato social, al estado civil, y al n´ umero de materias, de acuerdo a la tabla 7.8. Estrato 1
2
3
4 m´ as
Estado civil Casado Separado Viudo Divorciado Casado Separado Viudo Divorciado Casado Separado Viudo Divorciado Casado Separado Viudo Divorciado
Cargo fijo 15.000 30.000 20.000 25.000 25.000 40.000 30.000 35.000 35.000 50.000 40.000 45.000 50.000 80.000 65.000 70.000
Valor por materia 10.000 15.000 12.000 12.000 15.000 20.000 18.000 18.000 20.000 25.000 22.000 22.000 30.000 40.000 35.000 35.000
Cuadro 7.8: Datos problema propuesto 8 V alorM atricula = CargoF ijo + N o.M aterias × V alorM ateria
9. Un agricultor desea saber el costo de producci´on de un cultivo de acuerdo a la semilla seleccionada, conociendo el n´ umero de semillas que utilizar´a y el costo de cada semilla. El valor de cada semilla se encuentra en la tabla 7.9.
´ CAP´ITULO 7. DECISIONES MULTIPLES
120 Verdura Tomate
Tipo Chonto Ensalada
Repollo Papa Cebolla
Criolla Pastusa Salentuna Larga De huevo
Valor cada semilla 15 20 10 8 9 11 15 13
Cuadro 7.9: Datos problema propuesto 9 CostoSemillas = N o.Semillas × V alorSemilla
10. Se va a cobrar la matricula de la universidad a los estudiantes de acuerdo al estrato social, al ingreso promedio mensual de la familia y al n´ umero de materias registradas, de acuerdo a las siguientes tablas, en donde aparece el valor por materia. el cargo fijo esta indicado al terminar cada una de las tablas 7.10, 7.11, 7.12, 7.13 y 7.14. Estratos 1 y 2 No. de columnas hasta 2 de 3 a 5 m´ as de 5 0 - 400.000 18.000 15.000 12.000 400.001 - 750.000 22.000 20.000 18.000 750.001 en adelante 25.000 22.000 20.000 Ingreso promedio
Cargo fijo $ 20.000 Cuadro 7.10: Datos problema propuesto 10 (a)
7.2. PROBLEMAS PROPUESTOS Estrato 3 No. de columnas Ingreso promedio hasta 2 de 3 a 5 m´ as de 5 0 - 500.000 22.000 20.000 18.000 500.001 - 800.000 28.000 24.000 20.000 800.001 - 1.000.000 35.000 30.000 25.000 1.000.001 en adelante 40.000 35.000 30.000 Cargo fijo $ 30.000 Cuadro 7.11: Datos problema propuesto 10 (b)
Estrato 4 No. de columnas Ingreso promedio hasta 2 de 3 a 5 m´ as de 5 0 - 600.000 35.000 30.000 25.000 600.001 - 1.000.000 45.000 40.000 35.000 1.000.001 - 2.000.000 55.000 50.000 45.000 2.000.001 en adelante 65.000 60.000 55.000 Cargo fijo $ 80.000 Cuadro 7.12: Datos problema propuesto 10 (c)
Estratos 5 y 6 Ingreso promedio 0 - 1.000.000 1.000.001 - 2.000.000 2.000.001 - 3.000.000 3.000.001 en adelante
No. de columnas hasta 2 de 3 a 5 m´ as de 5 45.000 40.000 35.000 55.000 50.000 45.000 65.000 60.000 55.000 75.000 70.000 65.000
Cargo fijo Estratos 5 $ 100.000 Cargo fijo Estratos 6 $ 120.000 Cuadro 7.13: Datos problema propuesto 10 (d)
121
122
´ CAP´ITULO 7. DECISIONES MULTIPLES En todos los casos, si el valor del semestre cuesta m´as del 30% del ingreso familiar promedio, se tendra derecho a un descuento de acuerdo a la siguiente tabla: Estrato 1 2 3 4 5 6
Descuento 30% 25% 20% 15% 12% 10%
Cuadro 7.14: Datos problema propuesto 10 (e) V alorM atricula = CargoF ijo + N o.M aterias × V alorM ateria Descuento = V alorM atricula × P orcentajeDescuento P ago = V alorM atricula − Descuento Imprimir el valor de la matr´ıcula sin descuento. Si tiene descuento, imprimir el valor a pagar.
Cap´ıtulo 8 Ciclo do - while En muchas ocasiones, existen problemas que no se pueden solucionar con las estructuras de control estudiadas hasta ahora. Por ejemplo, si se desea imprimir los primeros n enteros positivos, donde n puede cambiar entre una ejecuci´on y otra. En vista de que el valor de n no es conocido, no se puede construir un programa secuencial que resuelva todos los casos posibles. Para lograrlo se necesitan las estructuras de repetici´on. Un ciclo es una estructura de control que permite repetir la ejecuci´on de algunas instrucciones. Con el fin de controlar el n´ umero apropiado de veces que se ejecutan las instrucciones que hacen parte de ciclo, se usa una condici´on de tal manera que se repitan mientras sea verdadera. Imagine que el programa que quiere imprimir los primeros n enteros positivos se quiere ejecutar para un valor de n = 1000. Si se quiere hacer este programa en forma secuencial, ser´ıa necesario escribir 1000 veces la instrucci´on que imprime. Ver “Lista secuencial de 1000 enteros”. Utilizando ciclos, el programa ser´ıa notablemente m´as corto y eficiente (Ver el programa de la p´agina 126). Por otra parte, existen dos clases de ciclos, de acuerdo a la posici´on donde se escriba la condici´on. Estos pueden ser condicionados al comienzo o al final. Los ciclos condicionados al comienzo se pueden encontrar de dos formas, el while y el for, mientras que para el ciclo condicionado al final solo existe una forma llamada do - while. 123
CAP´ITULO 8. CICLO DO - WHILE Lista secuencial de 1000 enteros
124
cout << " cout << " cout << "
1 \n"; 2 \n"; 3 \n"; . . . cout << " 998 \n"; cout << " 999 \n"; cout << "1000 \n";
Ver “Estructura general del ciclo do - while”. Estructura general del ciclo do - while Instrucciones antes del ciclo do { Instrucciones dentro del ciclo } while ( Condicion ); Instrucciones despues del ciclo
De la estructura general del ciclo do - while se debe tener en cuenta: Dentro de las instrucciones que se ejecutan antes del ciclo, puede encontrarse una que asigne un valor inicial a una variable que sirva para controlar el ciclo, es decir, esta variable ser´a utilizada en la condici´on que permite finalizar el ciclo. El grupo de instrucciones que se encuentran dentro del ciclo es el objetivo de esta estructura de repetici´on. Una de estas instrucciones, generalmente es el incremento o decremento de la variable de control. Esta
8.1. PROBLEMAS RESUELTOS
125
alteraci´on del valor de la variable de control se utiliza para que en alg´ un momento la condici´on deje de ser verdadera y se finalice el ciclo. La condici´on es una expresi´on l´ogica que tiene un valor de verdad que puede ser Falso o Verdadero. Igualmente, puede ser una expresi´on aritm´etica con valor de cero (Falso) o diferente de cero (Verdadero). Todas las instrucciones que hacen parte del ciclo se ejecutan al menos la primera vez. Las posibles repeticiones depender´an del resultado de evaluar la condici´on. De forma similar a las decisiones, los ciclos pueden anidarse de tal manera que un ciclo est´e completamente dentro de otro. Una aplicaci´on del ciclo condicionado al final es validar datos de entrada, es decir, impedir la entrada de informaci´on no v´alida, con el fin de minimizar los errores en la entrada de datos. En este caso, este tipo de ciclos no tiene inicializaci´on, ni incremento, y su condici´on depende u ´nicamente de un dato que se ingresa dentro de las instrucciones del ciclo. Una pasada por el grupo de instrucciones que componen el ciclo se conoce con el nombre de iteraci´on.
8.1.
Problemas resueltos
1. Imprimir un listado con los primeros 1.000 enteros positivos. Ver programa 26 “Lista de mil enteros positivos”. Este programa imprime 1.000 n´ umeros enteros (desde 1 hasta 1.000), donde la variable de control (I) se incrementa en una unidad cada vez que pasa por la instrucci´on I++;. Observe que el valor inicial de I es cero, pero el incremento se realiza antes de utilizar al m´etodo Salida_Int, lo que permite que inicie la impresi´on a partir de 1. Si el incremento se hiciera despu´es del llamado al m´etodo Salida_Int, se imprimir´ıan desde 0 hasta 999. La condici´on (I < MAX) permite que el ciclo finalice cuando el valor de I sea igual o mayor que la constante MAX, la cual tiene predeterminado un
CAP´ITULO 8. CICLO DO - WHILE
126
Programa 26 - Lista de mil enteros positivos #include <iostream.h> // P_DoW_01 const int MAX = 1000; // Prototipos void Salida_Int ( char Msj[], int Numero ); void main ( void ) { int I; cout << "NUMEROS ENTEROS!!\n"; I = 0; do { I++; Salida_Int ( "Numero : ", I ); } while ( I < MAX ); }
8.1. PROBLEMAS RESUELTOS
127
valor de 1000. Este valor no cambiar´a durante la ejecuci´on del programa por tratarse de una constante. 2. Imprimir los n´ umeros enteros que pertenecen a un rango determinado, incluyendo los l´ımites. Ver programa 27 “Impresi´on de un rango de n´ umeros”. Programa 27 - Impresi´ on de un rango de n´ umeros #include <iostream.h> // P_DoW_02 // Prototipos int Entrada_Int ( char Msj[] ); void Salida_Int ( char Msj[], int Numero ); void main ( void ) { int I, Lim_Inf, Lim_Sup; cout << "INTERVALO!!\n"; Lim_Inf = Entrada_Int ( "Limite inferior : " ); Lim_Sup = Entrada_Int ( "Limite superior : " ); I = Lim_Inf; do { Salida_Int ( "Numero I++; } while ( I <= Lim_Sup );
: ", I );
}
En este programa la variable de control (I) se inicia con el valor correspondiente al l´ımite inferior. Es de anotar que la condici´on requiere el
CAP´ITULO 8. CICLO DO - WHILE
128
uso del operador <=, debido a la necesidad de incluir el l´ımite superior. 3. Imprimir los n´ umeros enteros que pertenecen a un rango determinado, incluyendo los l´ımites, validando que el l´ımite Superior sea mayor que el l´ımite inferior. Ver programa 28 “Impresi´ on de un rango de n´ umeros con validaci´on”. Programa 28 - Impresi´ on de un rango de n´ umeros con validaci´ on #include <iostream.h> // P_DoW_03 // Prototipos int Entrada_Int ( char Msj[] ); void Salida_Int ( char Msj[], int Numero ); void main ( void ) { int I, Lim_Inf, Lim_Sup; cout << "INTERVALO VALIDADO!!\n";
Este programa permite utilizar un ciclo do - while para validar una entrada. En el caso de la entrada del l´ımite superior, deber´a repetir la entrada mientras sea menor o igual que el l´ımite inferior. Es decir, cuando la entrada es correcta, la entrada no se vuelve a ejecutar. Despu´es de validar la entrada del l´ımite superior, se ejecuta otro ciclo do - while donde se imprimen los elementos pertenecientes al rango especificado.
8.1. PROBLEMAS RESUELTOS
129
Continuaci´ on programa 28 Lim_Inf = Entrada_Int ( "Limite inferior : " ); do { Lim_Sup = Entrada_Int ( "Limite superior : " ); } while ( Lim_Sup <= Lim_Inf ); I = Lim_Inf; do { Salida_Int ( "Numero I++; } while ( I <= Lim_Sup );
: ", I );
}
4. Imprimir la tabla de multiplicar de un entero especificado con quince renglones. Ver programa 29 “Tabla de multiplicar de un valor ingresado”. Este programa solicita la entrada del n´ umero sobre el cual se desea obtener la tabla de multiplicar. Este n´ umero se pasa como argumento a la funci´on Tabla. La funci´on Tabla genera el resultado del producto entre el n´ umero que se recibe como par´ametro (Num) y el valor de la variable de control del ciclo (I). El llamado a la funci´on Salida se hace para que la salida en pantalla sea en forma de tabla. La funci´on Salida recibe tres par´ametros, el n´ umero al que se le imprime la tabla (N), el n´ umero que cambia en cada iteraci´on (Con) y el resultado del producto de los dos anteriores (Res).
CAP´ITULO 8. CICLO DO - WHILE
130
Programa 29 - Tabla de multiplicar de un valor ingresado #include <iostream.h> // P_DoW_04 const int MAX = 15; // Prototipos int Entrada_Int ( char Msj[] ); void Tabla ( int Num ); void Salida ( int N, int Con, int Res ); void main ( void ) { int Numero; cout << "TABLA DE MULTIPLICAR!!\n"; Numero = Entrada_Int ( "Ingrese el numero: " ); Tabla ( Numero ); }
8.1. PROBLEMAS RESUELTOS
Continuaci´ on programa 29 void Tabla ( int Num ) { int I, Resultado; I = 1; do { Resultado = Num * I; Salida ( Num, I, Resultado ); I++; } while ( I <= MAX ); }
Continuaci´ on programa 29 void Salida ( int N, int Con, int Res ) { cout << N << " * " << Con << " \t= " << Res << endl; }
131
CAP´ITULO 8. CICLO DO - WHILE
132
5. Realizar una multiplicaci´on de dos n´ umeros enteros positivos, utilizando sumas u ´nicamente. Tenga en cuenta que: a×b=a | + a + a{z+ · · · + a} b veces
Ver programa 30 “Multiplicaci´ on a partir de sumas sucesivas”. Programa 30 - Multiplicaci´ on a partir de sumas sucesivas #include <iostream.h> // P_DoW_05 // Prototipos int Entrada_Int ( char Msj[] ); void Salida_Int ( char Msj[], int Numero ); void main ( void ) { int I, Numero1, Numero2, Resultado; cout << "PRODUCTO CON SUMAS!!\n"; Numero1 = Entrada_Int ( "Primer numero : " Numero2 = Entrada_Int ( "Segundo numero : "
); );
Este programa solicita por teclado los dos enteros positivos que se van a multiplicar. En este caso, se tiene una variable (I) la cual se encarga de controlar que el ciclo sea ejecutado Numero2 veces. Por otra parte, la variable Resultado se encarga de llevar un registro de la suma parcial de Numero1 I veces. Al llegar I a Numero2, Resultado tendr´a el producto de N umero1 × N umero2. Es importante resaltar que las variables de control, generalmente se incrementan o decrementan en una unidad constante, muchas veces 1. Este tipo de variables reciben el nombre de contador.
8.2. PROBLEMAS PROPUESTOS
133
Continuaci´ on programa 30 I = 0; Resultado = 0; do { Resultado += Numero1; I++; } while ( I < Numero2 ); Salida_Int ( "Producto
: ", Resultado);
}
Las variables que se incrementan o decrementan en el interior de un ciclo en forma no constante, reciben el nombre de acumulador.
8.2.
Problemas propuestos
1. Una empresa dispone de una serie de empleados, a los cuales les paga teniendo en cuenta el n´ umero de horas trabajadas. Elabore un programa que lea los datos e imprima total de horas trabajadas, valor total a pagar y promedio de horas trabajadas. P agoi = Horasi Ă&#x2014; V alori T otalHoras =
n X
Horasi
i=1
T otalP ago =
n X
P agoi
i=1
P romedio =
T otalP ago n
2. Imprimir la serie 0, 0, 1, 0, 0, 1, 0, 0, 1, con 30 elementos.
134
CAP´ITULO 8. CICLO DO - WHILE
3. Imprimir en pantalla una figura similar a la que se encuentra a continuaci´on, la cual se realiza recibiendo como par´ametro la longitud. Valide las entradas de forma tal que no se salga de la pantalla. ******* ** * * * * * * * * * * 4. Calcular la suma de 1 + 4 + 9 + 16 + 25 + · · · + n2 Suma =
n X
i2
i=1
5. Elabore una funci´on que imprima la potencia usando productos. Valide que el exponente sea positivos. P otencia = |base × base{z× · · · × base} n veces
P otencia =
n Y
base
i=1
6. Dado un tiempo en HH:MM:SS sumarle otro tiempo, repitiendo este proceso hasta que el usuario lo indique. La respueta se debe mostrar en DD, HH, MM y SS. 14h 3m 50s 12h 58m 40s Ejemplo : 1d 2h 2m 30s 7. Calcular la suma de todos los enteros que pertenezcan al intervalo [a,b]. Suma =
b X i=a
i
8.2. PROBLEMAS PROPUESTOS
135
8. Elabore un programa que imprima una tabla con los valores correspondientes a las funciones SENO, COSENO, TANGENTE, COTANGENTE, para angulos cuadrantales, medidos en grados. Ver tabla 8.1. Rad =
´ Angulo 0 90 180 270 360
Seno
Angulo × π 180
Coseno
Sen(Rad) Cos(Rad) .. .. . .
Tangente
Cotangente
T an(Rad) .. .
1 T an(Rad) .. .
Cuadro 8.1: Datos problema propuesto 8
9. Programa que genere los n´ umeros primos menores que 100. Un n´ umero n es primo s´ı y solo si sus dos u ´nicos divisores son 1 y n. P = 1, 2, 3, 5, 7, 11, 13, 17, · · · 97 10. Se ingresa el numerador y denominador de un n´ umero racional. Simplificarlo (hacer el proceso hasta que uno de los valores sea primo). 20 = 10 6 3 60 = 15 Ejemplos : 8 2 20 20 7 = 7
136
CAP´ITULO 8. CICLO DO - WHILE
Cap´ıtulo 9 Ciclo while Despu´es de conocer los detalles del ciclo do - while, es importante analizar el ciclo condicionado al comienzo llamado while, el cual se diferencia del anterior en que la condici´on se ubica al comienzo del ciclo, lo que permite la posibilidad de que las instrucciones que se encuentran dentro del ciclo no se ejecuten nunca, si en la primera evaluaci´on de la condici´on ´esta resulta falsa. Ver “Estructura general del while”. Estructura general del while Instrucciones antes del ciclo while ( Condicion ) { Instrucciones dentro del ciclo } Instrucciones despues del ciclo
De la estructura general del ciclo while se debe tener especial cuidado en no escribir el caracter ; (punto y coma) a continuaci´on del par´entesis de la condici´on porque aunque no se detecta un error de sintaxis, el programa 137
CAP´ITULO 9. CICLO WHILE
138
en su ejecuci´on puede hacer cosas diferentes a las que el programador ha planeado. Por ejemplo, si la condici´on es verdadera, puede terminar en un ciclo infinito. Si la condici´on es falsa, pasa al siguiente rengl´on y ejecuta el bloque de instrucciones una sola vez.
9.1.
Problemas resueltos
1. Leer por teclado N n´ umeros enteros y encontrar el mayor. Ver programa 31 “Encontrar el mayor”. Programa 31 - Encontrar el mayor #include <iostream.h> // P_Whi_01 // Prototipos int Entrada_Int ( char Msj[] ); void Salida_Int ( char Msj[], int Numero ); void main ( void ) { int I, N, Numero, Mayor; cout << "ENCONTRAR EL MAYOR!!\n"; I = 1; N
= Entrada_Int ( "Cantidad ?
: " );
Salida_Int ( "Numero ", I ); Numero = Entrada_Int ( "Ingrese : " ); Mayor
= Numero;
9.1. PROBLEMAS RESUELTOS
139
Continuaci´ on programa 31 while ( I < N ) { I++; Salida_Int ( "Numero ", I ); Numero = Entrada_Int ( "Ingrese : " ); if ( Numero > Mayor ) { Mayor = Numero; } }; Salida_Int ( "El mayor es : ", Mayor); }
Este programa lee un valor para la variable N de tal manera que sea especificado el n´ umero de enteros a leer por el teclado. A continuaci´on se lee un n´ umero (el primero de ellos). Este se asume como el mayor de todos. Luego, mediante un ciclo while se leen los restantes. En caso de que un n´ umero ingresado en la variable Numero sea mayor que el valor de Mayor, entonces, ser´a asignado a Mayor el valor de Numero. 2. Determinar el n´ umero de pares e impares de un conjunto de N n´ umeros enteros aleatorios dentro de un intervalo determinado. Ver programa 32 “N´ umero de pares e impares”. Programa 32 - N´ umero de pares e impares #include <iostream.h> #include <stdlib.h> // P_Whi_02
CAP´ITULO 9. CICLO WHILE
140
Continuaci´ on programa 32 // Prototipos int Entrada_Int ( char Msj[] ); int Azar_Int ( int Inf, int Sup ); void Salida_Int ( char Msj[], int Numero ); void main ( void ) { int I, Lim_Inf, Lim_Sup, N, N_Par, N_Impar, Numero; randomize(); cout << "NUMEROS AL AZAR!!\n"; N_Par = 0; N_Impar = 0; Lim_Inf = Entrada_Int Lim_Sup = Entrada_Int N = Entrada_Int
( "Limite inferior : " ); ( "Limite superior : " ); ( "Cantidad ? : " );
I = 1; while ( I <= N ) { Numero = Azar_Int ( Lim_Inf, Lim_Sup ); if ( Numero % 2 == 0 ) { N_Par++; } else { N_Impar++; }
9.1. PROBLEMAS RESUELTOS
141
Continuaci´ on programa 32 Salida_Int ( "Azar ", I ); Salida_Int ( "Numero I++; }; Salida_Int ( "Pares Salida_Int ( "Impares
: ", Numero );
: ", N_Par ); : ", N_Impar );
}
En este programa se utiliza la biblioteca stdlib.h en la cual se encuentran entre otras, las funciones para el manejo de n´ umeros aleatorios. Los l´ımites inferior y superior del intervalo, se leen por el teclado al igual que la cantidad de n´ umeros aleatorios a generar. La instrucci´on randomize(); se utiliza para que el programa genere siempre n´ umeros diferentes. Este procedimiento se conoce con el nombre de inicializaci´on de la semilla para los n´ umeros aleatorios. Dentro del ciclo se asignan n´ umeros enteros al azar en la variable Numero, mediante el llamado a la funci´on Azar_Int al cual se pasan como argumentos los l´ımites del rango. Para determinar si el n´ umero es par o impar es necesario calcular el m´odulo 2 (residuo de la divisi´on entera por 2). Si este resultado es cero, entonces se puede concluir que el n´ umero es par. En caso contrario, es impar. La funci´on Azar_Int se encarga de generar un n´ umero aleatorio entre 1 y el rango solicitado por los l´ımites, posteriormente a dicho n´ umero se le adiciona el l´ımite inferior para que dicho n´ umero est´e dentro del intervalo solicitado. La funci´on invierte los l´ımites si por accidente el usuario no los ingres´o correctamente.
CAP´ITULO 9. CICLO WHILE Continuaci´ on programa 32
142
int Azar_Int { int Aux;
( int Inf, int Sup )
if ( Inf > Sup ) { Aux = Inf; Inf = Sup; Sup = Aux; } return random ( Sup - Inf + 1 ) + Inf; }
3. Dadas tres notas parciales de N estudiantes y determinar cuantos ganaron, cuantos perdieron el curso y el promedio general. Ver programa 33 “Estad´ıstica sobre notas”. Programa 33 - Estad´ıstica sobre notas #include <iostream.h> // P_Whi_03 const double NUM_NOTAS = 3.0; // Prototipos int double void void
Entrada_Int Entrada_Double Salida_Int Salida_Double
( ( ( (
char char char char
Msj[] ); Msj[] ); Msj[], int Numero ); Msj[], double Numero );
9.1. PROBLEMAS RESUELTOS
143
Continuaci´ on programa 33 void main ( void ) { int I, N, N_Gan, N_Per; double Nota_1, Nota_2, Nota_3, N_Def, Prom_Gen; cout << "ESTADISTICA ESTUDIANTES!!\n"; N_Gan = 0; N_Per = 0; Prom_Gen = 0; N = Entrada_Int ( "Numero de estudiantes
: " );
I = 1; while ( I <= N ) { Salida_Int ( "\nEstudiante", I ); Nota_1 = Entrada_Double ( "Nota 1 : " ); Nota_2 = Entrada_Double ( "Nota 2 : " ); Nota_3 = Entrada_Double ( "Nota 3 : " ); N_Def = ( Nota_1 + Nota_2 + Nota_3 ) / NUM_NOTAS; Prom_Gen += N_Def; if ( N_Def >= 3.0 ) { N_Gan++; } else { N_Per++; } Salida_Double ( "Definitiva : ", N_Def ); I++; };
CAP´ITULO 9. CICLO WHILE Continuaci´ on programa 33
144
Prom_Gen /= N; cout << "\n"; Salida_Int ( "Ganaron Salida_Int ( "Perdieron Salida_Double ( "Promedio General
: ", N_Gan ); : ", N_Per ); : ", Prom_Gen );
}
Este programa lee tres notas parciales a N estudiantes. Con ellas, calcula la definitiva (N_Def) y la acumula en la variable Prom_Gen. A continuaci´on, aumenta el contador correspondiente de acuerdo a la decisi´on N_Def >= 3.0. Al terminar el ciclo, calcula el promedio general como la suma de las notas dividido entre el n´ umero de ellas y entrega los resultados. 4. Calcular el m´aximo com´ un divisor de dos enteros positivos. Ver programa 34 “M´ aximo Com´ un Divisor”. Programa 34 - M´ aximo Com´ un Divisor #include <iostream.h> // P_Whi_04 // Prototipos int int void void
Entrada_Int Calculo Salida_Int Salida_Double
( ( ( (
char int char char
Msj[] Num1, int Num2 Msj[], int Numero Msj[], double Numero
); ); ); );
9.1. PROBLEMAS RESUELTOS
145
Continuaci´ on programa 34 void main ( void ) { int Numero1, Numero2, MCD; cout << "MAXIMO COMUN DIVISOR!!\n"; Numero1 = Entrada_Int ( "Primer Numero Numero2 = Entrada_Int ( "Segundo Numero MCD
= Calculo
Salida_Int
( Numero1, Numero2
: " : "
); ); );
( "Maximo Comun Divisor : ", MCD );
}
Este programa recibe del usuario dos enteros, los cuales pasa como argumento a la funci´on Calculo en la cual se obtiene el m´aximo com´ un divisor. Continuaci´ on programa 34 int Calculo ( int Num1, int Num2 ) { int I, Aux; Aux = 1; I = ( Num1 < Num2 ) ? Num1 : Num2;
La funci´on Calculo recibe com par´ametros los dos enteros. La variable de control del ciclo (I) se inicializa con el menor. Para ello se utiliza el operador condicional ?. En este caso, a la variable I le ser´a asignado el valor de Num1 si Num1 < Num2. En caso contrario, a I se le asignar´a el valor de Num2. El MCD es el primer divisor com´ un que se encuentre al
CAP´ITULO 9. CICLO WHILE Continuaci´ on programa 34
146
while ( I >= 1 ) { if ( Num1 % I == 0 && Num2 % I == 0 ) { Aux = I; break; } I--; }; return Aux; }
utilizar un ciclo descendente. En el caso de encontrar un divisor com´ un (Num1 % I == 0 && Num2 % I == 0), se sale del ciclo. Si no hay un divisor com´ un, llegar´a a 1. El MCD encontrado es el valor a retornar. 5. Realizar programa que genere con asteriscos una figura similar a la siguiente, de longitud variable, donde la longitud es el ancho mayor. Ver “Figura de longitud 6”. Ver programa 35 “Figura”. Este programa tiene dos partes, la primera es la que dibuja la mitad superior (el n´ umero de asteriscos en aumento). La segunda parte es la que dibuja la otra mitad. En las dos partes se utilizan ciclos anidados, es decir, un ciclo est´a en el interior de otro. Es decir, por cada iteraci´on del ciclo exterior, el interno deber´a ejecutarse completamente.
9.1. PROBLEMAS RESUELTOS Figura de longitud 6 * ** *** **** ***** ****** ***** **** *** ** *
Programa 35 - Figura #include <iostream.h> // P_Whi_05 // Prototipo int Entrada_Int ( char Msj[] ); void main ( void ) { int I, J, N; cout << "DIBUJO!!\n"; N = Entrada_Int ( "Longitud: " );
147
CAP´ITULO 9. CICLO WHILE
148
Continuaci´ on programa 35 I = 1; while ( I <= N ) { J = 1; while ( J <= I ) { cout << ( "*" ); J++; } cout << "\n"; I++; } I = 1; while ( I <= N ) { J = N - I; while ( J >= 1 ) { cout << ( "*" ); J--; } cout << "\n"; I++; } }
9.2. PROBLEMAS PROPUESTOS
9.2.
149
Problemas propuestos
1. Halle la suma de 2 + 4 + 6 + 8 + · · · + 2 × n, para n, entero positivo.
Suma =
n X
2×i
i=1
2. Lea un conjunto de datos de tipo char. Debe imprimir la cantidad de letras, d´ıgitos y otros caracteres. La entrada termina cuando es presionada <Esc>. El c´odigo ASCII asociado a la tecla <Esc> es el 27. 3. Crear un cuadrado en la pantalla con el caracter *, indicando las el ancho y el alto. Tenga en cuenta el tama˜ no de la pantalla. *********** * * * * * * * * * * *********** 4. Imprimir en pantalla una figura similar a la que se encuentra a continuaci´on de manera que pueda recibir el ancho y el alto. Valide las entradas de forma que no se vaya a salir de la pantalla. Utilice una variable llamada tipo, la cual, si es 1, hace que se dibujen u ´nicamente los bordes, pero si es 0, el tri´angulo debe ser relleno. * ** * * * * * * ****** Tipo 1
* ** *** **** ***** ****** Tipo 0
CAP´ITULO 9. CICLO WHILE
150
5. Dibuje en pantalla la siguiente figura, dada la longitud a lo ancho (incluye los extremos). Valide las entradas de forma que no se vaya a salir de la pantalla. Si el ancho es impar, debe terminar en un solo caracter. ****** * * **
******* * * * * * Impar
Par
6. Dibujar una l´ınea de tama˜ no n con el caracter -. En los extremos debe escribir el caracter *, lo mismo que al completar las medidas n1 y n2 , contando desde el extremo izquierdo. Todas las medidas incluyen los extremos. ∗ − − − − ∗} − − − − ∗ − − − − − ∗ | − − − {z n1 | {z } n2 {z } | n
7. Determinar el coseno de x, a partir de la siguiente serie (en radianes), para 10 iteraciones: cos(x) ≈ 1 −
x2 x4 x6 + − + ··· 2! 4! 6!
9 X x2×i cos(x) ≈ (−1)i × (2 × i)! i=0
8. Halle el elemento de la serie Fibonacci para n t´erminos. La serie Fibonacci es: 1, 1, 2, 3, 5, 8, 13, 21.... Recuerde que Elementon = Elementon−1 + Elementon−2 9. Halle 10 t´erminos de la secuencia: 2, 3, 8, 30, 144, 840, · · ·, donde Elementon = n! + (n − 1)!
9.2. PROBLEMAS PROPUESTOS 10. Imprima el tri´angulo de Pascal para un n menor o igual a 7. 1 1 1 1 1 1
1 2 1 3 3 1 4 6 4 5 10 10 ...
1 5
1
151
152
CAP´ITULO 9. CICLO WHILE
Cap´ıtulo 10 Ciclo for Otra forma muy com´ un de utilizar los ciclos es la estructura for, la cual hace parte de los ciclos condicionados al comienzo. Este ciclo agrupa en una sola l´ınea los tres elementos b´asicos de cualquier estructura de repetici´on (inicializaci´on, condici´on e incremento), facilitando la programaci´on. Ver “Estructura general del for”. Estructura general del for Instrucciones antes del ciclo for ( Inicializacion ; Condicion ; Incremento ) { Instrucciones dentro del ciclo } Instrucciones despues del ciclo
De la estructura general del ciclo for se debe tener en cuenta:
153
CAP´ITULO 10. CICLO FOR
154 El orden de ejecuci´on es el siguiente: 1. Instrucciones antes del ciclo 2. Inicializaci´on 3. Condici´on 4. Instrucciones dentro del ciclo 5. Incremento
6. Paso 3 mientras sea verdadera la condici´on 7. Instrucciones despu´es del ciclo Como se trata de un ciclo condicionado al comienzo, es posible que el grupo de instrucciones dentro del ciclo no se ejecute. Generalmente los tres elementos b´asicos se escriben en cualquier utilizaci´on del ciclo for. Sin embargo, estos elementos son opcionales. En caso de omitirse alguno de estos elementos, se debe reservar el espacio que ocupar´ıa en condiciones normales. Por ejemplo: for ( ; Condicion ; Incremento ) for ( Inicializacion ; Condicion ; ) for ( ; Condicion ; ), entre otras. Si la instrucci´on que se omite es la inicializaci´on, quiere decir que dentro de las instrucciones que se ejecutan antes del ciclo se encuentra el valor inicial de la variable de control. Por otra parte, si lo que se omite es el incremento, se asume que ´este deber´a estar en el grupo de instrucciones dentro del ciclo. Si se omite la condici´on, el ciclo ser´a infinito o tiene un llamado a la instrucci´on break;, normalmente asociada a una decisi´on. Esta instrucci´on break; finaliza el ciclo y es aplicable a los otros tipos de estructuras repetitivas. De manera similar a la instrucci´on break;, se puede utilizar continue; para que ignore las instrucciones siguientes dentro del ciclo. El uso de esta instrucci´on obliga a ejecutar el incremento y a continuaci´on verificar la condici´on. De igual manera, se puede utilizar en los ciclos do - while y while, el paso es directo a la verificaci´on de la condici´on, dejando a responsabilidad del usuario el incremento.
10.1. PROBLEMAS RESUELTOS
155
Al igual que en el ciclo while, se debe tener cuidado de no escribir el s´ımbolo ; (punto y coma) al terminar la l´ınea correspondiente al ciclo for porque tiene las mismas implicaciones. Ver p´agina 137
10.1.
Problemas resueltos
1. Calcular el cociente y el residuo utilizando u ´nicamente restas. Ver programa 36 “Divisi´ on a partir de restas”. Programa 36 - Divisi´ on a partir de restas #include <iostream.h> // P_For_01 // Prototipos int int int void
Entrada_Int Calculo_Coc Calculo_Res Salida_Int
( ( ( (
char int int char
Msj[] ); Dividendo, int Divisor ); Dividendo, int Divisor, int Coc ); Msj[], int Numero );
Este programa lee el dividendo y el divisor en las variables Numero1 y Numero2 respectivamente. A continuaci´on calcula el cociente y el residuo llamando las respectivos funciones, a las cuales se les pasan los argumentos correspondientes, para finalmente imprimir los resultados. La funci´on Calculo_Coc retorna el cociente de dividir el Dividendo entre el Divisor. En este caso, el cociente es el n´ umero de veces que es posible restar del Dividendo, el Divisor, sin encontrar n´ umeros negativos. La funci´on Calculo_Res devuelve el resultado correspondiente al residuo luego de pasar el Dividendo, el Divisor y el Cociente.
CAP´ITULO 10. CICLO FOR
156
Continuaci´ on programa 36 void main ( void ) { int Numero1, Numero2, Cociente, Residuo; cout << "DIVISION ENTERA CON RESTAS!!\n"; Numero1 Numero2
= Entrada_Int ( "Primer Numero = Entrada_Int ( "Segundo Numero
: " : "
); );
Cociente = Calculo_Coc ( Numero1, Numero2 Residuo = Calculo_Res ( Numero1, Numero2, Cociente
); );
Salida_Int Salida_Int
); );
( "Cociente : ", Cociente ( "Residuo : ", Residuo
}
Continuaci´ on programa 36 int Calculo_Coc ( int Dividendo, int Divisor ) { int I, R; R = Dividendo; for ( I = 0 ; R >= Divisor ; R -= Divisor ) { I++; } return I; }
10.1. PROBLEMAS RESUELTOS
157
Continuaci´ on programa 36 int Calculo_Res ( int Dividendo, int Divisor, int Coc ) { int R; R = Dividendo - Coc * Divisor; return R; }
2. Calcular el m´ınimo com´ un m´ ultiplo de dos enteros positivos. Ver programa 37 “M´ınimo Com´ un M´ ultiplo”. Programa 37 - M´ınimo Com´ un M´ ultiplo #include <iostream.h> // P_For_02 // Prototipos int Entrada_Int ( char Msj[] ); int Calculo ( int Num1, int Num2 ); void Salida_Int ( char Msj[], int Numero );
Este programa lee los dos n´ umeros a los que se les va a calcular el M´ınimo Com´ un M´ ultiplo. Este resultado se obtiene al llamar a la funci´on Calculo, valor que al final se imprime en la pantalla. La funci´on Calculo inicia encontrando el mayor entre los dos n´ umros que se reciben como par´ametros. Para este fin utiliza el operador condicional ?, el cual asigna a Aux1 el mayor valor entre Num1 y Num2. Es decir, Aux1 = Num1 si la condici´on Num1 > Num2 es verdadera. En otro caso, asigna Num2.
CAP´ITULO 10. CICLO FOR Continuaci´ on programa 37
158
void main ( void ) { int Numero1, Numero2, MCM; cout << "MINIMO COMUN MULTIPLO!!\n"; Numero1 = Entrada_Int ( "Primer Numero Numero2 = Entrada_Int ( "Segundo Numero MCM
= Calculo
Salida_Int
( Numero1, Numero2
Continuaci´ on programa 37 int Calculo ( int Num1, int Num2 ) { int I, Aux1, Aux2; Aux1 = ( Num1 > Num2 ) ? Num1 : Num2; Aux2 = 1; for ( I = Aux1 ; ; I += Aux1 ) { if ( I % Num1 == 0 && I % Num2 == 0 ) { Aux2 = I; break; } } return Aux2;
); ); );
( "Minimo Comun Multiplo : ", MCM );
}
}
: " : "
10.1. PROBLEMAS RESUELTOS
159
El valor inicial de la variable de control (I) es el mayor de los dos n´ umeros que ingresan (Aux1). Luego, se busca el primer m´ ultiplo com´ un a los dos n´ umeros, incrementando la variable de control en cada iteraci´on con el valor correspondiente a Aux1. Al encontrar el primer m´ ultiplo com´ un, este es el MCM y se sale del ciclo. 3. Imprimir una tabla trigonom´etrica para ´angulos desde 0.0 Grados hasta 90.0 Grados, cada 5.0 Grados, con su equivalente en Radianes, para las funciones trigonom´etricas Seno, Coseno y Tangente. Ver programa 38 “Tabla trigonom´etrica”. Programa 38 - Tabla trigonom´ etrica #include <iostream.h> #include <math.h> // P_For_03 const double PI = 3.1415926; const double MEDIO_CIRCULO = 180.0; const double APROXIMACION = 100.0; // Prototipo double Formatear ( double Num );
Este programa genera ´angulos desde 0.0 Grados hasta 90.0 Grados, donde el incremento en cada iteraci´on es de 5.0 Grados. Se calcula el equivalente a Radianes y con este valor se calculan el seno y el coseno. Para el c´alculo de la tangente se comprueba que el ´angulo medido en grados sea diferente de 90 Grados, porque la tangente de ´este ´angulo no existe. Para el c´alculo de las funciones trigonom´etricas se utilizan algunas de las funciones que pertenecen a la biblioteca math.h. Es importante tener en cuenta que operan sobre ´angulos medidos en radianes.
CAP´ITULO 10. CICLO FOR
160
Continuaci´ on programa 38 void main ( void ) { double Grados, Radianes; cout << "TABLA TRIGONOMETRICA!!\n"; cout << "Grados" << "\t" << "Rad" << "\t" << "Seno" << "\t" << "Coseno" << "\t" << "Tangente\n"; for ( Grados = 0.0 ; Grados <= 90.0; Grados += 5.0 ) { Radianes = Grados * PI / MEDIO_CIRCULO; cout << "\n" << Grados << "\t" << Formatear( Radianes ) << "\t" << Formatear( sin ( Radianes ) ) << "\t" << Formatear( cos ( Radianes ) ) << "\t" ; if ( Grados != 90.0 ) { cout << Formatear ( tan ( Radianes ) ); } else { cout << "No existe"; } } }
10.1. PROBLEMAS RESUELTOS
161
Continuaci´ on programa 38 double Formatear ( double Num ) { return floor( Num * APROXIMACION ) / APROXIMACION; }
A pesar de que C++ tiene funciones propias para formatear la salida de n´ umeros de punto flotante, se construy´o la funci´on Formatear con este objetivo, y reforzar la construcci´on de funciones. Para lograrlo, se utiliza la funci´on floor de la biblioteca math.h, la cual elimina los decimales. Las dos cifras se establecen multiplicando el numero recibido como par´ametro (Num) por 100, valor asignado a la constante APROXIMACION. El significado de este n´ umero es que 102 = 100. Otra forma de especificar el formato de salida de los n´ umeros de punto flotante es utilizando algunas variantes del comando cout, incluidas en el archivo de biblioteca iomanip.h. Ver “Salida de n´ umero de punto flotante con formato”. Salida de n´ umero de punto flotante con formato cout.setf(ios::right); cout.setf(ios::fixed); cout.setf(ios::showpoint); cout.precision(DECIMALES); cout << setw(ANCHO) << Valor;
La instrucci´on cout.setf(ios::right); indica que los n´ umeros deben ser presentados utilizando justificaci´on derecha, de acuerdo al ancho especificado con setw(ANCHO). Si el ancho del n´ umero que se va a imprimir excede a ANCHO, se ignora la justificaci´on.
CAP´ITULO 10. CICLO FOR
162
El comando cout.setf(ios::fixed); quiere decir a C++ que deber´a mostrar el n´ umero con punto decimal y no en notaci´on cient´ıfica. De manera similar, cout.setf(ios::showpoint); indica que se debe imprimir el punto decimal as´ı se trate de un flotante con la parte decimal en cero. Finalmente, cout.precision(DECIMALES); especifica el n´ umero de posiciones decimales con el valor entero DECIMALES. 4. Escribir el plan de amortizaci´on de un cr´edito en una entidad financiera conociendo el monto, el plazo en meses y el inter´es anual. El plan de amortizaci´on deber´a mostrar en un listado el comportamiento del cr´edito cada mes, incluyendo el abono al capital, el inter´es en cada mes y el saldo. Ver programa 39 “Plan de amortizaci´on”. Programa 39 - Plan de amortizaci´ on #include <iostream.h> #include <math.h> // P_For_04 const double APROXIMACION
=
100.0;
// Prototipos int double double double double double double
Entrada_Int Entrada_Double Calc_Interes Calc_Abono Calc_Saldo Calc_Cuota Formatear
( ( ( ( ( ( (
char Msj[] ); char Msj[] ); double I_Anl, double Sal ); double Cuo, double V_Int ); double Sal, double Abo ); double Mnt, int Pla, double I_Anl ); double Num );
10.1. PROBLEMAS RESUELTOS
163
Continuaci´ on programa 39 void main ( void ) { double Monto, Int_Anual, Int_Mensual, Cuota; double Abono, Interes, Saldo; int Plazo, I; cout << "PLAN DE AMORTIZACION!!\n"; Abono Interes
= 0.0; = 0.0;
Monto = Entrada_Double ( "Monto del credito : " ); Plazo = Entrada_Int ( "Plazo en meses : " ); Int_Anual = Entrada_Double ( "Interes anual (20% = 20): " ); Cuota
= Calc_Cuota
( Monto, Plazo, Int_Anual
);
Saldo = Monto; cout << "\n" << "Mes No." << "\t" << "Abono Capital" << "\t" << "Interes" << "\t\t" << "Cuota" << "\t\t" << "Saldo" << "\n";
Este programa calcula el valor de una cuota mensual de un cr´edito en una entidad financiera conociendo el monto del cr´edito, el inter´es anual y el plazo en meses. Adem´as, permite visualizar el comportamiento de cada una de las mensualidades con el fin de conocer detalles sobre el inter´es y abono al capital en cada cuota, lo mismo que el saldo actualizado. En la presentaci´on de cada valor se hace el llamado a la funci´on Formatear, explicada en la ejemplo anterior.
164
CAP´ITULO 10. CICLO FOR Continuaci´ on programa 39 for ( I = 0 ; I <= Plazo ; I++ ) { if ( I == 0 ) { cout << I << "\t" << "\t" << " \t\t" << "\t\t\t" << Formatear ( Saldo ) << endl; } else { cout << I << "\t" << Formatear ( Abono ) << "\t" << Formatear ( Interes ) << " \t" << Formatear ( Cuota ) << "\t" << Formatear ( Saldo ) << endl; } Interes = Calc_Interes ( Int_Anual, Saldo ); Abono = Calc_Abono ( Cuota, Interes ); Saldo = Calc_Saldo ( Saldo, Abono ); }
}
Continuaci´ on programa 39 double Calc_Interes ( double I_Anl, double Sal ) { return I_Anl / 100.0 / 12.0 * Sal; }
La funci´on Calc_Interes permite obtener el valor del inter´es para cada una de las cuotas mensuales. El c´alculo del inter´es que se paga en cada cuota corresponde al producto del saldo por la tasa de inter´es mensual que a su vez es la doceava parte de la tasa de inter´es anual. Se debe hacer divisi´on entre 100 debido a la forma como se interpret´o la entrada de la tasa anual.
10.1. PROBLEMAS RESUELTOS
165
Continuaci´ on programa 39 double Calc_Abono ( double Cuo, double V_Int ) { return Cuo - V_Int; }
La funci´on Calc_Abono recibe como par´ametros el valor de la cuota y el valor del inter´es asociado a esa cuota. Con estos dos valores se calcula la diferencia, correspondiente al abono a capital. Continuaci´ on programa 39 double Calc_Saldo ( double Sal, double Abo ) { return Sal - Abo; }
La funci´on Calc_Saldo calcula el nuevo saldo el cual corresponde al saldo anterior menos el abono que se realiz´o en la respectiva cuota. La funci´on Calc_Cuota utiliza los tres valores conocidos y una ecuaci´on cl´asica de ingenier´ıa econ´omica que no es pertinente explicar a fondo. C=
M × I × (I + 1)P (I + 1)P − 1
CAP´ITULO 10. CICLO FOR Continuaci´ on programa 39
166
double Calc_Cuota ( double Mnt, int Pla, double I_Anl ) { double Numero, Int_Mes, Aux; Int_Mes = I_Anl /100.0 / 12.0; Aux = pow ( Int_Mes + 1.0 , Pla ); Numero = Mnt * Int_Mes * Aux / ( Aux - 1.0 ); return Numero; }
5. Realizar programa que genere con asteriscos una figura similara a la siguiente de tal manera que permita cambiar la longitud y el n´ umero de flechas. La longitud es el ancho mayor de un segmento de asteriscos. El n´ umero de flechas no tiene en cuenta el tri´angulo inicial. Ver “Figuras de 1 y 4 flechas, de longitud 5”. Figuras de 1 y 4 flechas, de longitud 5 * * ** ** *** *** **** **** ***** ***** **** **** *** *** ** ** * *
* * * * * ** ** ** ** ** *** *** *** *** *** **** **** **** **** **** ***** ***** ***** ***** ***** **** **** **** **** **** *** *** *** *** *** ** ** ** ** ** * * * * *
10.1. PROBLEMAS RESUELTOS Ver programa 40 “Figura”. Programa 40 - Figura #include <iostream.h> // P_For_05 const int SEPARACION = -2; // Prototipo int Entrada_Int ( char Msj[] ); void main ( void ) { int I, J, K, N, N_Flechas, Tope; cout << "DIBUJO!!\n"; Tope = 0; N = Entrada_Int ( "Longitud: " ); N_Flechas = Entrada_Int ( "Flechas : " ); for ( I = 1 ; I <= N ; I++ ) { for ( J = 1 ; J <= I ; J++ ) { cout << ( "*" ); } for ( K = 1 ; K <= N_Flechas ; K++ ) { if ( K == 1 ) { Tope = N - 1 + SEPARACION; }
167
CAP´ITULO 10. CICLO FOR
168
Continuaci´ on programa 40 else { Tope = 2 * N - I + SEPARACION; } for ( J = 1 ; J <= Tope ; J++ ) { cout << ( " " ); } for ( J = 1 ; J <= I ; J++ ) { cout << ( "*" ); } } cout << "\n"; } for ( I = 1 ; I <= N ; I++ ) { for ( J = N - I ; J >= 1 ; J-- ) { cout << ( "*" ); } for ( K = 1 ; K <= N_Flechas ; K++ ) { if ( K == 1 ) { Tope = N - 1 + SEPARACION; } else { Tope = N + I + SEPARACION; }
10.1. PROBLEMAS RESUELTOS
169
Continuaci´ on programa 40 for ( J = 1 ; J <= Tope ; J++ ) { cout << ( " " ); } for ( J = N - I ; J >= 1 ; J-- ) { cout << ( "*" ); } } cout << "\n"; } }
Este programa genera una figura la cual consta de un tri´angulo y un n´ umero especificado de flechas que se forman con el caracter *. La constante SEPARACION puede ser modificada con el fin de variar la apariencia de la figura. Con este ejemplo ser´ıa ideal practicar el seguimiento de las variables en forma manual para fortalecer la habilidad en el manejo de las estructuras de repetici´on anidadas.
CAP´ITULO 10. CICLO FOR
170
10.2.
Problemas propuestos
1. Con * dibuje una letra L en la pantalla. Solicite la altura y el ancho. Valide las entradas de acuerdo al tama˜ no de la pantalla. * * * * * * ****** 2. Dibujar en la pantalla la siguiente figura. El ancho es igual al alto y su valor es especificado por teclado. ****** ***** **** *** ** * 3. Hallar los divisores de un entero positivo dado. 4. Hallar el m´aximo com´ un divisor de dos enteros positivos. 5. Dados a y b, enteros positivos, calcular a×b usando u ´nicamente sumas. 6. Hallar la primera potencia de 3 mayor de 1000, usando productos.
10.2. PROBLEMAS PROPUESTOS
171
7. Elabore un programa que imprima en pantalla la figura siguiente con caracteres *. La altura y el ancho se ingresan por teclado. La altura debe ser impar. Valide las entradas. ****** * * * * * * ** * * ** *** **** ***** ****** 8. Genere e imprima los n elementos de la serie de fibonacci, a partir del elemento k ´esimo. Tanto n como k deben ser solicitados al usuario. Recuerde que la serie de fibonacci es: 1, 1, 2, 3, 5, 8, 13, 21.... Elementon = Elementon−1 + Elementon−2 9. Calcular el factorial de un n´ umero entero positivo menor de 7, utilizando u ´nicamente sumas. n! = n × (n − 1) × (n − 2) × · · · × 3 × 2 × 1 a×b=a | + a + a{z+ · · · + a} b veces
10. Teniendo 100 n´ umeros al azar entre 1 y 5, determine la frecuencia de cada n´ umero.
172
CAP´ITULO 10. CICLO FOR
Cap´ıtulo 11 Arreglos unidimensionales Las variablee simples almacenan valores individuales. C++ permite la utilizaci´on de arreglos para almacenar uno o m´as valores, asociados al mismo identificador, donde todos los valores son del mismo tipo. Existen arreglos de una o m´as dimensiones. Los arreglos de una dimensi´on se conocen con el nombre de vectores. Los de dos dimensiones se llaman matrices y los dem´as, reciben el nombre de multidimensionales. Las notas de los 35 estudiantes de un grupo, los nombres de 100 libros en la biblioteca o el valor de la matr´ıcula un n´ umero especificado de estudiantes de la universidad. Cuando se necesita manejar muchos datos (todos del mismo tipo), se utiliza un arreglo, especificando el tipo, el nombre del arreglo y el tama˜ no entre corchetes. El nombre del arreglo deber´a ser un identificador v´alido. Por ejemplo, int Vector [ 20 ];. Al momento de crear el espacio de memoria, antes de usar el arreglo, se debe escribir el nombre del arreglo y entre corchetes el tama˜ no o n´ umero de posiciones que se desea reservar. Es importante anotar que N puede ser una constante o un n´ umero claramente especificado, por ejemplo 8. Cuando C++ encuentra la declaraci´on de un arreglo (float Nota [ 50 ];), sabe que el usuario utilizar´a un arreglo llamado Nota y que ha reservado cincuenta posiciones, de tal manera que en cada espacio de 4 bytes sea almacenado un n´ umero flotante perteneciente al arreglo. 173
174
CAP´ITULO 11. ARREGLOS UNIDIMENSIONALES
Para identificar cada uno de los elementos de un arreglo, se debe usar un valor sub´ındice que se˜ nala la posici´on del elemento dentro del arreglo. Para distinguir el primer elemento se usar´a el sub´ındice 0. El segundo elemento se usar´a el sub´ındice 1, y as´ı sucesivamente. El u ´ltimo elemento siempre estar´a en la posici´on especificada por el tama˜ no del arreglo menos uno. Para un arreglo de tama˜ no n, los elementos son: Ver “Elementos de un arreglo”. Elementos de un arreglo Dato[0] Dato[1] Dato[2] ... Dato[n - 2] Dato[n - 1]
Suponga que el valor de n es 5 y que los valores son: 0
100
1
2
200 300
3
4
400 500
Una forma de asignar los valores a las diferentes posiciones de un arreglo es usando el acceso directo. Ver “Acceso directo a las posiciones de un arreglo”. Ahora bien, es u ´til emplear una variable entera como sub´ındice que sirva para acceder a las posiciones del arreglo. Por ejemplo, si se desea asignar 2000 en la posici´on 3 usando un sub´ındice.
175 Acceso directo a las posiciones de un arreglo int Dato[ 5 ]; Dato[0] Dato[1] Dato[2] Dato[3] Dato[4]
= = = = =
100; 200; 300; 400; 500;
Ver “Acceso indirecto a las posiciones de un arreglo”. Acceso indirecto a las posiciones de un arreglo int i; i = 3; Dato[i] = 2000;
Las valores almacenados en las posiciones de un arreglo son variables. Por lo tanto, ahora el valor de Dato[ 3 ] es 2000 y no 400 como estaba inicialmente. 0
1
100
200
2
3
300 2000
4
500
Es es muy pr´actico utilizar ciclos con el fin de acceder a todas las posiciones del arreglo, ya sea para leer, asignar, manipular o imprimir los valores que se encuentran almacenados en las diferentes posiciones. Ver “Acceso a un arreglo usando ciclos do - while y for”. A pesar de que en el ejemplo anterior no fue considerado el ciclo while, esta clase de ciclo tambi´en puede ser utilizada para este fin. No obstante, generalmente se utiliza el ciclo for, por facilidad en la programaci´on.
CAP´ITULO 11. ARREGLOS UNIDIMENSIONALES Acceso a un arreglo usando ciclos do - while y for
176
i = 0; do { Dato[ i ] = 0; i++; } while ( i < 5);
11.1.
for ( i = 0 ; i < 5 ; i++ ) { Dato[ i ] = 0; }
Problemas resueltos
1. Elaborar un programa que sume los elementos de un arreglo de enteros. Ver programa 41 “Sumar los elementos de un arreglo”. Programa 41 - Sumar los elementos de un arreglo #include <iostream.h> // P_Arr_01 const int MAX = 100; // Prototipos int void void void int
Entrada_Int Salida_Int Entrada_Vec_Int Salida_Vec_Int Calculo
( ( ( ( (
char char char char int
Msj[] Msj[], Msj[], Msj[], Vec[],
int int int int
); Numero ); Vec[], int Length ); Vec[], int Length ); Length );
11.1. PROBLEMAS RESUELTOS
177
Continuaci´ on programa 41 void main ( void ) { int Vector[MAX]; int N, Suma; cout << "SUMA DE LOS ELEMENTOS!!\n"; N = Entrada_Int
( "Numero de elementos : "
);
Entrada_Vec_Int
( "Posicion " , Vector, N
);
Salida_Vec_Int
( "Posicion " , Vector, N
);
Suma = Calculo
( Vector, N
);
( "Suma: " , Suma
);
cout << "\n";
cout << "\n"; Salida_Int }
Este programa define una constante entera llamada MAX, la cual tiene un valor de 100 y representa el tama˜ no m´aximo del vector, es decir, la cantidad de posiciones de memoria que se han reservado. Sin embargo, el usuario puede establecer un n´ umero de elementos que desee utilizar. En este caso, se lee el valor de N, el cual debe ser menor que MAX, aunque el programa no est´a validando esta entrada. Despu´es de conocer la cantidad de elementos que va a contener el arreglo, se indica a C++ que llame a la funci´on Entrada_Vec_Int, a la cual se le pasan como argumentos un mensaje que se imprime al leer cada elemento, el nombre del arreglo y el tama˜ no especificado por el usuario. Luego, imprime completamente el contenido del arreglo que acaba de ingresar llamando a la funci´on Salida_Vec_Int con los mismos argumentos.
178
CAP´ITULO 11. ARREGLOS UNIDIMENSIONALES La funci´on Calculo suma los elementos del arreglo y finamente se imprime el resultado. Continuaci´ on programa 41
void Entrada_Vec_Int ( char Msj[], int Vec[], int Length ) { int I; for ( I = 0 ; I < Length ; I++ ) { Salida_Int ( Msj, I ); Vec[ I ] = Entrada_Int ( "Ingrese: " ); } }
La funci´on Entrada_Vec_Int solicita la entrada de un entero dentro de un ciclo el cual se ejecuta todas las veces necesarias para leer la cantidad especificada de elementos del vector. Esta funci´on ser´a utilizada en los dem´as ejemplos. Naturalmente no se volver´a a explicar. Continuaci´ on programa 41 void Salida_Vec_Int ( char Msj[], int Vec[], int Length ) { int I; for ( I = 0 ; I < Length ; I++ ) { Salida_Int ( Msj, I ); Salida_Int ( "Numero : ", Vec[I] ); } }
La funci´on Salida_Vec_Int es similar a Entrada_Vec_Int, y se utiliza para mostrar en pantalla el contenido de un arreglo cuya referencia pasa
11.1. PROBLEMAS RESUELTOS
179
como par´ametro, al igual que la cadena que se imprime. Esta funci´on, al igual que Entrada_Vec_Int ser´a utilizada en los ejemplos siguientes y no ser´a explicada. Continuaci´ on programa 41 int Calculo ( int Vec[], int Length ) { int I, S; S = 0; for ( I = 0 ; I < Length ; I++ ) { S += Vec[I]; } return S; }
La funci´on Calculo recibe como par´ametro una referencia al arreglo que se quiere sumar y la longitud. El acumulador se inicia en cero (S = 0;) y conociendo la longitud del vector se ejecuta un ciclo que sumar´a los elementos del arreglo. El valor final de S es retornado. 2. Construir un programa que lea los elementos de un vector de enteros, invierta el orden y lo imprima. Ver programa 42 “Orden inverso”. Programa 42 - Orden inverso #include <iostream.h> // P_Arr_02
CAP´ITULO 11. ARREGLOS UNIDIMENSIONALES Continuaci´ on programa 42
180
// Prototipos int *Crear_Vector_Int ( int Tam void Liberar_Vector ( int Vec[] int Entrada_Int ( char Msj[] void Entrada_Vec_Int ( char Msj[], int Vec[], int Length void Salida_Vec_Int ( char Msj[], int Vec[], int Length void Invertir_Vec_Int ( int Vec[], int Vec_Inv[], int Length
); ); ); ); ); );
void main ( void ) Length \end{parte} { int *Vector, *Vector_Inv; int N; cout << "ORDEN INVERSO!!\n"; N = Entrada_Int
( "Numero de elementos : "
);
Vector = Crear_Vector_Int ( N ); Vector_Inv = Crear_Vector_Int ( N ); Entrada_Vec_Int Invertir_Vec_Int
( "Posicion ", Vector, N ( Vector, Vector_Inv, N
); );
cout << "\n ORDEN INVERSO \n"; Salida_Vec_Int
( "Posicion " , Vector_Inv, N );
Liberar_Vector ( Vector ); Liberar_Vector ( Vector_Inv ); }
11.1. PROBLEMAS RESUELTOS
181
En muchas ocasiones el usuario de un programa determina el tama˜ no de los arreglos. Por esta raz´on, reservar un espacio de memoria fijo puede ocasionar incovenientes, ya sea porque se reserva espacio insuficiente o porque se desperdicia. Cuando se reserva una zona fija de memoria se conoce con el nombre de memoria est´atica. En este programa se ilustra otra forma de utilizar los arreglos unidimensionales en los cuales se utiliza u ´nicamente la memoria necesaria. La funci´on Crear_Vector_Int tiene como objetivo solicitar memoria para un vector de enteros. Esta funci´on debe retornar el lugar en el cual inicia la zona de memoria reservada. Cuando una funci´on retorna una direcci´on de memoria, es necesario anteponerle al nombre el s´ımbolo * y se dice que retorna un puntero. De igual manera, las variables que reciben direcciones de memoria en lugar de valores, deben tener el s´ımbolo * en su nombre al momento de declararse (int *Vector, *Vector_Inv;). Observe que no se especifica el tama˜ no del arreglo y que Vector es una variable que recibir´a una direcci´on de memoria y no un valor entero. Por esa raz´on se le antepone el *. Este tipo de variables se conocen con el nombre de punteros y ser´an estudiadas m´as a fondo en el Volumen II de esta obra. En este libro, los punteros ser´an utilizados u ´nicamente con el fin de declarar arreglos en los cuales no se desperdiciar´a memoria. Este tipo de arreglos son de tama˜ no din´amico. Este programa lee el n´ umero de elementos que conformar´a el vector. A continuaci´on solicita memoria para la creaci´on de dos vectores (el original y otro en el cual ser´a almacenado el vector invertido). Con el llamado a la funci´on Entrada_Vec_Int se leen los datos del vector. La funci´on Invertir_Vec_Int se encarga de generar un vector invertido de elementos enteros a partir del vector que ha sido ingresado por el usuario. Finalmente se imprime el vector resultante a trav´es de la funci´on Salida_Vec_Int. La funci´on Liberar_Vector se encarga de indicarle a C++ que la memoria que ten´ıa reservada para el vector especificado puede ser liberada, es decir, deja de estar reservada y se convierte en memoria disponible. Es de anotar que como la memoria es un recurso limitado, se recomienda un manejo apropiado de ella y nunca dejar programas que reserven memoria y no la liberen al terminar de utilizarla.
CAP´ITULO 11. ARREGLOS UNIDIMENSIONALES Continuaci´ on programa 42
182
int *Crear_Vector_Int ( int Tam ) { int *Vec; Vec
= new int [ Tam ];
return Vec; }
La funci´on Crear_Vector_Int solicita memoria (new) para un vector ([ ]) de enteros (int) donde el par´ametro Tam especifica el tama˜ no o n´ umero de posiciones Vec = new int [ Tam ];. En este caso Vec es un puntero temporal el cual contiene la direcci´on de la primera posici´on de la memoria reservada al utilizar esta funci´on. Dicha direcci´on es la que se retorna. Esta es una funci´on de uso frecuente en este cap´ıtulo y no ser´a explicada de nuevo. Continuaci´ on programa 42 void Liberar_Vector ( int *Vec ) { delete [ ]Vec; }
De la misma forma como se reserva memoria, es necesario devolver (liberar) a C++ la memoria reservada que ya no se va a utilizar. La instrucci´on delete se encarga de esta tarea, conociendo la direcci´on de la zona de memoria que el usuario ha dejado de utilizar y desea que quede libre. Observe el uso de los corchetes vac´ıos a la izquierda del nombre del par´ametro que representa al arreglo que se quiere liberar. Estos corchetes indican que la memoria a liberar corresponde a un vector.
11.1. PROBLEMAS RESUELTOS
183
Esta funci´on se utiliza en los dem´as ejemplos que componen este cap´ıtulo. Por esta raz´on no ser´a explicada de nuevo. Continuaci´ on programa 42 void Invertir_Vec_Int ( int Vec[ ], int Vec_Inv[ ], int Length ) { int I, J; J=0; for ( I = Length -1 ; I >= 0 ; I-- ) { Vec_Inv[ J ] = Vec[ I ]; J++; } }
La funci´on Invertir_Vec_Int recibe como par´ametros el vector original, el vector en el cual se almacenar´a el resultado de invertir los elementos y el tama˜ no. Mediante el uso de los contadores I y J se controlan las posiciones en los dos vectores. Observe que I usa decrementos mientras que J usa incrementos. Si se desea utilizar un vector como par´ ametro en una funci´on, el usuario puede utilizar el nombre del vector y los corchetes vac´ıos ( int Vec[ ]) o anteponer el s´ımbolo * y omitir los corchetes int *Vec. El usuario puede escoger la forma que le permita trabajar con mayor comodidad. Es de tener en cuenta que al pasar arreglos a una funci´on, lo que se est´a pasando es una copia de la direcci´ on en la cual comienza el arreglo. Por lo tanto, si dentro de una funci´on se realiza alguna modificaci´ on al arreglo recibido como par´ ametro, se modifica el contenido original de dicho arreglo.
CAP´ITULO 11. ARREGLOS UNIDIMENSIONALES
184
3. Construir un programa que lea los elementos de un vector de enteros, y lo divida en dos vectores, uno con los pares y otro con los impares. Ver programa 43 “Dividir en pares e impares”. Programa 43 - Dividir en pares e impares #include <iostream.h> // P_Arr_03 // Prototipos int *Crear_Vector_Int ( int void Liberar_Vector ( int int Entrada_Int ( char void Salida_Int ( char void Entrada_Vec_Int ( char void Salida_Vec_Int ( char int Cuenta_Pares ( int void Dividir ( int int
Tam Vec[] Msj[] Msj[], Msj[], Msj[], Vec[], Vec[], Length
int int int int int
); ); ); Numero ); Vec[], int Length ); Vec[], int Length ); Length ); Vec1[], int Vec2[], );
void main ( void ) { int *Vector, *Vec_Par, *Vec_Impar; int N, N_Pares, N_Impares; cout << "DIVISION EN PARES E IMPARES!!\n"; N = Entrada_Int Vector
( "Numero de elementos : "
);
= Crear_Vector_Int ( N );
Entrada_Vec_Int
( "Posicion " , Vector, N
N_Pares = Cuenta_Pares ( Vector, N N_Impares = N - N_Pares;
); );
11.1. PROBLEMAS RESUELTOS
185
Continuaci´ on programa 43 Vec_Par
= Crear_Vector_Int ( N_Pares
);
Vec_Impar = Crear_Vector_Int ( N_Impares ); cout << endl; Dividir if ( N_Pares > 0 ) { cout Salida_Vec_Int } if ( N_Impares > 0 ) { cout Salida_Vec_Int }
( Vector, Vec_Par, Vec_Impar, N
);
<< "\nPARES \n"; ( "Posicion " , Vec_Par, N_Pares
);
<< "\nIMPARES \n"; ( "Posicion " , Vec_Impar, N_Impares );
Liberar_Vector ( Vector ); Liberar_Vector ( Vec_Par ); Liberar_Vector ( Vec_Impar ); }
Este programa lee un vector de enteros. Con la funci´on Cuenta_Pares se obtiene la cantidad de n´ umeros pares y al restarlo del total de elementos del vector original se puede solicitar la memoria necesaria para los vectores Vec_Par y Vec_Impar. A continuaci´on se utiliza la funci´on Dividir donde los argumentos son el vector con los datos, el vector que almacenar´a los pares y el vector donde ser´an guardados los impares. Finalmente, se imprimen los vectores resultantes, siempre y cuando tengan elementos.
CAP´ITULO 11. ARREGLOS UNIDIMENSIONALES Continuaci´ on programa 43
186
int Cuenta_Pares ( int Vec[ ], int Length ) { int I, J; J = 0; for ( I = 0 ; I < Length ; I++ ) { if ( Vec[I] % 2 == 0 ) { J++; } } return J; }
La funci´on Cuenta_Pares recorre el vector que recibe por par´ametro con el fin de llevar la cuenta del n´ umero de elementos pares. Continuaci´ on programa 43 void Dividir ( int Vec[ ], int Vec1[ ], int Vec2[ ], int Length ) { int I, J, K; J = 0; K = 0;
11.1. PROBLEMAS RESUELTOS
187
Continuaci´ on programa 43 for ( I = 0 ; { if ( Vec[I] { Vec1[ J ] J++; } else { Vec2[ K ] K++; } }
I < Length ; I++ ) % 2 == 0) = Vec[ I ];
= Vec[ I ];
}
La funci´on Dividir recibe el vector con los elementos enteros y se encarga de generar dos vectores resultantes, uno para n´ umeros pares y otro para impares. 4. Elaborar un programa que lea un vector de enteros y una posici´on determinada. El programa deber´a generar un vector con los mismos elementos excepto el que se encuentre en la posicion especificada. Ver programa 44 “Eliminar un dato”. Programa 44 - Eliminar un dato #include <iostream.h> // P_Arr_04 const int TRUE = 1; const int FALSE = 0;
CAP´ITULO 11. ARREGLOS UNIDIMENSIONALES Continuaci´ on programa 44
188
// Prototipos int *Crear_Vector_Int ( int Tam ); void Liberar_Vector ( int Vec[] ); int Entrada_Int ( char Msj[] ); void Entrada_Vec_Int ( char Msj[], int Vec[], int Length ); void Salida_Vec_Int ( char Msj[], int Vec[], int Length ); int Eliminado ( int Vec[], int Pos, int V_Sal[], int Length ); void main ( void ) { int *Vector, *Vec_Sal; int N, Posicion; cout << "ELIMINAR UN ELEMENTO!!\n"; N = Entrada_Int Vector Vec_Sal
= Crear_Vector_Int ( N = Crear_Vector_Int ( N
Entrada_Vec_Int Posicion
( "Numero de elementos : "
);
); - 1 );
( "Posicion " , Vector, N
);
= Entrada_Int ( "\nPosicion del elemento : " );
cout << "\n"; if ( Eliminado ( Vector, Posicion, Vec_Sal, N ) == TRUE ) { Salida_Vec_Int ( "Elemento ", Vec_Sal, N -1 ); } else { cout << "ERROR!!"; }
11.1. PROBLEMAS RESUELTOS
189
Continuaci´ on programa 44 Liberar_Vector ( Vector ); Liberar_Vector ( Vec_Sal ); }
Este programa lee un vector de enteros y la posici´on del elemento que no se desea pasar al vector de salida. En caso de que la posici´on especificada no corresponda a un elemento del vector original se imprime un mensaje de error. Continuaci´ on programa 44 int Eliminado ( int Vec[], int Pos, int V_Sal[], int Length ) { int I, J; J = 0; if ( Pos >= 0 { for ( I = 0 { if ( I != { V_Sal [ J++; } }
&& Pos < Length ) ; I < Length ; I++ ) Pos ) J ] = Vec[ I ];
return TRUE; }
CAP´ITULO 11. ARREGLOS UNIDIMENSIONALES Continuaci´ on programa 44
190
else { return FALSE; } }
La funci´on Eliminado genera un vector de enteros con los elementos de un vector de datos excepto el elemento de una posici´on determinada por el par´ametro Pos. Si la posici´on Pos no hace parte del vector se retorna un valor false en otro caso, se copia el vector elemento a elemento sin tener en cuenta el elemento de la posici´on Pos. Observe que cada vector es controlado por su propio contador. 5. Construir un programa que permita insertar un elemento dentro de un vector de enteros a partir de una posici´on especificada. Ver programa 45 “Insertar y desplazar”. Programa 45 - Insertar y desplazar #include <iostream.h> // P_Arr_05 const int TRUE = 1; const int FALSE = 0;
Este programa lee un vector de enteros, un elemento a insertar y la posici´on en la cual se desea introducir. Mediante el llamado a la funci´on Insertado se puede imprimir en la pantalla el vector de salida. Si no es posible insertar dicho elemento, se obtiene un mensaje de error.
11.1. PROBLEMAS RESUELTOS
191
Continuaci´ on programa 45 // Prototipos int *Crear_Vector_Int ( int Tam void Liberar_Vector ( int Vec[] int Entrada_Int ( char Msj[] void Entrada_Vec_Int ( char Msj[], void Salida_Vec_Int ( char Msj[], int Insertado ( int Vec[], int V_Sal[],
); ); ); int Vec[], int Length ); int Vec[], int Length ); int Pos, int Elem, int Length );
void main ( void ) { int *Vector, *Vec_Sal; int N, Posicion, Elemento; cout << "INSERTAR UN ELEMENTO!!\n"; N = Entrada_Int Vector Vec_Sal
( "Numero de elementos : "
);
= Crear_Vector_Int ( N ); = Crear_Vector_Int ( N + 1 );
Entrada_Vec_Int
( "Posicion " , Vector, N
);
Elemento
= Entrada_Int ( "Elemento a insertar
: "
);
Posicion
= Entrada_Int ( "Posicion del elemento : "
);
if ( Insertado ( Vector, Posicion, Elemento, Vec_Sal, N ) == TRUE ) { Salida_Vec_Int ( "Posicion ", Vec_Sal, N + 1 }
);
CAP´ITULO 11. ARREGLOS UNIDIMENSIONALES
192
Continuaci´ on programa 45 else { cout << "ERROR!!"; } Liberar_Vector ( Vector ); Liberar_Vector ( Vec_Sal ); }
Continuaci´ on programa 45 int Insertado ( int Vec[], int Pos, int Elem, int V_Sal[], int Length ) { int I, J; J = 0; if ( Pos >= 0 { for ( I = 0 { if ( I == { V_Sal [ J++; }
&& Pos < Length ) ; I < Length ; I++ ) Pos ) J ] = Elem;
V_Sal [ J ] = Vec[ I ]; J++; } return TRUE; }
11.2. PROBLEMAS PROPUESTOS
193
Continuaci´ on programa 45 else { return FALSE; } }
La funci´on Insertado recibe como par´ametros el vector de datos, la posici´on en la cual se desea insertar el elemento, el elemento a insertar y el vector de salida que se va a generar. En caso de que la posici´on no sea posible, se retorna un valor booleano de false. Si el proceso se realiz´o correctamente, se retorna un true.
11.2.
Problemas propuestos
1. Concatene dos arreglos, donde el primer arreglo es de n elementos, y el segundo es de m elementos, en un tercer arreglo. Los valores m y n est´an entre 1 y 20. 6
4
9
5
6
4
9
5
2
2
5
2
3
8
5
2
3
8
0
0
2. Generar e imprimir un arreglo de 40 elementos similara al que se muestra a continuaci´on. 1
4
9
16
25
36
49
···
CAP´ITULO 11. ARREGLOS UNIDIMENSIONALES
194
3. Inicializar un vector de 50 elementos enteros con la serie que se puede apreciar en el siguiente arreglo. Finalmente, encuentre la suma de sus elementos utilizando una funci´on. 0
3
6
9
0
3
6
9
0
3
6
9
···
6
···
4. Generar e imprimir el arreglo de 50 elementos. 1
1
2
2
3
3
4
4
5
5
6
5. Dado un vector a de n elementos que ingresa ordenado de menor a mayor, hallar la mediana. n−1 a[ 2 ], M ediana =
si n es impar
a[ n ]+a[ n −1] 2 2 2
si n es par
Por ejemplo, dado el siguiente arreglo de 8 elementos: 1
2
2
5
M ediana =
7
8
8
9
a[ n2 ] + a[ n2 − 1] 2
a[ 82 ] + a[ 82 − 1] 2 a[4] + a[3] 7+5 M ediana = = =6 2 2 M ediana =
6. Dado un arreglo de 10 enteros y un n´ umero x entre cero y nueve, cree un segundo arreglo de nueve posiciones igual al primero, al cual se le ha eliminado el elemento de la posici´on x.
11.2. PROBLEMAS PROPUESTOS 5
7
195
2
5
1
1
6
3
5
6
5
7
2
5
1
6
3
5
x=5 6
7. Dado un arreglo de 8 enteros, un n´ umero x entero entre cero y siete, y un entero cualquiera m, cree un segundo arreglo de nueve posiciones al que se le ha adicionado el elemento m en la posici´on x. 4
3
2
3 4
7 3
8 2
9 8
3 3
x=3 7
8
9
m=8 3
8. Dados dos arreglos de tama˜ nos m y n respectivamente, determinar si son iguales o no. Si el tama˜ no de los vectores es diferente, determinar si existe contenencia, en el orden estricto. 5
3
6
2
8
4
3
⊃
6
2
8
9. Dado un vector de 15 elementos enteros que ingresa en orden de menor a mayor, imprima un segundo vector igual al primero sin repeticiones. 1
1
2
3
3
3
4
6
8
8
8
1
2
3
4
6
8
9
8
9
9
9
10. Dado un vector de 15 elementos enteros que ingresa en cualquier orden, imprima un segundo vector igual al primero sin repeticiones. 6
9
3
2
6 6
0 9
2 3
5 2
1 0
4 5
0 1
3 4
2
1
5
196
CAP´ITULO 11. ARREGLOS UNIDIMENSIONALES
Cap´ıtulo 12 Matrices Un arreglo bidimensional es una formaci´on organizada de elementos, dispuestos en filas y columnas. Los arreglos de dos dimensiones se conocen con el nombre de matrices o tablas. Al igual que los arreglos unidimensionales, las matrices se utilizan para agrupar un conjunto de datos del mismo tipo, asociados a un mismo identificador y tienen m´ ultiples aplicaciones en la soluci´on de problemas de diferentes ´areas. Las notas de varias materias para los estudiantes de un grupo, cuatro notas parciales de un grupo de estudiantes, la venta semanal de los vendedores de una empresa o la temperatura de un estanque cada hora en los diferentes d´ıas de la semana, entre otros. Para indicarle a C++ que se utilizar´a un arreglo de dos dimensiones, se debe especificar el tipo de dato, el nombre del arreglo, entre corchetes el n´ umero de filas y luego, otra vez entre corchetes el n´ umero de columnas. El nombre de la matriz deber´a ser un identificador v´alido. Por ejemplo, int Dato [ 4 ][ 3 ];. En la declaraci´on de una matriz (float Nota [ 4 ][ 3 ];), C++ sabe que el usuario utilizar´a un arreglo bidimensional llamado Nota y que ha reservado cuatro filas y tres columnas, de tal manera que en cada espacio de 4 bytes sea almacenado un n´ umero flotante perteneciente a la matriz. Para identificar cada uno de los elementos de una matriz, se deben usar dos valores sub´ındices que se˜ nalan la posici´on del elemento dentro de la matriz. 197
CAP´ITULO 12. MATRICES
198
Para distinguir el primer elemento (primera fila, primera columna) se usar´a el sub´ındice 0,0. El segundo elemento de la primera fila usar´a los sub´ındices 0,1, y as´ı sucesivamente. El u ´ltimo elemento (´ ultima fila, u ´ltima columna) siempre estar´a en la posici´on especificada por el n´ umero de filas menos uno y n´ umero de columnas menos uno. Para una matriz de tama˜ no N x M, los elementos son:
[ [
0 1
][ 0 ] [ ][ 0 ] [ .. .
0 1
][ 1 ] [ ][ 1 ] [ .. .
0 1
][ 2 ] ][ 2 ] .. .
... ... ...
[ [
0 1
][ M-1 ] ][ M-1 ] .. .
[ N-1 ][ 0 ] [ N-1 ][ 1 ] [ N-1 ][ 2 ]
...
[ N-1 ][ M-1 ]
Cuadro 12.1: Matriz de N filas por M columnas
Suponga que N es igual a 5, M es igual a 4 y que los valores son:
0 1 2 3
0
1
2
3
4
100 600 300 100
200 700 50 100
300 800 600 100
400 900 200 300
500 200 200 500
Una forma de asignar los valores a las diferentes posiciones de una matriz es usando el acceso directo. Para tener acceso a los elementos de una matriz se puede utilizar el acceso directo o el acceso indirecto. Ver “Acceso directo a las posiciones de una matriz”. Despu´es de la asignaci´on anterior, la matriz tiene almacenada en la tabla 12.2: Tambi´en es posible utilizar variables enteras como sub´ındices para acceder a las posiciones de la matriz. Por ejemplo: si se desea asignar 85 en la posici´on de la fila 1 y columna 0.
199 Acceso directo a las posiciones de una matriz int Tabla[3][2]; Tabla[0][0] Tabla[0][1] Tabla[1][0] Tabla[1][1] Tabla[2][0] Tabla[2][1]
= = = = = =
10; 15; 20; 25; 30; 35;
0 1 2
0
1
10 20 30
15 25 35
Cuadro 12.2: Matriz de 3 filas por 2 columnas
Acceso indirecto a las posiciones de una matriz int i,j; i = 1; j = 0; Tabla[i][j] = 85;
CAP´ITULO 12. MATRICES
200
Ver “Acceso indirecto a las posiciones de una matriz”. Al realizar la anterior modificaci´on a la tabla, los nuevos valores se encuentran en la tabla 12.3.
0 1 2
0
1
10 85 30
15 25 35
Cuadro 12.3: Actualizaci´on de valores de una Matriz Es es muy pr´actico utilizar ciclos con el fin de acceder a todas las posiciones del arreglo, ya sea para leer, asignar, manipular o imprimir los valores que se encuentran almacenados en las diferentes posiciones. Ver “Acceso a un arreglo usando el ciclo for”. Acceso a un arreglo usando el ciclo for for ( i = 0 ; i < 4 ; i++ ) { for ( j = 0 ; j < 3 ; j++ ) { Dato[ i ][ j ] = 10 * i + j; } }
Observe que el ciclo externo controla el ´ındice de las filas y el interno se utiliza para recorrer las columnas. Ver tabla 12.4.
12.1. PROBLEMAS RESUELTOS 0 1 2 3
201
0
1
2
0 10 20 30
1 11 21 31
2 12 22 32
Cuadro 12.4: Acceso a los elementos de una matriz
12.1.
Problemas resueltos
1. Elabore un programa que genere la Matriz Identidad de orden N. La Matriz Identidad se compone de n´ umeros enteros, donde todos los elementos de la diagonal principal son unos y el resto de la matriz son ceros. Ver tabla 12.5.
0 1 2
0
1
2
1 0 0
0 1 0
0 0 1
Cuadro 12.5: Matriz Identidad de orden 3 Ver programa 46 â&#x20AC;&#x153;Inicializar la Matriz Identidadâ&#x20AC;?. Programa 46 - Inicializar la Matriz Identidad #include <iostream.h> // P_Mat_01 const int MAX = 50;
CAP´ITULO 12. MATRICES Continuaci´ on programa 46
202
// Prototipos int Entrada_Int ( char Msj[] ); void Mat_Identidad ( int Mat[][MAX], int Length ); void Salida_Mat_Int ( int Mat[][MAX], int Length ); void main ( void ) { int Matriz[MAX][MAX]; int N; cout << "MATRIZ IDENTICA!!"; N = Entrada_Int ( "Orden : " ); Mat_Identidad
( Matriz, N
);
Salida_Mat_Int
( Matriz, N
);
}
Este programa define una constante entera llamada MAX, la cual tiene un valor de 50 y representa el n´ umero m´aximo de filas y columnas de la matriz, es decir, la cantidad de posiciones de memoria que se han reservado. Sin embargo, el usuario puede establecer un n´ umero de elementos que desee utilizar. En este caso, se lee el valor de N, el cual debe ser menor que MAX, aunque el programa no est´a validando esta entrada. Despu´es de conocer la cantidad de elementos que va a contener la matriz, se indica a C++ que llame a la funci´on Mat_Identidad, a la cual se le pasan como argumentos el nombre de la matriz y el tama˜ no especificado por el usuario. Luego, imprime completamente el contenido de la matriz llamando a la funci´on Salida_Mat_Int con los mismos argumentos.
12.1. PROBLEMAS RESUELTOS
203
Continuaci´ on programa 46 void Mat_Identidad ( int Mat[][MAX], int Length ) { int I, J; for ( I = 0 ; I { for ( J = 0 ; { if ( I == J { Mat[ I ][ } else { Mat[ I ][ } } }
< Length ; I++ ) J < Length ; J++ ) ) J ] = 1;
J ] = 0;
}
La funci´on Mat_Identidad asigna a la matriz recibida como par´ametro la Matriz Identidad. Este m´etodo utiliza el par´ametro Length para determinar el n´ umero de filas y columnas. Observe que la variable I controla las filas y J se encarga de controlar las columnas. La decisi´on interna determina que cuando I y J sean iguales se asigne un 1 y en caso contrario se asigne un 0. Es decir, los elementos de la diagonal principal tienen el mismo ´ındice en la fila y la columna. Observe que en los par´ametros de la funci´on ( int Mat[][MAX] se especifica un nombre para la matriz, los corchetes que representan las filas y los corchetes que representan las columnas. En el sitio en el cual se deben escribir las filas no se escribe nada pero en el espacio de las columnas se debe escribir el valor m´aximo solicitado para las columnas. Esto se debe a que es importante el n´ umero de columnas indica la extensi´on de cada fila.
CAP´ITULO 12. MATRICES Continuaci´ on programa 46
204
void Salida_Mat_Int ( int Mat[][MAX], int Length ) { int I, J; for ( I = 0 ; I < Length ; I++ ) { for ( J = 0 ; J < Length ; J++ ) { cout << "\t" << Mat[ I ][ J ]; } cout << "\n"; } }
La funci´on Salida_Mat_Int se encarga de imprimir en la pantalla una matriz especificada. Los elementos de la matriz se separan por un tabulador (\t). Cada fila se imprime en un rengl´on independiente, separadas por la instrucci´on cout << "\n";. Esta funci´on ser´a utilizada en los dem´as ejemplos. Naturalmente no se volver´a a explicar. 2. Escriba un programa que sume los elementos de la diagonal principal de una matriz cuadrada. Ver programa 47 “Suma de los elementos de la diagonal”. Programa 47 - Suma de los elementos de la diagonal #include <iostream.h> // P_Mat_02
12.1. PROBLEMAS RESUELTOS
205
Continuaci´ on programa 47 // Prototipos int **Crear_Matriz_Int ( int Fil, void Liberar_Matriz ( int **Mat, int Entrada_Int ( char Msj[] void Entrada_Mat_Int ( char Msj[], int Length void Salida_Mat_Int ( int **Mat, int Calc_Diag ( int **Mat, void Salida_Int ( char Msj[],
int int
Col Fil
); ); );
int **Mat, int int int
); Length ); Length ); Numero );
void main ( void ) { int **Matriz; int N, Suma, i; cout << "SUMA DE LOS ELEMENTOS DE LA DIAGONAL!!\n";
N
= Entrada_Int
( "Orden : "
Matriz
= Crear_Matriz_Int ( N, N
); );
Entrada_Mat_Int
( "Elemento " , Matriz, N );
Suma
( Matriz, N
);
( Matriz, N
);
Salida_Int
( "La suma es: ", Suma
);
Liberar_Matriz
( Matriz, N
);
= Calc_Diag
Salida_Mat_Int cout << "\n";
}
206
CAP´ITULO 12. MATRICES De forma similar al manejo de los vectores, cuando se desea utilizar matrices, a veces se desperdicia mucha memoria o en otras se reserva memoria insuficiente para desarrollar alg´ un programa. Por esta raz´on, el manejo de matrices con memoria est´atica no es el m´as apropiado. En este programa se ilustra otra forma de utilizar las matrices en las cuales se utiliza u ´nicamente la memoria necesaria. La funci´on Crear_Matriz_Int tiene como objetivo solicitar memoria para una matriz de enteros. Esta funci´on debe retornar un puntero doble, es decir, la direcci´on de memoria donde se almacena un puntero a la primera columna (“es un puntero que apunta a un puntero que apunta a un entero”). Como se trata de un puntero doble, es necesario anteponerle al nombre el s´ımbolo ** y se dice que retorna un puntero doble. De igual manera, las variables que reciben una direcci´on de memoria en donde hay otra direcci´on de memoria que apunta a un entero, deben tener ** en su nombre al momento de declararse (int **Matriz;). Observe que no se especifica el tama˜ no de la matriz, es decir, no se especifican ni el n´ umero de filas ni de columnas. Este tipo de variables se conocen con el nombre de punteros dobles y ser´an estudiadas m´as a fondo en el Volumen II de esta obra. En este libro, los punteros dobles ser´an utilizados u ´nicamente con el fin de declarar matrices en los cuales no se desperdiciar´a memoria. Este tipo de matrices son de tama˜ no din´amico. Este programa lee los elementos de la matriz mediante el llamado al m´etodo Entrada_Mat_Int. Este m´etodo recibe dos argumentos, un letrero que acompa˜ na cada entrada de elemento individual y una referencia a la matriz que ser´a le´ıda por el teclado. El m´etodo Calc_Diag se encarga de calcular la suma de los elementos de la diagonal. Finalmente se imprime la matriz y el resultado de la suma. La funci´on Liberar_Matriz se encarga de indicarle a C++ que la memoria que ten´ıa reservada para la matriz especificada puede ser liberada, es decir, deja de estar reservada y se convierte en memoria disponible. Se recomienda un manejo apropiado de la memoria y nunca dejar programas que reserven memoria y no la liberen al terminar de utilizarla.
12.1. PROBLEMAS RESUELTOS
207
Continuaci´ on programa 47 int **Crear_Matriz_Int ( int Fil, int Col ) { int **Mat; int I; Mat
= new int* [ Fil ];
for ( I = 0 ; I < Fil ; I++ ) { Mat[ I ] = new int [ Col ]; } return Mat; }
La funci´on Crear_Matriz_Int solicita memoria (new) para un vector ([ ]) punteros a enteros (int*) donde el par´ametro Fil especifica el tama˜ no o n´ umero de posiciones Mat = new int* [ Fil ];. Es decir, se crea la primera columna de la matriz como un vector de punteros. En otras palabras, hay Fil punteros que apuntan a las Fil filas. Para solicitar la memoria de cada uno de los elementos de cada vector, se utiliza el ciclo donde se desea reservar un n´ umero determinado por el par´ametro Col. Es decir, con el ciclo se reserva la memoria para cada una de las filas. En este caso Mat es un puntero doble temporal el cual contiene la direcci´on de la primera posici´on de la memoria reservada para la matriz. Dicha direcci´on es la que se retorna. Esta es una funci´on de uso frecuente en este cap´ıtulo y no ser´a explicada de nuevo.
CAP´ITULO 12. MATRICES Continuaci´ on programa 47
208
void Liberar_Matriz ( int **Mat, int Fil ) { int I; for ( I = 0 ; I < Fil ; I++ ) { delete [ ] Mat[ I ]; } delete [ ] Mat; }
De manera similar a la solicitud de memoria, es necesario liberarla cuando se ha dejado de usar. La instrucci´on delete se utiliza dentro de un ciclo para eliminar los elementos de cada uno de los vectores que representan las filas de la matriz. Con este procedimiento, queda un vector que representa la primera columna. Al terminar, se utiliza nuevamente delete para liberar la primera columna de la matriz. Este procedimiento es an´alogo al manejo que se hace en vectores para liberar la memoria. Esta funci´on se utiliza en los dem´as ejemplos que componen este cap´ıtulo. Por esta raz´on no ser´a explicada nuevamente. Continuaci´ on programa 47 void Entrada_Mat_Int ( char Msj[], int **Mat, int Length ) { int I, J;
El m´etodo Entrada_Mat_Int lee la matriz desde el teclado. Este m´etodo indica al usuario las coordenadas del elemento que se est´a solicitando.
12.1. PROBLEMAS RESUELTOS
209
Continuaci´ on programa 47 for ( I = 0 ; I < { for ( J = 0 ; J { cout << Msj Mat[ I ][ J } cout << "\n"; }
Length ; I++ ) < Length ; J++ ) << " [ " << I << " , " << J << " ]"; ] = Entrada_Int (": ");
}
Continuaci´ on programa 47 int Calc_Diag ( int **Mat, int Length ) { int I, Num; Num = 0; for ( I = 0 ; I < Length ; I++ ) { Num += Mat [ I ][ I ]; } return Num; }
El m´etodo Calc_Diag se encarga de sumar los elementos de la diagonal principal de la matriz. Debido a que dichos elementos tienen en sus coordenadas el mismo n´ umero para la fila y la columna, u ´nicamente se utiliza un ciclo. 3. Construir un programa que imprima la transpuesta de una matriz. Ver programa 48 “Imprimir la transpuesta de una matriz”.
CAP´ITULO 12. MATRICES
210
Programa 48 - Imprimir la transpuesta de una matriz #include <iostream.h> // P_Mat_03 // Prototipos int **Crear_Matriz_Int ( int Fil, void Liberar_Matriz ( int **Mat, int Entrada_Int ( char Msj[] void Entrada_Mat_Int ( char Msj[], int Fil, void Salida_Mat_Int ( int **Mat, int Col void Transpuesta_Mat ( int **Mat, int Col,
int int
Col Fil
int **Mat, int Col int Fil,
); ); ); ); );
int Fil, int **Mat_T );
void main ( void ) { int **Matriz, **Matriz_T; int Filas, Columnas, Filas_T, Columnas_T; cout << "MATRIZ TRANSPUESTA!!\n"; Filas = Entrada_Int ( "Numero de filas Columnas = Entrada_Int ( "Numero de Columnas
: " ); : " );
Filas_T = Columnas; Columnas_T = Filas; cout << "\n"; Matriz
= Crear_Matriz_Int ( Filas,
Columnas
Matriz_T = Crear_Matriz_Int ( Filas_T, Columnas_T
); );
Entrada_Mat_Int ( "Elemento " , Matriz, Filas, Columnas );
12.1. PROBLEMAS RESUELTOS
211
Continuaci´ on programa 48 Transpuesta_Mat ( Matriz, Filas, Columnas, Matriz_T
);
cout << "MATRIZ ORIGINAL\n"; Salida_Mat_Int
( Matriz, Filas, Columnas
);
cout << "\nMATRIZ TRANSPUESTA\n"; Salida_Mat_Int
( Matriz_T, Filas_T, Columnas_T );
Liberar_Matriz Liberar_Matriz
( Matriz, Filas ( Matriz_T, Filas_T
); );
}
Este programa lee los elementos de una matriz, crea la matriz transpuesta con el llamado a la funci´on Transpuesta_Mat y las imprime. Continuaci´ on programa 48 void Transpuesta_Mat ( int **Mat, int Fil, int Col, int **Mat_T ) { int I, J; for ( I = 0 ; I < Fil ; I++ ) { for ( J = 0 ; J < Col ; J++ ) { Mat_T[ J ][ I ] = Mat[ I ][ J ] ; } } }
CAP´ITULO 12. MATRICES
212
Esta funci´on invierte el orden de los ´ındices de tal manera que la disposici´on en filas y columnas de la matriz origen se convierta en una formaci´on de columnas y filas. Es decir, si la matriz origen es de N x M, la transpuesta ser´a de M x N. 4. Escriba un programa que intercambie dos filas de una matriz. Ver programa 49 “Intercambiar dos filas”. Programa 49 - Intercambiar dos filas #include <iostream.h> // P_Mat_04 // Prototipos int **Crear_Matriz_Int void Liberar_Matriz int Entrada_Int void Entrada_Mat_Int void void
( ( ( (
int Fil, int int **Mat, int char Msj[] char Msj[],int int Fil, int Salida_Mat_Int ( int **Mat, int Intercambio_Filas ( int **Mat, int int F1, int
void main ( void ) { int **Matriz, **Matriz_Sal; int Filas, Columnas, Fil1, Fil2; cout << "INTERCAMBIO DE DOS FILAS!!\n";
Col Fil
); ); );
**Mat, Col ); Fil, int Col ); Fil, int Col, F2, int **Mat_S );
12.1. PROBLEMAS RESUELTOS
213
Continuaci´ on programa 49 Filas Columnas
= Entrada_Int = Entrada_Int
( "Numero de filas ( "Numero de Columnas
: " : "
); );
cout << "\n"; Matriz = Crear_Matriz_Int ( Filas, Columnas Matriz_Sal = Crear_Matriz_Int ( Filas, Columnas Entrada_Mat_Int
Fil1 Fil2
= Entrada_Int = Entrada_Int
Intercambio_Filas
); );
( "Elemento " , Matriz, Filas, Columnas
);
( "Fila 1: " ( "Fila 2: "
); );
( Matriz, Filas, Columnas, Fil1, Fil2, Matriz_Sal
);
cout << "MATRIZ ORIGINAL\n"; Salida_Mat_Int
( Matriz, Filas, Columnas
);
cout << "\nMATRIZ DE SALIDA\n"; Salida_Mat_Int
( Matriz_Sal, Filas, Columnas );
Liberar_Matriz ( Matriz , Filas ); Liberar_Matriz ( Matriz_Sal, Filas ); }
Este programa lee la matriz origen y las filas que se desea intercambiar. A continuaci´on llama al m´etodo Intercambio_Filas al cual le pasa como argumentos referencia a las matrices origen y destino, y las filas que se va a intercambiar. Luego se imprimen las dos matrices.
214
CAP´ITULO 12. MATRICES Continuaci´ on programa 49
void Intercambio_Filas ( int **Mat, int Fil, int Col, int F1, int F2, int **Mat_S ) { int I, J, Aux; for ( I = 0 ; I < Fil ; I++ ) { for ( J = 0 ; J < Col ; J++ ) { if ( I != F1 && I != F2 ) { Mat_S[ I ][ J ] = Mat[ I ][ J ]; } else { if ( I == F1 ) { Mat_S[ I ][ J ] = Mat[ F2 ][ J ]; } else { Mat_S[ I ][ J ] = Mat[ F1 ][ J ]; } } } } }
El m´etodo Intercambio_Filas utiliza decisiones anidadas dentro de los ciclos que controlan todos los elementos de la matriz para establecer si el valor de la variable I corresponde a una de las dos filas que se quieren intercambiar o no. En todos los casos, se realiza la asignaci´on correspondiente para formar la matriz de salida.
12.1. PROBLEMAS RESUELTOS
215
5. Escriba un programa que genere cuadrados m´agicos de orden impar. Un cuadrado m´agico es una disposici´on especial de n´ umeros enteros en una matriz, donde la suma de los elementos de las filas, las columnas o las diagonales es el mismo. Ver tabla 12.6.
0 1 2 3 4
0
1
2
3
4
17 23 4 10 11
24 5 6 12 18
1 7 13 19 25
8 14 20 21 2
15 16 22 3 9
Cuadro 12.6: Cuadrado M´agico de orden 5 Ver programa 50 “Cuadrados m´agicos de orden impar”. Programa 50 - Cuadrados m´ agicos de orden impar #include <iostream.h> // P_Mat_05 // Prototipos int **Crear_Matriz_Int void Liberar_Matriz int Entrada_Int void Salida_Mat_Int void Cuadro_Magico void Inicializa_Matriz
( ( ( ( ( (
int int char int int int
Fil, **Mat, Msj[] **Mat, **Mat, **Mat,
int Col int Fil
); ); ); int Fil, int Col ); int Fil, int Col ); int Fil, int Col );
CAP´ITULO 12. MATRICES Continuaci´ on programa 50
216
void main ( void ) { int **Matriz; int N; cout << "CUADRADO MAGICO DE ORDEN IMPAR!!\n"; N
= Entrada_Int
if ( N % 2 == 1 ) { Matriz = Crear_Matriz_Int Inicializa_Matriz Cuadro_Magico Salida_Mat_Int Liberar_Matriz } else { cout << "ERROR!!"; }
( "Orden
( ( ( ( (
N, N Matriz, Matriz, Matriz, Matriz,
: " );
N, N N, N N, N N
); ); ); ); );
}
Este programa valida que el orden de la matriz sea impar para poder realizar correctamente su ejecuci´on, debido a que se utiliza un algoritmo exclusivamente para matrices de tama˜ no impar. A continuaci´on, se inicializa la matriz con ceros, para facilitar la identificaci´on de posiciones vac´ıas. Luego se llama al m´etodo Cuadro_Magico para generar el cuadrado m´agico correspondiente que finalmente se imprime.
12.1. PROBLEMAS RESUELTOS
217
Continuaci´ on programa 50 void Inicializa_Matriz ( int **Mat, int Fil, int Col ) { int I, J; for ( I = 0 ; I < Fil ; I++ ) { for ( J = 0 ; J < Col ; J++ ) { Mat[ I ][ J ] = 0; } } }
El m´etodo Inicializa_Matriz se encarga de poner en 0 todos los elementos de la matriz cuya referencia se recibi´o por par´ametro. Es importante tener en cuenta que para efectos del algoritmo, un cero corresponde a un espacio sin ocupar en el cuadrado m´agico. Continuaci´ on programa 50 void Cuadro_Magico ( int **Mat, int Fil, int Col ) { int F, C, Num, Prox_F, Prox_C; F = 0; C = Col / 2;
CAP´ITULO 12. MATRICES Continuaci´ on programa 50
218
for ( Num = 1 ; Num <= Fil * Col ; Num++ ) { Mat[ F ][ C ] = Num; Prox_F = ( F - 1 + Fil ) % Fil; Prox_C = ( C + 1 + Col ) % Col; if ( Mat[ Prox_F ][ Prox_C ] == 0 ) { F = Prox_F; C = Prox_C; } else { F = F + 1; } } }
El m´etodo Cuadro_Magico se encarga de asignar las diferentes posiciones de la matriz, siguiendo el siguiente procedimiento: El n´ umero 1 se ubica en la primera fila en la columna del centro. El siguiente n´ umero se escribe en la celda de la siguiente columna y fila anterior, en forma circular. Es decir, la fila anterior a la primera es la u ´ltima o la columna siguiente a la u ´ltima es la primera, mientras est´e libre. En caso de que una posici´on est´e ocupada, el n´ umero ser´a ubicado en la misma columna, de la fila siguiente. Un cuadrado m´agico de tama˜ no N tiene N 2 elementos. Por lo tanto, el procedimiento termina cuando el cuadrado est´a completamente lleno.
12.2. PROBLEMAS PROPUESTOS
12.2.
219
Problemas propuestos
Suponga por cada problema, la existencia de una matriz de tama˜ no N por M. 1. Encuentre los elementos mayor y menor. Adem´as, calcule el promedio de todos sus elementos. 2. Determine si la matriz es o no sim´etrica. Una matriz es sim´etrica si es cuadrada (N es igual a M), los elementos por encima de la diagonal son iguales a los elementos por debajo en forma de espejo. Ver un ejemplo en la tabla 12.7.
0 1 2
0
1
2
a b
a c
b c -
Cuadro 12.7: Matriz sim´etrica de orden 3
3. Determine si la matriz es o no un cuadrado m´agico. 4. Elimine una fila y columna especificadas y construya otra matriz con el resultado. 5. En la matriz se almacenan las notas de un curso. Suponga que una fila corresponde a las notas parciales de un estudiante. Calcule la nota definitiva de todos los estudiantes, el promedio general del curso, el n´ umero de estudiantes que ganaron y la cantidad de estudiantes que perdieron el curso. 6. Determine si todos y cada uno de los elementos de la diagonal principal, est´an otra posici´on de la matriz.
CAP´ITULO 12. MATRICES
220
7. Indique si los elementos de la diagonal principal corresponden a los elementos de la diagonal secundaria. Ver tabla 12.8.
0 1 2
0
1
2
a c
b -
a c
Cuadro 12.8: Matriz con digonales iguales de orden 3
8. Determine si en la matriz existen por lo menos dos ceros consecutivos en una misma fila, o en una misma columna. 9. Calcule el producto entre la matriz de N x M y por otra matriz dada por el usuario de M x N. Recuerde que el producto de estas dos matrices produce una tercera matriz de N x N elementos. ci,j =
M −1 X
ai,k × bk,j
∀ a ∈ A, ∀ b ∈ B,
k=0
i = 0, 1, ..., N − 1
j = 0, 1, ..., N − 1
10. Dadas dos matrices de N x M llamadas A y B respectivamente, calcule el valor de k, si existe, en donde la matriz A sea igual a k por la matriz B.
Cap´ıtulo 13 Para el Volumen II Este cap´ıtulo pretende mostrar r´apidamente algunos elementos que ser´an tratados en el libro “C++ volumen II: Objetos”, tales como excepciones, cadenas de caracteres, argumentos del m´etodo main, archivos de acceso secuencial y directo, clases, entre otros. Naturalmente, no se har´a una explicaci´on detallada, simplemente, esperamos que con este cap´ıtulo se puedan complementar los fundamentos de C++. Algunos temas tales como excepciones y cadenas pertenecen al ANSI C++ y no est´an disponibles en todos los compiladores de C++. No todos los compiladores soportan el est´andar ANSI C++. El archivo de biblioteca string hace parte de dicho est´andar, lo mismo que stdexcept. Por lo tanto, algunos compiladores como g++ (C++ para Linux) permiten el uso de este est´andar mientras que otros como Turbo C++ Versi´ on 3.0 para DOS no.
13.1.
Manejo de Excepciones
Una excepci´on es un mecanismo que captura la ocurrencia de errores y mejora su tratamiento evitando as´ı que un programa sea abortado, por ejemplo, al ocurrir una divisi´on por cero, un desbordamiento aritm´etico, o tener el ´ındice de un arreglo por fuera de los l´ımites, entre otros. 221
CAP´ITULO 13. PARA EL VOLUMEN II
222
El uso de las excepciones aumenta la claridad del c´odigo escrito en C++ y lo hace m´as robusto frente a posibles fallas en la ejecuci´on normal de un programa. Adem´as, se utilizan en aquellas situaciones en las que es posible que el sistema se recupere ante el error que la gener´o. Las excepciones son apropiadas cuando se desarrollan componentes de un sistema por separado, facilitando su integraci´on. En todos los casos se recomienda incluir el manejo de excepciones desde el momento en que se dise˜ na una aplicaci´on, y no despu´es de su implementaci´on. Para el manejo de excepciones es necesario utilizar las instrucciones try y catch.
Ejemplos 1. Elaborar un programa que realice la divisi´on entre dos n´ umeros enteros. Controle la excepci´on generada por un cero en el divisor de manera que pueda evitar que el programa termine de manera anormal. Ver programa 51 “Excepciones 1”. Programa 51 - Excepciones 1 #include <iostream> #include <string> #include <stdexcept> // P_Exc_01 int Entrada_Int ( string Msj ); int Calc_Cociente ( int Numero1, int Numero2 ) void Salida_Int ( string Msj, int Numero );
13.1. MANEJO DE EXCEPCIONES
223
Continuaci´ on programa 51 void main ( void ) { int Dividendo, Divisor, Cociente; cout << "DIVISION ENTERA!!" << endl; Dividendo = Entrada_Int ( "Dividendo: " Divisor = Entrada_Int ( "Divisor : "
); );
try { if ( Divisor == 0 ) { throw exception(); } Cociente = Calc_Cociente( Dividendo, Divisor ); Salida_Int ( "Resultado: ", Cociente ); } catch ( ... ) { cerr << "ERROR!! Division por cero. " << endl; } }
La explicaci´on de este programa sin el uso de excepciones se encuentra en la p´agina 57 (P_Dec_01). Debido a esta situaci´on, nos centraremos u ´nicamente en las instrucciones que permiten el manejo de las excepciones. Para el manejo de las excepciones es necesario la inclusi´on del archivo de biblioteca stdexcept, en donde se encuentra definido el m´etodo exception(). El bloque que se escribe a continuaci´on de la instrucci´on try es el que posiblemente genere un error. En este caso, se puede generar una divisi´on por cero. En caso de que el divisor sea cero, throw exception(); lanza una excepci´on que ser´a capturada por la instrucci´on catch.
CAP´ITULO 13. PARA EL VOLUMEN II
224
catch requiere un argumento en el que se especifica la excepci´on que se desea manipular. En el programa anterior, la excepci´on a manejar es ..., es decir, cualquier excepci´on. En este ejemplo, la excepci´on surge al encontrar que el divisor es cero. La instrucci´on cerr se utiliza para imprimir el mensaje especificado en el dispositivo de error por defecto, normalmente la pantalla. 2. Elabore un programa que mediante el uso de un vector de enteros ilustre el manejo de diferentes excepciones. Ver programa 52 “Excepciones 2”. Programa 52 - Excepciones 2 #include <iostream> #include <string> #include <stdexcept> // P_Exc_02 const int MAXIMO = 5; int Entrada_Int
( string Msj );
void main ( void ) { int Indice; int Vector[ MAXIMO ]; cout << "EXCEPCIONES DE ARREGLOS!!" << endl;
13.1. MANEJO DE EXCEPCIONES
225
Continuaci´ on programa 52 try { Indice = Entrada_Int ( "Posicion: "
);
if ( Indice == 0 ) { throw exception(); } if ( Indice < 0 || Indice > MAXIMO ) { throw range_error(""); } Vector[ Indice ] = 100 / Indice; } catch ( range_error e ) { cerr << "ERROR!! Fuera del rango." << endl; } catch ( exception e ) { cerr << "ERROR!! Division por cero. " << endl; } }
El programa P_Exc_02 no tiene ninguna utilidad en particular. Simplemente es utilizado con el fin de ilustrar el manejo de algunas excepciones frecuentemente presentadas en C++. En este caso, la variable Indice debe capturar un entero. Si por alguna raz´on el usuario ingresa un cero ea letra o un n´ umero con punto decimal, C++ genera la excepci´on exception(). Por otra parte, si el usuario utiliza una posici´on por fuera de los l´ımites de un arreglo, se
CAP´ITULO 13. PARA EL VOLUMEN II
226
genera la excepci´on range_error(""). En el ejemplo solo se aceptar´ıan n´ umeros enteros entre 0 y 4 (MAXIMO - 1), sin embargo, la posici´on cero no puede ser aceptada por este valor se utiliza en la operaci´on Vector[ Indice ] = 100 / Indice;. Es de anotar que solo uno de los bloques catch se ejecuta, de acuerdo a la excepci´on que ha capturado, enviando un mensaje al dispositivo est´andar de error. Observe que es el programador el responsable de lanzar la excepci´ on adecuada, dependiendo de la ocurrencia o no de alguna situaci´on 3. Elabore un programa que utilice las excepciones para controlar los datos de entrada de manera que evite los errores producidos por entradas no v´alidas. Ver programa 53 “Excepciones 3”. Programa 53 - Excepciones 3 #include <iostream> #include <string> #include <stdexcept> // P_Exc_03 const int MAXIMO = 5; int Entrada_Int ( string Msj ); void main ( void ) { int Indice; int Repetir; int Vector[ MAXIMO ]; cout << "EXCEPCIONES DE ARREGLOS!!" << endl;
13.1. MANEJO DE EXCEPCIONES
227
Continuaci´ on programa 53 do { Repetir = false; try { Indice = Entrada_Int ( "Posicion: "
);
if ( Indice == 0 ) { throw exception(); } if ( Indice < 0 || Indice > MAXIMO ) { throw range_error(""); } Vector[ Indice ] = 100 / Indice; } catch ( range_error e ) { cerr << "ERROR!! Fuera del rango." << endl; Repetir = true; } catch ( exception e ) { cerr << "ERROR!! Division por cero. " << endl; Repetir = true; } } while ( Repetir == true ); }
CAP´ITULO 13. PARA EL VOLUMEN II
228
El programa P_Exc_03 es el mismo programa P_Exc_02 con la diferencia que mediante el ciclo do - while y la variable Repetir se valida la entrada para evitar errores derivados de excepciones.
13.2.
Cadenas de caracteres
Una cadena de caracteres es una serie de caracteres que son tratados como una unidad, la cual puede contener letras, n´ umeros y s´ımbolos. En C++, una cadena se maneja como un objeto de la clase string. Para poder utilizar esta clase, es necesario incluir el archivo de biblioteca string. Observe cuidadosamente que no incluye la extensi´on .h como en los otros casos.
Ejemplos 1. Elabore un programa que concatene dos cadenas de caracteres y muestre la longitud de la cadena resultante. Ver programa 54 “Cadenas 1”. El programa anterior concatena dos cadenas y calcula la longitud de la cadena concatenada. Al finalizar, imprime los resultados. La uni´on o concatenaci´on de las cadenas se realiza mediante la instrucci´on Cad3 = Cad1 + Cad2;, donde Cad3 es la cadena resultante de unir Cad1 y Cad2. El s´ımbolo + es el encargado de realizar esta operaci´on. El m´etodo length ( ), asociado al objeto Cad3 permite obtener su longitud. La funci´on Entrada_Str es similar a las funciones utilizados en el libro para leer datos de cualquier tipo. En este caso, observe que el tipo de dato que retorna esta funci´on es string, lo mismo que la variable temporal Cadena. Algo similar ocurre con el m´etodo Salida_Str. Observe la instrucci´on getline( cin, Cadena ); la cual es utilizada para leer una cadena de caracteres, en este caso Cadena, de tal manera que incluya espacios en blanco, hasta que detecte un "\n", es decir, hasta presionar la tecla <Enter>.
13.2. CADENAS DE CARACTERES
Programa 54 - Cadenas 1 #include<iostream.h> #include<string> // P_Cad_01 string Entrada_Str ( string Msj ); void Salida_Str ( string Msj, string Cadena ); void Salida_Int ( string Msj, int Numero ); void main ( void ) { string Cad1, Cad2, Cad3; int Longitud; cout << "CONCATENAR DOS CADENAS!!" << endl; Cad1 Cad2
= Entrada_Str ( "Ingrese un mensaje: " ); = Entrada_Str ( "Ingrese otro mensaje: " );
Cad3 Longitud
= Cad1 + Cad2; = Cad3.length ( );
Salida_Str ( "La cadena concatenada es: ", Cad3); Salida_Int ("La longitud es: ", Longitud ); }
229
CAP´ITULO 13. PARA EL VOLUMEN II Continuaci´ on programa 54
230
string Entrada_Str ( string Msj ) { string Cadena; cout << Msj ; getline( cin, Cadena ); return Cadena; }
2. Elabore un programa que convierta una cadena de caracteres a su equivalente en may´ usculas. Ver programa 55 “Cadenas 2”. Este programa convierte una cadena a may´ usculas mediante la funci´on llamada toUpperCase(), la cual recibe como par´ametro una cadena y devuelve su equivalente convertida a may´ usculas. En caso de que el usuario desee convertir a min´ usculas, podr´ıa construir una funci´on similar. La funci´on toUpperCase recibe como par´ametro una cadena de caracteres (string) y la conversi´on a may´ usculas se realiza gracias a la compatibilidad de las cadenas con los arreglos de tipo char. La instrucci´on Cad = Cadena; se encarga de asignar a la cadena Cad el contenido de la cadena Cadena con el fin de adecuar el tama˜ no de la cadena que ser´a retornada por esta funci´on. Si desea hacer una funci´on similar que convierta a min´ usculas, simplemente utilice la funci´on tolower en lugar de toupper. Estas dos funciones pertenecen al archivo de biblioteca ctype.h.
13.2. CADENAS DE CARACTERES
Programa 55 - Cadenas 2 #include <iostream.h> #include <ctype.h> #include <string> // P_Cad_02 string Entrada_Str ( string Msj ); void Salida_Str ( string Msj, string Cadena ); string toUpperCase ( string Cadena ); void main ( void ) { string Cad1, Cad2; cout << "CONVERTIR A MAYUSCULA!!" << endl; Cad1 = Entrada_Str ( "Ingrese un mensaje: " ); Cad2 = toUpperCase ( Cad1 ); Salida_Str ( "La cadena convertida es: ", Cad2); }
231
CAP´ITULO 13. PARA EL VOLUMEN II Continuaci´ on programa 55
232
string toUpperCase ( string Cadena ) { int i; string Cad; Cad = Cadena; for ( i = 0; i < Cadena.length() ; i++ ) { Cad[i] = toupper ( Cadena [ i ] ); } return Cad; }
3. Elaborar un programa que compare dos cadenas de caracteres y determine si son iguales o no. Ver programa 56 “Cadenas 3”. Programa 56 - Cadenas 3 #include <iostream.h> #include <string> // P_Cad_03 string Entrada_Str ( string Msj );
´ 13.3. ARGUMENTOS DEL METODO MAIN Continuaci´ on programa 56
233
void main ( void ) { string Cad1, Cad2; cout << "COMPARAR DOS CADENAS!!" << endl; Cad1 = Entrada_Str ( "Ingrese un mensaje : " ); Cad2 = Entrada_Str ( "Ingrese otro mensaje: " ); if ( Cad1 == Cad2 ) { cout << "Son iguales" << endl; } else { cout << "Son diferentes" << endl; } }
Este programa compara dos cadenas para determinar si son iguales o no. Para encontrar el valor de verdad de la comparaci´on de las cadenas se utiliza una decisi´on simple.
13.3.
Argumentos del m´ etodo main
Los argumentos del m´etodo main es la forma que ofrece C++ para recibir datos desde la l´ınea de comandos con el fin de que sean procesados desde el programa. La forma de pasar argumentos a un programa es en el momento de la ejecuci´on, escribiendo en forma de cadena de caracteres uno a uno el grupo de argumentos para que sea procesado en el programa.
CAP´ITULO 13. PARA EL VOLUMEN II
234
Ejemplos 1. Elabore un programa que imprima los argumentos con los cuales se hace el llamado a un prorgama. Ver programa 57 “Argumentos 1”. Programa 57 - Argumentos 1 #include <iostream.h> // P_Arg_01 void main ( int N_Arg, char *Arg[ ] ) { int I; cout << "ARGUMENTOS DEL METODO PRINCIPAL!!" << endl; for ( I = 0; I < N_Arg; I++ ) { cout << "argumento [" << I << "]: " << Arg[ I ] << endl; } }
Este programa imprime la lista de argumentos con los cuales fue llamado el programa desde la l´ınea de comandos. Es decir, el usuario, debe llamar al programa compilado utilizando el nombre del programa y a continuaci´on los argumentos. Ejemplo: P_Arg_01 uno dos tres cuatro El resultado de la ejecuci´on ser´ıa: Ver “Resultado Argumentos 1”. Observe que el arreglo de cadenas de caracteres se compone de cinco elementos llamados P_Arg_01, uno, dos, tres y cuatro y corresponden a las primeras cuatro posiciones 0...4.
´ 13.3. ARGUMENTOS DEL METODO MAIN Resultado Argumentos 1
235
ARGUMENTOS DEL METODO PRINCIPAL!! argumento [ 0 ]: P_Arg_01 argumento [ 1 ]: uno argumento [ 2 ]: dos argumento [ 3 ]: tres argumento [ 4 ]: cuatro
2. Elabore un programa que sume dos n´ umeros enteros. El programa deber´a soportar la entrada de los n´ umeros a trav´es de los argumenos del m´etodo principal. Ver programa 58 “Argumentos 2”. Programa 58 - Argumentos 2 #include <iostream.h> #include <string> #include <stdlib.h> // P_Arg_02 int Entrada_Int ( string Msj ); void Salida_Int ( string Msj, int Numero ); void main ( int N_Arg, char *Arg[ ] ) { int Num1, Num2, Suma; cout << "ARGUMENTOS DEL METODO PRINCIPAL!!" << endl;
CAP´ITULO 13. PARA EL VOLUMEN II Continuaci´ on programa 58
236
if ( N_Arg == 3) { Num1 = atoi ( Arg [ 1 ] ); Num2 = atoi ( Arg [ 2 ] ); } else { Num1 = Entrada_Int ( "Ingrese el primer numero: " ); Num2 = Entrada_Int ( "Ingrese el primer numero: " ); } Suma = Num1 + Num2; Salida_Int ( "La suma es: ", Suma ); }
Este programa pretende sumar dos enteros que son pasados como par´ametros desde la l´ınea de comandos, por ejemplo: P_Arg_02 4 6 En este caso, se asigna a la variable Num1 el valor de 4 y a Num2 el valor de 6. Si el n´ umero de argumentos N_Arg no es exactamente 3, se solicitan desde el teclado los dos n´ umeros que ser´an sumados. Observe la forma como se convierte a entero el valor del argumento, y que el nombre del vector de cadenas que se recibe desde la l´ınea de comandos es arbitrario, es decir, el usuario puede utilizar el que desee.
13.4.
Archivos
Un archivo es un mecanismo que permite almacenar los datos en alg´ un dispositivo de almacenamiento secundario (disco duro, diskete, CD-R, entre otros), de manera que no se pierdan al terminar la ejecuci´on de un programa. Los
13.4. ARCHIVOS
237
datos que se almacenan en archivos se conocen con el nombre de datos persistentes. Para C++, un archivo puede ser un flujo secuencial de bytes el cual termina con un marcador de fin de archivo o en un n´ umero de bytes especificado. Cuando un arhivo se abre, se crea un objeto y se asocia un flujo (stream) a dicho objeto. Un flujo permite comunicar un programa y un archivo o dispositivo en particular. Existen diferentes clases de archivos. Con un archivo de acceso secuencial cada solicitud de entrada y salida sucesiva lee o escribe el siguiente conjunto de datos consecutivos en el archivo. Por otra parte, los archivos de acceso directo pueden dirigirse a cualquier parte del archivo.
Ejemplos 1. Elabore un programa que permita crear un archivo de acceso secuencial e imprimir su contenido. Ver programa 59 “Archivos de acceso secuencial”. Este programa lee del teclado l´ıneas de texto hasta que el usuario ingresa una cadena que contiene u ´nicamente el caracter \n, es decir, presiona la tecla <Enter> al comienzo de una nueva l´ınea. Cada l´ınea ingresada es almacenada en el archivo y cuando el usuario indique el final de la entrada el contenido del archivo se imprime en la pantalla. Este programa llama la funci´on Escr_Arch_Dir para leer el texto que se desea almacenar, y Leer_Arch_Dir para imprimir en pantalla el contenido del archivo especificado. Observe que este programa controla excepciones generadas por fallas al intentar escribir o leer un archivo de acceso secuencial especificado.
CAP´ITULO 13. PARA EL VOLUMEN II
238
Programa 59 - Archivos de acceso secuencial #include #include #include #include
<iostream.h> <fstream.h> <string> <stdexcept>
// P_Arc_01 string Entrada_Str ( string Msj ); void Escr_Arch_Sec ( char Nombre[] ); void Leer_Arch_Sec ( char Nombre[] ); void main ( void ) { cout << "ARCHIVO DE ACCESO SECUENCIAL!!\n" << endl; cout << "Presione <Enter> en una nueva" cout << " linea para terminar!!\n " try { Escr_Arch_Sec ( "Temp1.txt" ); Leer_Arch_Sec ( "Temp1.txt" ); } catch ( exception e ) { cerr << "ERROR en el archivo." << endl; } }
<< endl; << endl;
13.4. ARCHIVOS
239 Continuaci´ on programa 59
void Escr_Arch_Sec ( char Nombre[] ) { ofstream Arch_Out; string Cadena; Arch_Out.open ( Nombre ); if ( Arch_Out.fail( ) ) { throw exception(); } do { Cadena = Entrada_Str ( "Ingrese un mensaje: " ); Cadena += "\n"; Arch_Out << Cadena; } while ( Cadena != "\n" ); Arch_Out.close( ); }
La funci´on Escr_Arch_Sec recibe como par´ametro el nombre del archivo en el que se desea almacenar un texto. Para enviar informaci´on al archivo es necesario crear un flujo de salida de datos llamado Arch_Out, mediante el comando ofstream Arch_Out;. La instrucci´on ofstream Arch_Out; indica que Arch_Out es un objeto de la clase ofstream, es decir, un flujo de salida hacia un archivo. Arch_Out.open ( Nombre ); abre el archivo asociado a Arch_Out con el nombre especificado en la cadena Nombre. De este modo, Arch_Out puede ser utilizado. Si por alguna raz´on el archivo asociado con el flujo Arch_Out falla, se genera una excepci´on que es capturada en la funci´on main por la orden
CAP´ITULO 13. PARA EL VOLUMEN II
240 catch.
Ver “Excepcion por falla en el archivo de salida”. Excepcion por falla en el archivo de salida if ( Arch_Out.fail( ) ) { throw exception(); }
La funci´on Entrada_Str permite que la variable Cadena reciba una entrada desde el teclado. El contenido de la variable Cadena se almacenar´a en el archivo. A esta cadena se le a˜ nade el caracter \n para que en el archivo se almacenen los saltos de l´ınea, con la instrucci´on Cadena += "\n";. La instrucci´on Arch_Out << Cadena; env´ıa el contenido de Cadena al flujo Arch_Out, que se encuentra asociado a un archivo. Cuando el usuario env´ıa una cadena que contiene solamente el caracter \n, termina el ciclo, y se procede a cerrar el archivo con la instrucci´on Arch_Out.close( );. La funci´on Leer_Arch_Sec recibe como par´ametro el nombre del archivo que se quiere imprimir en la pantalla. Para leer informaci´on del archivo es necesario crear un flujo de entrada de datos llamado Arch_In, mediante el comando ifstream Arch_In;. La instrucci´on ifstream Arch_In; indica que Arch_In es un objeto de la clase ifstream, es decir, un flujo de entrada hacia un archivo. Arch_In.open ( Nombre ); abre el archivo asociado a Arch_In con el nombre especificado en la cadena Nombre. De este modo, Arch_In puede ser utilizado. Si el archivo asociado con el flujo Arch_In falla, se genera una excepci´on que es capturada en la funci´on main por la orden catch. Ver “Excepcion por falla en el archivo de entrada”.
13.4. ARCHIVOS
241 Continuaci´ on programa 59
void Leer_Arch_Sec ( char Nombre[] ) { ifstream Arch_In; string Cadena; Arch_In.open ( Nombre ); if ( Arch_In.fail( ) ) { throw exception(); } Arch_In >> Cadena; while ( Arch_In.eof( ) == false ) { cout << Cadena << endl; Arch_In >> Cadena; } Arch_In.close( ); }
Excepcion por falla en el archivo de entrada if ( Arch_In.fail( ) ) { throw exception(); }
CAP´ITULO 13. PARA EL VOLUMEN II
242
La instrucci´on Arch_In >> Cadena; recibe el contenido de Arch_In en la variable Cadena. El ciclo while a continuaci´on verifica que el archivo no haya llegado al final con la condici´on Arch_In.eof( ) == false. En caso de que esta condici´on sea verdadera, se imprime en pantalla el contenido de Cadena y se lee la siguiente cadena del flujo de entrada. Al terminar de leer el contenido del archivo asociado al flujo de entrada, se cierra con el comando Arch_In.close( );. 2. Elabore un programa que permita crear un archivos de acceso directo e imprimir su contenido. Ver programa 60 “Archivos de acceso directo”. Programa 60 - Archivos de acceso directo #include <iostream.h> #include <fstream.h> #include <stdexcept> // P_Arc_02 const int MAX = 30; void void
Escr_Arch_Dir ( char Nombre [ ] ); Leer_Arch_Dir ( char Nombre [ ] );
void main ( void ) { cout << "ARCHIVO DE ACCESO DIRECTO!!\n" << endl; cout << "Presione <Enter> en una nueva" cout << " linea para terminar!!\n "
<< endl; << endl;
13.4. ARCHIVOS
243 Continuaci´ on programa 60
try { Escr_Arch_Dir ( "Temp1.txt" ); Leer_Arch_Dir ( "Temp2.txt" ); } catch ( exception e ) { cerr << "ERROR en el archivo." << endl; } }
De manera similar a los archivos de acceso secuencial, este programa llama las funciones Escr_Arch_Dir y Leer_Arch_Dir para crear e imprimir en pantalla el contenido del archivo especificado. Continuaci´ on programa 60 void Escr_Arch_Dir ( char Nombre [ ] ) { ofstream Arch_Out; char Cadena [ MAX ]; Arch_Out.open ( Nombre ); if ( Arch_Out.fail ( ) ) { throw exception(); }
CAP´ITULO 13. PARA EL VOLUMEN II Continuaci´ on programa 60
244
while ( true ) { cout << "Ingrese un mensaje: "; cin.getline ( Cadena, MAX ) ; if ( Cadena [ 0 ] == ’\0’ ) { break; } Arch_Out.write ( Cadena, MAX ); } Arch_Out.close ( ); }
La funci´on Escr_Arch_Dir recibe como par´ametro el nombre del archivo en el que se desea almacenar un texto. La instrucci´on ofstream Arch_Out; indica que Arch_Out es un objeto de la clase ofstream. A continuaci´on se abre el archivo con Arch_Out.open ( Nombre ); y si al intentar esta operaci´on se presenta una falla se genera una excepci´on que ser´a capturada en la funci´on main. Luego se lee una cadena de una longitud m´axima establecida en la constante MAX. Si esta cadena es diferente a cadena vac´ıa, se escribe en el archivo con Arch_Out.write ( Cadena, MAX );. Si la cadena contiene solo \n el ciclo se rompe y se cierra el archivo. Es de anotar que en este caso, las cadenas almacenadas tendr´an siempre el tama˜ no establecido en MAX aunque no sea utilizado todo este espacio asignado. Esta es una de las principales diferencias con los archivos de acceso secuencial.
13.4. ARCHIVOS
245 Continuaci´ on programa 60
void Leer_Arch_Dir ( char Nombre [ ] ) { ifstream Arch_In; char Cadena [ MAX ]; int i; Arch_In.open ( Nombre ); if ( Arch_In.fail ( ) ) { throw exception(); } Arch_In.read ( Cadena, MAX ); while ( Arch_In.eof ( ) == false ) { cout << Cadena << endl; Arch_In.read ( Cadena, MAX ); } Arch_In.close ( ); }
La funci´on Leer_Arch_Dir recibe como par´ametro el nombre del archivo que se quiere imprimir. De manera similar al ejemplo anterior, es necesario crear el flujo de entrada con ifstream Arch_In;. A continuaci´on, Arch_In.open ( Nombre ); asocia el flujo con el archivo especificado en la cadena Nombre. Si se presenta alguna falla, se genera una excepci´on, controlada desde la funci´on main. Luego, Arch_In.read ( Cadena, MAX ); lee una cadena de tama˜ no MAX y si no se ha llegado al final del archivo se imprime en la pantalla el contenido de Cadena y se lee la cadena siguiente.
246
CAP´ITULO 13. PARA EL VOLUMEN II Esta operaci´on se controla mediante el ciclo while con la condici´on Arch_In.eof ( ) == false. Al terminar de imprimir el archivo se cierra con el comando Arch_In.close( );.
Bibliograf´ıa [1] ANTONAKOS, J.L. y MANSFIELD, K.C.: Programaci´ on estrucurada en C.. Prentice Hall. Madrid, 1997. [2] BECERRA, C´esar: Algoritmos: Conceptos b´asicos. Por computador Ltda. Tercera edici´on. Santaf´e de Bogot´a, D.C., 1991. [3] BECERRA, C´esar: Lenguaje C: El nuevo concepto. Por computador Ltda. Octava edici´on. Santaf´e de Bogot´a, D.C., 1996. [4] BECERRA, C´esar: Turbo Pascal. Por computador Ltda. Cuarta edici´on. Santaf´e de Bogot´a, D.C., 1987. [5] CAIRO, Oswaldo: Metodolog´ıa de la programaci´ on. Tomos I y II. Computec - Alfaomega Grupo Editor. Santaf´e de Bogot´a, D.C., 1996. [6] DEITEL, H.M. y DEITEL, P.J.: Como programar en C/C++. Prentice Hall. Segunda edici´on. M´exico, 1995. [7] JOYANES, Luis: Programaci´ on en Turbo Pascal. Mc Graw Hill. Madrid, 1992. [8] SAVITCH, Walter: Resoluci´ on de problemas con C++: El objeto de la programaci´ on. Segunda Edici´on, Prentice Hall. Madrid, 2000. [9] SCHILDT, Herbert: Programaci´ on en Turbo C.. Mc Graw Hill. Segunda edici´on. 1990.
247
248
BIBLIOGRAF´IA
´Indice alfab´ etico A actividad . . . . . . . . . . . . . . . . . . . . . . . . 2 actualizar . . . . . . . . . . . . . . . . . . . . . . 39 acumulador . . . . . . . . . . . . . . . . . . . 133 agenda . . . . . . . . . . . . . . . . . . . . . . . . . . 2 algoritmo . . . . . . . . . . . . . . . . . . . . . . . 1 almacenamiento secundario . . . 237 an´alisis. . . . . . . . . . . . . . . . . . . . . . . . . 74 ANSI C++ . . . . . . . . . . . . . . . . . . . 221 apuntador . . . . . . . . . . . . . . . . 181, 206 archivo. . . . . . . . . . . . . . . . . . . . . . . .237 acceso directo . . . . . . . . . . . . . 221, 242 secuencial . . . . . . . . . . 221, 237 argumentos . . . . . . . . . . . . . . . . . . . . 41 del main . . . . . . . . . . . . . . . . . . 221 arreglo . . . . . . . . . . . . . . . . . . . . . . . . 173 ´ındice . . . . . . . . . . . . . . . . . . . . . 174 acceso directo . . . . . . . . . . . . . 174, 198 indirecto . . . . . . . . . . . . . . . . 174 bidimensional . . . . . . . . . . . . . 197 din´amico . . . . . . . . . . . . . . . . . . 181 multidimensional . . . . . . . . . . 173 reservar memoria . . . . . . . . . . 173 sub´ındice. . . . . . . . . . . . . . . . . .174 unidimensional . . . . . . . . . . . . 173 ASCII. . . . . . . . . . . . . . . . . . . . . . . . . .11
B bibliotecas conio.h . . . . . . . . . . . . . . . . . . . . . 28 ctype.h . . . . . . . . . . . . . . . . . . . . . 28 graphics.h . . . . . . . . . . . . . . . . . . 28 iostream.h. . . . . . . . . . . . . . . . . .28 math.h . . . . . . . . . . . . . . . . . . . . . 28 stdio.h . . . . . . . . . . . . . . . . . . . . . 28 stdlib.h . . . . . . . . . . . . . . . . . . . . 28 string.h . . . . . . . . . . . . . . . . . . . . 28 bloque . . . . . . . . . . . . . . . . . . . . . . . . . 30 C c´odigo. . . . . . . . . . . . . . . . . . . . . . . . . .39 reutilizar . . . . . . . . . . . . . . . . . . . 39 C++ DOS . . . . . . . . . . . . . . . . . . . . . . 221 Linux . . . . . . . . . . . . . . . . . . . . . 221 Turbo . . . . . . . . . . . . . . . . . . . . . 221 cadenas . . . . . . . . . . . . . . . . . . . . . . . 228 de caracteres . . . . . . . . . . . . . . 221 caracteres especiales . . . . . . . . . . . . 11 catch . . . . . . . . . . . . . . . . . . . . . . . . . 222 ciclo . . . . . . . . . . . . . . . . . . . . . . . . . . 123 acumulador . . . . . . . . . . . . . . . 133 anidado . . . . . . . . . . . . . . . . . . . 146 break . . . . . . . . . . . . . . . . . . . . . 154 condicionado al comienzo . . . . . . . . 137, 153 al final . . . . . . . . . . . . . . . . . . 123 249
250 contador . . . . . . . . . . . . . . . . . . 132 continue . . . . . . . . . . . . . . . . . . 154 do - while . . . . . . . . . . . . . . . . . 123 condici´on. . . . . . . . . . . . . . . .125 incremento . . . . . . . . . . . . . . 125 inicializaci´on . . . . . . . . . . . . 124 for . . . . . . . . . . . . . . . . . . . . . . . . 153 condici´on. . . . . . . . . . . . . . . .154 ejecuci´on . . . . . . . . . . . . . . . . 154 estructura . . . . . . . . . . 123, 153 incremento . . . . . . . . . . . . . . 154 inicializaci´on . . . . . . . . . . . . 154 while . . . . . . . . . . . . . . . . . . . . . . 137 estructura . . . . . . . . . . . . . . . 137 clases . . . . . . . . . . . . . . . . . . . . . . . . . 221 columna . . . . . . . . . . . . . . . . . . . . . . 197 comentario . . . . . . . . . . . . . . . . . . . . . 30 comparaci´on . . . . . . . . . . . . . . . . . . . 12 compilar . . . . . . . . . . . . . . . . . . . . . . . 27 comportamiento . . . . . . . . . . . . . . . . . 6 compromiso . . . . . . . . . . . . . . . . . . . . . 2 condici´on . . . . . . . . . . . . . . . . . . . . . . 55 constante . . . . . . . . . . . . . . . . 8, 48, 74 contador . . . . . . . . . . . . . . . . . . . . . . 132 D decisi´on . . . . . . . . . . . . . . . . . . . . . 5, 55 ´arbol . . . . . . . . . . . . . . . . . . . . . . . 83 anidada . . . . . . . . . . . . . . . . . . . . 73 m´ ultiple . . . . . . . . . . . . . . . . . . . . 95 depurar . . . . . . . . . . . . . . . . . . . . . . . . 39 dispositivo est´andar de salida . . . . . . . . . . . . . . . . . . . 30 E ejecutar . . . . . . . . . . . . . . . . . . . . . . . . 27 estructuras de repetici´on . . . . . . 123 excepciones . . . . . . . . . . . . . . . . . . . 221
´INDICE ALFABETICO ´ throw . . . . . . . . . . . . . . . . . . . . . 223 excluyente . . . . . . . . . . . . . . . . . . . . . 55 expresi´on . . . . . . . . . . . . . . . . . . . 13, 16 algebr´aica . . . . . . . . . . . . . . . . . . 16 aritm´etica . . . . . . . . . . . . . . . . . . 16 de asignaci´on . . . . . . . . . . . . . . . 18 l´ogica . . . . . . . . . . . . . . . . . . . 18, 55 m´ ultiple . . . . . . . . . . . . . . . . . . 18 simple . . . . . . . . . . . . . . . . . . . . 18 F fila . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 funci´on . . . . . . . . . . . . . . . . . . . . . 15, 39 argumentos. . . . . . . . . . . . . . . . .41 estructura general . . . . . . . . . . 39 generalidades . . . . . . . . . . . . . . . 41 identificador . . . . . . . . . . . . . . . . 39 llamar . . . . . . . . . . . . . . . . . . . . . . 39 longitud . . . . . . . . . . . . . . . . . . . . 42 main . . . . . . . . . . . . . . . . . . . . . . . 41 nombre. . . . . . . . . . . . . . . . . . . . .41 par´ametros . . . . . . . . . . . . . . . . . 41 pasar arreglos . . . . . . . . . . . . . 183 pasar valores . . . . . . . . . . . . . . . 51 predefinida . . . . . . . . . . . . . . . . . 15 principal . . . . . . . . . . . . . . . . . . . 41 recomendaciones . . . . . . . . . . . 41 retornar . . . . . . . . . . . . . . . . . . . . 44 sqrt . . . . . . . . . . . . . . . . . . . . . . . . 35 tipo de dato . . . . . . . . . . . . . . . . 39 variable local . . . . . . . . . . . . . . . 41 funciones . . . . . . . . . . . . . . . . . . . . . . . . 8 G g++ . . . . . . . . . . . . . . . . . . . . . . . . . . 221 H historia . . . . . . . . . . . . . . . . . . . . . . . . . 7
´INDICE ALFABETICO ´ I identificador . . . . . . . . . . . . . . . . . . . . . 8 imprimir . . . . . . . . . . . . . . . . . . . . . . . 30 iteraci´on . . . . . . . . . . . . . . . . . . . . . . 125 J jerarqu´ıa . . . . . . . . . . . . . . . . . . . . . . . 13 L leer . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 lenguaje B ........................... 7 BCPL . . . . . . . . . . . . . . . . . . . . . . . 7 C ........................... 7 C++ . . . . . . . . . . . . . . . . . . . . . . . . 7 de programaci´on. . . . . . . . . . . . .1 M main argumentos . . . . . . . . . . . . . . . 233 matriz . . . . . . . . . . . . . . . . . . . 173, 197 ´ındice . . . . . . . . . . . . . . . . . . . . . 198 acceso directo . . . . . . . . . . . . . . . . . . 198 indirecto . . . . . . . . . . . . . . . . 198 columna . . . . . . . . . . . . . . . . . . 197 din´amica . . . . . . . . . . . . . . . . . . 206 fila . . . . . . . . . . . . . . . . . . . . . . . . 197 reservar memoria . . . . . . . . . . 197 sub´ındice. . . . . . . . . . . . . . . . . .198 memoria . . . . . . . . . . . . . . . . . 181, 206 din´amica . . . . . . . . . . . . . 181, 206 direcci´on . . . . . . . . . . . . . 181, 206 est´atica . . . . . . . . . . . . . . 181, 206 liberar. . . . . . . . . . . . . . . .181, 206 solicitar . . . . . . . . . . . . . . 181, 206 modificar. . . . . . . . . . . . . . . . . . . . . . .39 modularizar . . . . . . . . . . . . . . . . . . . . 39
251 N n´ umeros enteros . . . . . . . . . . . . . . . . . . . . . 11 reales . . . . . . . . . . . . . . . . . . . . . . 12 notaci´on cient´ıfica . . . . . . . . . . . . . . 12 O operador condicional . . . . . . . . . . . . . . . . 146 operadores aritm´eticos . . . . . . . . . . . . . . . . . 12 de agrupaci´on . . . . . . . . . . . . . . 13 de asignaci´on . . . . . . . . . . . . . . . 13 de signo . . . . . . . . . . . . . . . . . . . . 13 jerarqu´ıa . . . . . . . . . . . . . . . . . . . 13 equivalente . . . . . . . . . . . . . . . 14 l´ogicos . . . . . . . . . . . . . . . . . . . . . 12 conjunci´on . . . . . . . . . . . . . . . 12 disyunci´on . . . . . . . . . . . . . . . 12 precedencia . . . . . . . . . . . . . . . . 13 equivalente . . . . . . . . . . . . . . . 14 prioridad . . . . . . . . . . . . . . . . . . . 13 equivalente . . . . . . . . . . . . . . . 14 relacionales. . . . . . . . . . . . . . . . .12 P palabras reservadas . . . . . . . . . . . . . . 9 break . . . . . . . . . . . . . . . . . . 95, 154 case . . . . . . . . . . . . . . . . . . . . . . . . 96 catch. . . . . . . . . . . . . . . . . . . . . .222 cerr . . . . . . . . . . . . . . . . . . . . . . . 224 char. . . . . . . . . . . . . . . . . . . . . . .149 const . . . . . . . . . . . . . . . . . . . . . . . 32 continue . . . . . . . . . . . . . . . . . . 154 default . . . . . . . . . . . . . . . . . . . . . 96 do . . . . . . . . . . . . . . . . . . . . . . . . 123 double . . . . . . . . . . . . . . 12, 31, 32 else . . . . . . . . . . . . . . . . . . . . . . . . 57
252 float. . . . . . . . . . . . . . . . . . . . . . . .12 for . . . . . . . . . . . . . . . . . . . . . . . . 153 if . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 include . . . . . . . . . . . . . . . . . . . . . 28 main . . . . . . . . . . . . . . . . . . . . . . . 41 sqrt . . . . . . . . . . . . . . . . . . . . . . . . 35 string . . . . . . . . . . . . . . . . . . . . . 228 switch . . . . . . . . . . . . . . . . . . . . . . 95 tolower . . . . . . . . . . . . . . . . . . . . 230 toupper . . . . . . . . . . . . . . . . . . . 230 try . . . . . . . . . . . . . . . . . . . . . . . . 222 void . . . . . . . . . . . . . . . . . . . . . . . . 30 while . . . . . . . . . . . . . . . . . 123, 137 pantalla . . . . . . . . . . . . . . . . . . . . . . . . 30 par´ametros . . . . . . . . . . . . . . . . . . . . . 41 par´entesis anidados. . . . . . . . . . . . .14 plazo corto . . . . . . . . . . . . . . . . . . . . . . . . 2 largo . . . . . . . . . . . . . . . . . . . . . . . . 2 mediano . . . . . . . . . . . . . . . . . . . . . 2 posici´on . . . . . . . . . . . . . . . . . . 174, 197 posincremento. . . . . . . . . . . . . . . . . .20 precedencia . . . . . . . . . . . . . . . . . . . . 13 predecremento . . . . . . . . . . . . . . . . . 20 preincremento . . . . . . . . . . . . . . . . . . 20 prioridad . . . . . . . . . . . . . . . . . . . . . . . 13 programa secuencial . . . . . . . . . . . . . . . . . . . 5 puntero . . . . . . . . . . . . . . . . . . 181, 206 punto decimal . . . . . . . . . . . . . . . . . . 12 R repetici´on . . . . . . . . . . . . . . . . . . . . . . . 6 reutilizar . . . . . . . . . . . . . . . . . . . . . . . 39 S secuencias de escape. . . . . . . . . . . .11 stream . . . . . . . . . . . . . . . . . . . . . . . . 237
´INDICE ALFABETICO ´ string . . . . . . . . . . . . . . . . . . . . . . . . . 228 Stroustrup . . . . . . . . . . . . . . . . . . . . . . 8 sub´ındice . . . . . . . . . . . . . . . . . 174, 197 T tabla . . . . . . . . . . . . . . . . . . . . . . . . . . 197 tiempo . . . . . . . . . . . . . . . . . . . . . . . . . . 3 tipos de datos . . . . . . . . . . . . . . . . 8, 9 char . . . . . . . . . . . . . . . . . . . . . . . . 11 primitivos . . . . . . . . . . . . . . . . . . . 9 tolower . . . . . . . . . . . . . . . . . . . . . . . 230 toupper . . . . . . . . . . . . . . . . . . . . . . . 230 try . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222 V valor de verdad . . . . . . . . . . . . . . . . 55 valor l´ogico. . . . . . . . . . . . . . . . . . . . .12 falso . . . . . . . . . . . . . . . . . . . . . . . 12 verdadero . . . . . . . . . . . . . . . . . . 12 variable . . . . . . . . . . . . . . . . . 8, 30, 173 alcance . . . . . . . . . . . . . . . . . . . . . 41 vida diaria . . . . . . . . . . . . . . . . . . . . . . 1