Algoritmos en Lenguaje C-C++

March 24, 2018 | Author: Charly A. Robles | Category: Programming Language, C++, Bit, Computer Programming, Computer Program


Comments



Description

I NTR O DUC C I Ó N A L O S A L G OR I TMOS EN L E NG UA J E C / C+ + H UMB E R TO MA Z UE R A PÁ R R A G A [email protected] www.geocities.com/humbertomazuera "Feliz es el hombre que ha hallado sabiduría, y el hombre que consigue discernimiento, porque el tenerla como ganancia es mejor que tener la plata como ganancia; y el tenerla como producto, que el oro mismo. Es más preciosa que los corales, y todos tus otros deleites no pueden ser igualados a ella. Largura de días está en su diestra, en su siniestra hay riquezas y gloria. Sus caminos son caminos de agradabilidad, y todas sus veredas son paz. Es árbol de vida a los que se asen de ella, y los que la mantienen firmemente asida han de ser llamados felices." Proverbios, 3:11-18 C A L I , fe br e r o D E l 2 0 0 1 1 TABLrrorONTENIDO dor no definido. ¡E A DE C ! Marca Componentes de los Programas en Lenguaje C Instrucciones Secuenciales Instrucción Selectiva If Instrucción Selectiva Switch Divide y Venceras: Funciones Instrucción Repetitiva While Instrucción Repetitiva While(Continuación) Instrucción Repetitiva Desde Instrucción Repetiva Do...While Paso por Valor y Retorno en Funciones Arreglos Unidimensionales Algoritmos de Clasificacion de Vectores Algoritmos con Vectores(Continuación) Arreglos Bidimensionales Punteros y Paso por Referencia Estructura de Datos Registro Estructura de Datos Archivo Menú de Conmutadores en Modo Gráfico Las Tradicionales Printf y Scanf Código ASCII y Códigos Extendidos 2 CAPÍTULO 1 COMPONENTES DE LOS PROGRAMAS EN C++ 1.1 METODOLOGÍA El profesor deberá explicarle los diversos componentes de un programa elemental en lenguaje C++, a partir de describirle el programa COUT01.CPP, ver listado más adelante, en él la instrucción principal que debe entender o mejor abstraer, es el objeto cout <<, la cual permite mostrar en la pantalla de la computadora, la información que deseamos. El profesor explicará como copiar, depurar, compilar y ejecutar en la máquina un programa. A continuación el profesor explicará la codificación de expresiones algebraicas como expresiones algorítmicas "entendibles" por la computadora, y finalmente les explicará el programa COUT02.CPP. Ya en su casa, no se angustie, efectúe la primera tarea y luego con sus compañeros de Grupo de estudio, discútanla y lleven la que crean definitiva al laboratorio de computadoras. En el laboratorio deberá haber un monitor el cual les ayude a manejar el editor del lenguaje C++, a compilar y ejecutar los dos programas vistos en clase y luego la tarea. Efectúe una lectura de todo este capítulo con la sola finalidad de saber el que existen muchos elementos constitutivos de un lenguaje de programación, no se alarme si no entiende mucho y no pretenda aprender nada de memoria. 1.2 PROGRAMACIÓN ESTRUCTURADA El concepto de programación estructurada como un enfoque científico a la programación de computadoras lo introdujeron E.W.Dijkstra y C.A.R.Hoare a fines de los años sesenta. Mediante el análisis matemático de la estructura de los programas, ellos mostraron que podemos evitar muchos errores de diseño de programas mediante un enfoque sistemático a la programación. Es fundamental en la programación estructurada el diseño adecuado de los algoritmos y el manejo de las estructuras de datos. La programación estructurada enfrenta el problema a resolver con la técnica del "Divide y Vencerás", dividiéndolo sucesivamente en partes más pequeñas, cada una de estas partes, estas reciben diversos nombres dependiendo del lenguaje utilizado: procedimientos, rutinas, métodos, funciones, subrutinas, bloques de código, etc.; en el lenguaje C/C++ las llamamos funciones. En general un programa es un conjunto de instrucciones las cuales le dicen a la computadora cómo ejecutar una tarea específica. Todos los lenguajes de programación consisten en secuencias de caracteres, o sea de letras, números, símbolos retornos de carro y espacios. Se puede definir un lenguaje de computadora como una secuencia de elementos, los cuales tienen un significado concreto y "entendible" por la misma. Estos elementos son: las palabras reservadas(keywords), los identificadores y los símbolos, la sintaxis del lenguaje definirá cómo se combinarán todos estos para producir un código ejecutable por el ordenador. 1.3 ALGORITMO Se entiende por un algoritmo la secuencia de pasos necesarios para realizar una area o un determinado problema. En el presente curso presentaremos los algoritmos escritos en el lenguaje de nivel intermedio C/C++. 3 1.4 SÍMBOLOS Un símbolo es uno o varios caracteres los cuales tienen un especial significado en los lenguajes de computador. Ellos pueden ser separadores de identificadores como la coma(,), separadores de expresiones como el punto y coma(;), agrupadores de expresiones como los paréntesis y operadores de diversos tipos. Lista de ellos se presenta más adelante en varias tablas. Cada símbolo está representado internamente por un código o secuencia de códigos ASCII. 1.5 CÓDIGO ASCII El código ASCII(American Standard Committed for Information Interchange), es el código con el cual operan los microcomputadores que trabajan bajo el sistema operativo MS-DOS y Windows. Se compone de un conjunto de caracteres de control, y caracteres imprimibles, numerados del 0 al 255. Ocupa cada uno de ellos un Byte de memoria, es decir ocho bit. Tabla 1.1 Caracteres ASCII. 0 12 24 32 44 56 68 80 92 104 116 128 140 152 164 176 188 200 212 224 236 248 1 13 25 33 45 57 69 81 93 105 117 129 141 153 165 177 189 201 213 225 237 249 ☺ 2 _ 14 26 ! 34 - 46 9 58 E 70 Q 82 ] 94 i 106 u 118 ü 130 ì 142 Ö 154 Ñ 166 ▒ 178 ╜ 190 ╔ 202 ╒ 214 ß 226 238 250 ☺ 3 _ 15 27 " 35 . 47 : 59 F 71 R 83 ^ 95 j 107 v 119 é 131 Ä 143 Ü 155 ª 167 ▓ 179 ╛ 191 ╩ 203 ╓ 215 227 239 251 4 5 16 17 28 _ 29 36 $ 37 % 48 0 49 1 60 < 61 = 72 H 73 I 84 T 85 U 96 ` 97 a 108 l 109 m 120 x 121 y 132 ä 133 à 144 É 145 æ 156 £ 157 ¥ 168 ¿ 169 _ 180 ┤ 181 ╡ 192 └ 193 ┴ 204 ╠ 205 ═ 216 ╪ 217 ┘ 228 229 240 241 ± 252 _ 253 ² 6 18 30 38 & 50 2 62 > 74 J 86 V 98 b 110 n 122 z 134 å 146 Æ 158 _ 170 182 ╢ 194 ┬ 206 ╬ 218 ┌ 230 242 254 7 • 8 _ 9 10 _ 11 _ 19 _ 20 ¶ 21 § 22 23 31 39 ' 40 ( 41 ) 42 * 43 + 51 3 52 4 53 5 54 6 55 7 63 ? 64 @ 65 A 66 B 67 C 75 K 76 L 77 M 78 N 79 O 87 W 88 X 89 Y 90 Z 91 [ 99 c 100 d 101 e 102 f 103 g 111 o 112 p 113 q 114 r 115 s 123 { 124 | 125 } 126 ~ 127 135 ç 136 ê 137 ë 138 è 139 ï 147 ô 148 ö 149 ò 150 û 151 ù 159 160 á 161 í 162 ó 163 ú 171 ½ 172 ¼ 173 ¡ 174 « 175 » 183 ╖ 184 ╕ 185 ╣ 186 ║ 187 ╗ 195 ├ 196 ─ 197 ┼ 198 ╞ 199 ╟ 207 ╧ 208 ╨ 209 ╤ 210 ╥ 211 ╙ 219 █ 220 ▄ 221 ▌ 222 ▐ 223 ▀ 231 232 233 234 235 243 244 245 246 247 255 _ , 8 D P \ h t Ç î _ ñ ░ ╝ ╚ ╘ # / ; G S _ k w â Å ¢ º │ ┐ ╦ ╫ 1.6 EL LENGUAJE C++ El C++ es un poderoso compilador, utilizado por experimentados y recién iniciados programadores. Con el Turbo C++ se consigue simultáneamente el C++ de la compañía AT&T y el estándar ANSI C. De esta forma el C++ es un lenguaje de propósito general en el cual se puede desarrollar cualquier tipo de aplicación, desde aplicaciones comerciales, de ingeniería, científicas, juegos, sistemas operativos hasta los últimos desarrollos en inteligencia artificial y dentro de ella la robótica, los sistemas expertos, analizadores de lenguajes, etc. El C++ es un lenguaje de programación orientada a objetos (POO), empero, este tema no será abordado en este manual. 4 include.2 auto break case* char* const* continue default do* Las 32 palabras reservadas del C.h> #include <string. Tabla 1. es decir que 5 . esto es sin punto y coma.2 y 1. En tiempo de compilación el "compilador" revisará la sintaxis de las diferentes instrucciones y en caso de encontrar alguna con terminador inadecuado. es decir es su terminador.) en archivos separados. El C/C++ en particular trae una gran cantidad de archivos a incluir por medio de la directiva del compilador #include. etc. la cual debe ser colocada preferiblemente al inicio del programa y siempre por fuera del ámbito de las funciones.h> <stdio. los lenguajes en general y como parte de la máxima "Divide y Vencerás". Los archivos a incluir en el turbo C++ los puede encontrar en el nivel de ayuda del editor. Se debe colocar el punto y coma al final de cada instrucción (statement).h> #include <graphics. tipos de datos. En C/C++ el punto y coma marca el fin de una instrucción.h> #include <dos. dará un error de sintaxis: " .h> #include <stdlib.h> <ctype.h> #include <values. y con esta sintaxis: #include #include #include #include <iostream.Tabla 1.h> #include <conio. colocan una serie de utilidades(funciones.h> <iomanip. el de no utilizar ninguna de las palabras reservadas de las Tablas 1. etc. expected".). las cuales no llevan punto y coma al final.7 LIBRERÍAS Para optimizar el código producido.h> #include <math.. Solo debe tener la precaución.8 SEPARADORES DE INSTRUCCIONES Cada lenguaje utiliza alguna convención para separar las diferentes instrucciones del mismo. Se exceptúan las instrucciones del preprocesador (define. los cuales de pueden utilizar como si estuvieran en el programa que estamos diseñando. en el lenguaje C el separador es el símbolo de punto y coma . double* else* enun extern float* for* goto if* int* long* register return* short signed sizeof static struct* switch* typedef* union* unsigned* void* volatile while* NOTA: Solo los identificadores con asterisco(*). se utilizarán en el presente curso. variables.3 asm catch clas delete friend Las palabras reservadas ampliadas del C++ inline new operator overload private protected public template this throw try virtual NOTA: Ninguno de estos identificadores se utilizará en este curso.h> 1.3 1.h> #include <fstream. cuando defina un identificador. Los siguientes serán los utilizados en el presente manual. . es decir no ocuparán espacio en él. estos pueden ocupar una o tantas líneas como se desee.aquí comienzan mis comentarios en esta línea también siguen .obj). y de esta forma guardar el programa adecuadamente documentado.9 COMENTARIOS En todo lenguaje hay la posibilidad de colocar comentarios. en general este otro caracter lo encuentra en la instrucción siguiente. En el lenguaje C se utilizan los caracteres /* y */ para el inicio y la terminación de comentarios. 1. estos comentarios no se tendrán en cuenta en el momento en que el compilador produzca el código objeto(archivo *.esperaba un punto y coma y encontró otro caracter.10 OPERACIONES DE ENTRADA/SALIDA Un programa para que pueda trabajar. Es buena práctica de programación colocar abundantes comentarios. // este es otro comentario // etc. Observe los punto y comas en los programas presentados en este capítulo.. En la forma estándar o por defecto (default) el dispositivo de entrada será el teclado y el dispositivo de salida la pantalla o monitor. aquí terminan los comentarios ----> */ Adicionalmente en C++ existe el comentario de línea.. entre otras cosas. estos son líneas en el código fuente adicionales al algoritmo propio del programa. donde marcará el error y confundiendo al recién iniciado. este comentario inicia con una doble barra inclinada //. ┌─────────────────────┐ ┌────────────┐ │ ┌──────────────────┐│ │ PC │ │ │ PANTALLA ││ │ │ │ │ ││ cout << │ ┌───────┐ │ │ │ │├<<────────────────────────────┤ │ │ │ │ └──────────────────┘│ Inserción en Flujo de salida │ │MEMORIA│ │ └─────────────────────┘ │ │ RAM │ │ ┌───────────────────────────┐ │ │ │ │ │ ▄ ▄ ▄ TECLADO ▄ ▄ ▄ ▄ │ cin >> │ │ │ │ │ ▄▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ├─────────────────────────>>┤ │ │ │ │ ▄▄ ▄▄▄ ▄▄▄▄▄▄▄▄ ▄▄ ▄ ▄▄▄ │ Extracción en Flujo │ └───────┘ │ └───────────────────────────┘ de entrada └────────────┘ 6 . debe poder operar los datos que se proporcionan mediante un dispositivo de entrada y poder enviar los resultados después de procesados con la ayuda de un algoritmo a un dispositivo de salida. ejemplo: // este es un comentario de una sola línea. 1. o más exactamente desde la columna donde se coloque hasta el fin de línea.1 instrucciones básicas de entrada/salida en C++. Figura 1. ejemplo: /* <---. 1. Esta instrucción despliega o muestra los valores que se le indiquen en pantalla.. El operador << es llamado en este contexto un insertor. cout << "\n\n\nArriba hay tres líneas en blanco\n". en su forma por defecto. o expresiones delimitadas como cadenas de caracteres de la memoria del computador a la pantalla. cout << "El cursor está aquí".2 Fragmento de código en C++ y lo que aparecería en pantalla: clrscr().h. ya que inserta datos en el flujo de salida hacia la pantalla. variables. //Borrar pantalla cout << "ESTO ES SOLO UNA PRUEBA. cout << "El contador N = " << N << "\n\n".. PANTALLA ╔═══════════════════════════════════════╗ ║ ESTO ES SOLO UNA PRUEBA ║ ║ El contador N = 0 ║ ║ ║ ║ ║ ║ ║ ║ Arriba hay tres líneas en blanco ║ ║ ║ ║ 1 + 2 + 3 = 6 ║ ║ El contador N = 1 ║ ║ ║ ║ El cursor está aquí_ ║ ║ ║ ╚═══════════════════════════════════════╝ 7 .11 INSTRUCCIÓN DE ESCRITURA EN PANTALLA Para transferir valores de constantes. expresiones algebraicas. emplearemos la instrucción (en realidad es un objeto) del lenguaje C++: cout <<.\n". teniendo la posibilidad de formatearlos. N = 0. N++. cout << "El contador N = " << N << "\n". cout << "\n1+ 2 + 3 = " << 1+2+3 << "\n". y la cual se encuentra en el archivo a incluir iostream. Figura 1. compílelo y ejecútelo. cout << " ERICH FROMM \n". Prevalece la superstición patética de que sabiendo más y más hechos es posible llegar a un conocimiento de la realidad. en el teclado numérico. #include <iostream. cout << "y más hechos es posible llegar a un conocimiento de la \n". cout << "realidad. . cout << "más hechos. pero la 'información' sin teoría puede representar un obstáculo para el pensamiento tanto como su carencia. Es cierto que el pensar carente \n". todo su tiempo y toda su energía se pierden en aprender cada vez más hechos.. ERICH FROMM "EL MIEDO A LA LIBERTAD"_ 8 . Es cierto que el pensar carente de un conocimiento adecuado de los hechos sería vacío y ficticio..1. De este modo se descargan en la cabeza de los estudiantes centenares de hechos aislados e inconexos. de manera que les queda muy poco lugar para ejercitar el pensamiento. pero la 'información' sin teoría puede representar \n". cout << "de un conocimiento adecuado de los hechos sería vacío y \n".h> // cout #include <conio.. tal cual. cout << "estudiantes centenares de hechos aislados e inconexos. cout << " . Prevalece la superstición patética de que sabiendo más \n". Luego modifíquele los saltos de línea. cout << "ficticio.... el código ASCII correspondiente. getch().. cout << "un obstáculo para el pensamiento tanto como su carencia. .3 Efecto de la ejecución del Programa COUT01.12 El siguiente ejemplo presenta en pantalla un texto compuesto de varias líneas.CPP main(){ clrscr(). Las tildes digítelas pulsando la tecla ALT y simultáneamente. cout << "ejercitar el pensamiento. } Figura 1.h> // clrscr() y getch() //COUT01. cout << "\n\n". de manera que les queda muy poco lugar para \n".CPP en pantalla .. De este modo se descargan en la cabeza de los \n". cout << "su tiempo y toda su energía se pierden en aprender cada vez \n". \n". cópielo. todo \n". cout << " \"EL MIEDO A LA LIBERTAD\"". MOS\*.CPP │ COUTIN10. en el editor.CPP │ COUTIN09.CPP │ ┌────────┐ │ │ │ │ └───────────────┴──────────────┘ │ Help │ │ │ │ │ └────────┘ │ │ │ │ C:\TC\ALGORIT.CPP │ └────────┘ │ │ │ │ │ COUTIN02.CPP │ COUTIN03.CPP │ │ Open │ │ │ │ │ ├──────────────────────────────┤ └────────┘ │ │ │ │ │Files ─────────┬───────────── │ ┌────────┐ │ │ │ │ │ COUT00. compilar.CPP │ │Cancel │ │ │ │ │ │ COUTIN01. compilándolos y ejecutándolos cada uno de ellos. enlazar y ejecutar un programa en el Lenguaje C.CPP │ COUTIN07.CPP │ │ │ │ │ │ COUT03.CPP │ COUTIN08.CPP │ │ │ │ │ │ COUT04.CPP │ ┌────────┐ │ │ │ │ │ COUTIN00. upper for directories 1. Copie.CPP │ │Replace │ │ │ │ │ │ COUT01.CPP─────────────────────────────────┐ │ │ │ ┌──[_]──────────── Open a File ─────────────────┐ │ │ │ ┌──────────────────────────────┐ │ │ │ │ │Name │ ┌────────┐ │ │ │ │ │ C:\TC\ALGORIT. donde el profesor explicará los pasos para lograr editar. las principales a necesitar e ir "memorizando" son las contenidas en la siguiente Tabla: 9 . Figura 1.1.13 ESCRITURA DE UN PROGRAMA EN EL EDITOR DEL TURBO C++ Después de asistir a la clase magistral correspondiente a esta segunda lección estudie las explicaciones dadas en este capítulo sobre operaciones de entrada y salida y luego deberá dirigirse a la sala de cómputo.1995 8:06am │ │ │ └───────────────────────────────────────────────┘ │ │ │ └────────1:1 ──────────────────────────────────────────────────────────────────┘ F1 Help Type for incremental search: lower for files.4 Editor del Turbo C++ File Edit Search Run Compile Debug Project Options Window Help ┌─[_]──────────────────────────── NONAME00. uno por uno todos los programas que se presentan en esta lección.CPP │ COUTIN05.CPP │ └────────┘ │ │ │ │ │ COUT02.CPP │ COUTIN06.CPP │ │ │ │ COUT00.CPP 630 Sep 17.14 Para lograr ejecutar un programa se deberán utilizar varias secuencias de teclas.MOS\*.CPP │ COUTIN04. TECLA ORDEN DEL MENU F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F10 F10 F10 F10 Ayuda del editor Grabar en disco Cargar desde disco Ejecutar programa hasta el cursor Hace zoom en la ventana activa Cambia de ventana activa Rastreo del programa con llamado de funciones Rastreo del programa saltando funciones Compila y enlaza el programa Activa el menú principal File New Comenzar un programa nuevo File Change Dir Cambiar directorio actual Window Close All Cerrar todas las ventanas Help Index Índice alfabético de ayuda + + + + F8 Marca punto en el cual detenerse ejecución F9 Compilar y ejecutar(correr) Y Borrar una línea T Borrar una palabra o espacios Teclas Mover Marcar bloque DelBorrar bloque marcado InsRestaurar bloque borrado KV Mover bloque marcado KC Copiar bloque marcado KR Leer un archivo como bloque KW Grabar un bloque como archivo KP Imprimir bloque marcado CTRL CTRL CTRL CTRL Shift Shift Shift CTRL CTRL CTRL CTRL CTRL ALT ALT ALT ALT ALT ALT ALT ALT ALT + + + + + + + + + + + + + + + + + 0 Lista ventanas abiertas 1 al 9 Activa ventana 1 al 9 F1 Pantalla ayuda anterior F3 Elimina ventana activa F4 Abre ventana de depuración F5 Cambia a ventana de ejecución del programa F7 Error anterior F8 Error siguiente F9 Compilar a archivo .4 Secuencias de teclas más utilizadas.OBJ ALT + X Salir(eXit) del editor del C++ 10 .Tabla 1. │ │ cout << "un obstáculo para el pensamiento tanto como su carencia..h> │ Trace into F7 │ │ │#include <conio. │ │ cout << " .│ │ cout << " \"EL MIEDO A LA LIBERTAD\"". Todo algoritmo se desarrollará con tres tipos de instrucciones: Secuenciales... todo \n".│ │ cout << "más hechos. Recordar que la pantalla tiene en modo de texto 80 columnas. Cada función del programa. 11 . la función main(). ..15 CUERPO DEL PROGRAMA Los programas en C/C++ deberán estar compuestos de al menos una función. en algún campo del saber.│ │ cout << "realidad. El algoritmo debe incluir identificadores.│ │ cout << "su tiempo y toda su energía se pierden en aprender cada vez \n". el entendimiento de estas tres es el objetivo principal de este curso. De esta forma el algoritmo es simplemente la secuencia de pasos que interpretan un problema específico. Los espacios en blanco adicionales y los caracteres de salto de línea no son relevantes para el compilador. de manera que les queda muy poco lugar para \n".h> // │ Step over F8 │ │ │ │ Arguments.│ └────── 1:1 ──────────────────────────────────────────────────────────────────┘ F1 Help │ Make and run the current program 1. consta de la secuencia de instrucciones o algoritmo que la computadora deberá realizar. c │ Program reset Ctrl+F2 │ odifíquele los saltos de l │ │ │ Go to cursor F4 │ │ │#include <iostream. El C++ es un lenguaje de formato libre. Es cierto que el pensar carente \n". Selectivas y Repetitivas.5 Ejemplo de función main() en editor del Turbo C++ ┌───────┐ File Edit Search Run │Compile│ Debug Project Options Window Help ┌─[_]───────────────────┼───────┴─────────────────┬──────────────────────1[_] ─┐ │//El siguiente ejemplo │ Run Ctrl+F9 │ o compuesto de varias líne │ │//cópielo. siendo preferible utilizar menos de los primeros 80 por motivos de presentación en las impresiones del código fuente. Prevalece la superstición patética de que sabiendo más \n". \n".│ │ cout << "ficticio. De este modo se descargan en la cabeza de los \n".Figura 1. excepto cuando se requieren para conservar identificadores y las palabras claves o dentro de variables de tipo de cadena. │ │ cout << " ERICH FROMM \n".│ │ cout << "de un conocimiento adecuado de los hechos sería vacío y \n". pero la 'información' sin teoría puede representar \n". operadores y palabras claves.. y que la computadora podrá ejecutar y de esta forma nosotros obtener los resultados deseados.│ │ cout << "ejercitar el pensamiento.. tal cual.│ │ cout << "estudiantes centenares de hechos aislados e inconexos. Las líneas del programa pueden tener una longitud máxima de hasta 127 caracteres.│ │ cout << "\n\n". │ │ │main(){ └─────────────────────────┘ │ │ clrscr().│ │ cout << "y más hechos es posible llegar a un conocimiento de la \n". sin esta el programa no trabajará por sí solo. │ │ cout << "\n\n".. Los operandos pueden ser constantes.│ │ │-----------------│ hos es posible llegar a un conocimiento de la \n".CPP │ │#i │ Save as.│ │ └─────────────────┘ s centenares de hechos aislados e inconexos. de manera que les queda muy poco lugar para \n".. y así sucesivamente hasta el operador coma que tiene la más baja prelación. │ // cout │ │#i │ Save all │ lrscr() y getch() │ │ │-----------------│ │ │ma │ Change dir.│ └─────── 1:1 ──────────────────────────────────────────────────────────────────┘ F1 Help │ Save the file in the active Edit window 1.│ │ cout << "ficticio.. los condicionales (categoría #14) y los de asignamiento (categoría #15) son asociados de derecha a izquierda. lógicos.. a nivel de bits.│ │ cout << "un obstáculo para el pensamiento tanto como su carencia.17 OPERADORES Los operadores se utilizan para procesar adecuadamente los operandos de acuerdo a sus tipos de datos. Por la característica de operación que realizan.│ │ cout << " \"EL MIEDO A LA LIBERTAD\"". todo \n"... variables o funciones. │ │ cout << " ERICH FROMM \n". Los operadores unarios (categoría #2). todos los demás son asociados de izquierda a derecha.│ │ │ Quit Alt+X │ De este modo se descargan en la cabeza de los \n".6 Ejemplo de función main() en editor del Turbo C++ ┌─────┐ │ File│ Edit Search Run Compile Debug Project Options Window Help ├───┬─┴───────────────┬─── \TC\ALGORIT. . el operador sizeof. Es cierto que el pensar carente \n". F3 │ mpilelo y ejecútelo. relacionales.. La categoría #1 tiene la más alta prioridad de precedencia. Operadores dentro de la misma categoría tienen la misma prelación.│ │ cout << "más hechos. │ │ │ │ Print │ │ │ │DOS shell │alece la superstición patética de que sabiendo más \n". En la siguiente tabla de operadores.│ │ cout << "de un conocimiento adecuado de los hechos sería vacío y \n". los operadores también se dividen en: aritméticos. \n". el operador coma.│ │ cout << "su tiempo y toda su energía se pierden en aprender cada vez \n". De mayor precedencia quiere decir que se ejecuta primero. por 12 . 1. los operadores del Turbo C++ son divididos en 16 categorías.Figura 1.MOS\COUT01. Luego modifíquele los saltos de lí│ │ │ Save F2 │ //COUT01.CPP ───────────────────1-[ ]─┐ │// │ New │ presenta en pantalla un texto compuesto de varias línea│ │// │ Open.16 EXPRESIONES Una expresión es un conjunto de datos compuesto de operandos unidos operadores.│ │ cout << "ejercitar el pensamiento. pero la 'información' sin teoría puede representar \n".. la categoría #2 (operadores unarios) tiene la segunda prelación. .Tabla 1. Multipli. Igualdad │ == │ Igual a ║ ║ │ != │ No igual a ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║ 9.. o │ | │ OR para bits ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║12. Mayor │ () │ Invocación de función ║ ║ │ [] │ Suscritos de arreglos ║ ║ │ -> │ Selector de indirección ║ ║ │ :: │ Resolución de ámbito ║ ║ │ . Desplaza.│ * │ Multiplicación ║ ║ cativos │ / │ División ║ ║ │ % │ Resto en división entera ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║ 4.5 Operadores del C++ y Precedencia ╔═══════════════╤══════════╤═══════════════════════════════╗ ║ # Categoría │ Operador │ Qué es (o qué hace) ║ ╠═══════════════╪══════════╪═══════════════════════════════╣ ║ 1. o exclusivo│ ^ │ XOR para bits ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║11. Acceso │ . Unarios │ ! │ Negación lógica (NOT) ║ ║ │ ~ │ Complemento en binario ║ ║ │ + │ Más ║ ║ │ │ Menos ║ ║ │ ++ │ Preincremento o postincremento║ ║ │ -│ Predecremento o postdecremento║ ║ │ & │ Dirección ║ ║ │ * │ Valor en la dirección de ║ ║ │ sizeof │ Tamaño del operando en bytes ║ ║ │ new │ Espacio en memoria dinámica ║ ║ │ delete │ Desasigna espacio en memoria ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║ 3. │ Selector de componentes ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║ 2. 13 . y │ && │ AND lógico ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║Continúa.│ << │ Izquierda ║ ║ miento bits│ >> │ Derecha ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║ 7. │ Separador campo ║ ║ a miembros │ -> │ Separador campo ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║ 5. Aditivos │ + │ Más binario ║ ║ │ │ Menos binario ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║ 6. y │ & │ AND para bits ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║10. Relacional │ < │ Menor que ║ ║ │ <= │ Menor o igual que ║ ║ │ > │ Mayor que ║ ║ │ >= │ Mayor o igual que ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║ 8. Condicional│ ?: │ a ? x : ║ ║ │ │ significa: ║ ║ │ │ "Si a Entonces x. Coma │ . cout<< "Resultado expresión algebraica = " << (y-x)/(a*x-b).1 * x + 69.1232/8 + (34. Asignación │ = │ Asignamiento simple ║ ║ │ *= │ Producto ║ ║ │ /= │ División ║ ║ │ %= │ Resto ║ ║ │ += │ Suma ║ ║ │ -= │ Diferencia ║ ║ │ &= │ AND sobre bits ║ ║ │ ^= │ XOR sobre bits ║ ║ │ |= │ OR sobre bits ║ ║ │ <<= │ Desplazamiento a la izquierda ║ ║ │ >>= │ Desplazamiento a la derecha ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║16. Las expresiones numéricas están formadas por operadores aritméticos y con operandos enteros o reales. dentro de un algoritmo. │ Separador de expresiones ║ ╚═══════════════╧══════════╧═══════════════════════════════╝ NOTA: muchos de estos operadores no serán utilizados en el presente manual. Energía = Masa * Pow(VelocidadLuz.4. Valor = (123.Tabla 1. cout << "60 = " << 60 * 3.5 Operadores del C++ y Precedencia (Continuación) ╔═══════════════╤══════════╤═══════════════════════════════╗ ║ # Categoría │ Operador │ Que es (o que hace) ║ ╠═══════════════╪══════════╪═══════════════════════════════╣ ║13. como es el caso en la expresión algebraica: 13X + 31Y donde la multiplicación la entendemos tácitamente. los espacios en blanco son opcionales. mejoran la presentación de la expresión.54 .6632*54. Ejemplos de expresiones con operadores aritméticos válidas.36 % 6. empero.2 * Pow(2. El primer paso para traducir una expresión algebraica a su equivalente de computador es verificar que cada operación esté indicada. son las siguientes: Numero = 24 / 2 . En la tabla siguiente se presenta una evaluación "manual" de expresiones aritméticas: 14 . o │ || │ OR lógico ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║14. 12) . y = 3.21) + Numero. SI_NO y" ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║15. 2).14159 / 180 << " radianes". esta debe codificarse como 13*X + 31*Y.544. 3 + 64 / 2 .15 45 2 + 3 * 4 % 7 / 3 + 21 / 2 + 12 % 7 / 3 + 21 / 2 + 5 / 3 + 21 / 2 + 1 + 21 / 2 + 1 + 7 3 + 7 10 3 3 3 3 60 .429 Como ejercicio algebraicas.0 / 35 .0 4.3 + 8 * 2 * 4 / 2 .3 + 16 * 4 / 2 .4 + 120 14 .1 + 1.4 + 12 * 10 5 + 9 .15 60 .4 + 120 10 + 120 130 6 + 9 * 8 / 2 * 4 .0.6 150 .0 . Evaluación secuencial de expresiones aritméticas 65.9 / 3 2.15 40 / 35 .15 1.2 * 3 6 + 72 / 2 * 4 .6 144 (63 -20) /(35 -15) 43 / 20 2 (63 -20.3 .3 9 6 * 9 54 54 54 54 86 83 + 8 * 2 * 4 / 2 .15 59.8 .5 65 / 2 32 65 % 2 1 5 + 3 * 3 .20) / 35 .15 -13.3 4.15 44.0) /(35 -15) 43.9 .20) /35.3 (60 .6.4 3 3 3 3 3 5 + + + + + sqrt(8 % 6 * 10 / 5) sqrt( 2 * 10 / 5) sqrt(20 / 5) sqrt(4) 2 (60 .3 4.429 .Tabla 1.15 -14 60 .15 60 0 .858 4.2 / 2 + 3.15 1 .20.3 12 .571 .2 + 2 * 3.1 + 3.2 * 3 6 + 36 * 4 .20 / 35 .142 .15 60 .2 * 3 6 + 144 .2 * 3 6 + 144 .0 / 20 2.0 / 2 32. escriba las expresiones anteriores como expresiones 15 .9 / 3 2.0 -15 40 /35.2 + 7.3 + 32 . 54/(2.Tabla 1.5)+b*pow(Y.------X+Y 567 (aX5 +bY4 -0.3534)(a-b) 90 .c --.4*X ..54)/(3.20 / 35 .20) / 35 .15 (a*a + b*b ..2.15 35 60 .7 Ejemplos de codificación de expresiones algebraicas EXPRESIÓN ALGEBRAICA 60 ..4X .20 --------35 .5 .15 20 60 .15) 60 .1*Y) 16 .1Y EXPRESIÓN ALGORÍTMICA (60 .15) 60 .15 (60 .---.54 ------------3.2.40 35 13 ------.4X 54 -----2.5-c)/567) (a*pow(X.--------35 .3534)*(a-b) (90-40)/(30-12) + 35/(-47) -13/69 (sqrt(a) + sqrt(b)) / pow(3.1Y (b2 + a) -------ac ---------------3 4..+ ---.15 35 a2 + b2 .4)-0.--30 .15 20 60 .20 -------.12 -47 69 a + b ------36 (1 + seno(x))2 cos2(x) + sen2(x) a2 + b2 ------3.20 / (35 .20) / (35 .4*X) .6) (1 + sin(x)) * (1 + sin(x)) cos(x)*cos(x) + sin(x)*sin(x) - (a*a + b*b)/(3.1*Y) (b*b+a)/(a*c)/(3/(X+Y)-(4. Escriba expresión algebraica para cada caso y calcúlela "manualmente" comparándola con la obtenida en el computador.1.0 + ( 2.0 / 4.0 * 3. cout << "\n\n( 1.0).0)/ 4.0 * 3.0 / 4.75 1.0 / 4.h> #include <conio.0 * 3.0 ) / 4.0) * (3..0 / 4.0 ) / 4.CPP en pantalla ¡Error! Marcador no definido.5 2.0 / 4.1.0 / 4.0) * 3.0) / 4. Codifique las expresiones anteriores como un programa de computador escrito en lenguaje C/C++.0 + 2.0 / 4.0 + 2.0).0 = " << 1.0 / 4.0 * 3.0 ) / 4.0 / 4.0 = " << (1.0 / 4. cout << "\n\n1.0 + ( (2.0 + ( (2..25 1.5 Digite cualquier tecla para terminar.0 * 3. cout << "1. } Figura 1.0 / 4.0._ 1.h> //COUT02.0 = " << 1.0 / 4.0 ) = " << 1.0 * 3.7 Efecto de la ejecución del programa COUT02.0 + ( (2.CPP main(){ clrscr().0 = 2.25 (1.0 * 3.0 ) = 2.0 + ( 2.0) = " << 1.0) / 4.0 + 2.0.0 + ( 2.0 + 2. #include <iostream.. 17 .0 ) * 3. compile y ejecute el siguiente programa el cual presenta un ejemplo de diferentes agrupaciones con paréntesis en expresiones algebraicas. Codifique computador.0 * 3.0 + 2.0) / 4.0) = " << (1.0 + (2. cout << "\n\n(1.0 ) / 4. cout << "\n\n1. getch().0 = " << (1.0 ) * 3.0 = 2.0 * 3.0 + (2.0)/ 4.0 * 3.0).0) = 2.0 + 2.5 1.0) * (3.0 * 3.0 = 1.0 + 2.0) = 2.18 Copie.0 * 3.0 + 2. cout << "\n\n( 1.0 * 3.0) * (3.".0 + 2. cout << "\n\n1.0.0 * 3.0 + 2.5 ( 1.0 = 2.0 + ( 1.0 * 3. cout << "\n\n\n\nDigite cualquier tecla para terminar.19 ACTIVIDADES PARA REALIZAR PERSONALMENTE 1.0.0 + ( 2. 10 expresiones algebraicas en expresiones entendibles por el 2..0 + 2. . nombres de archivos incluidos y parámetros en definición de funciones. en especial no deben contener espacios en blanco.2 LOS IDENTIFICADORES Al escribir programas de computadora en cualquier lenguaje de alto nivel es necesario utilizar nombres para identificar los objetos que se desean manipular. 2. nombres de funciones. y se agrava si no tiene un dominio del teclado. Los algoritmos deben ser resueltos con lápiz. compile y corra los programas presentados. Los identificadores deben no solo ser válidos sino que deben autodocumentar su programa. está en una lectura más adelante. de otros archivos con la directiva #include y de esta forma tener acceso a gran cantidad de librerías que vienen adicionadas al lenguaje. de esta forma si dentro del algoritmo escribe AREA no reconocerá este identificador si inicialmente lo definió como Area. por ejemplo si necesitamos una variable para el cálculo de un área será mucho más claro llamarla: Area y no solamente A. en un principio. codificados en lenguaje C. Resuelva la tarea personalmente y luego lleve aportes a su Grupo de estudio. y las cuales podemos conseguir de diversas formas y también irlas diseñado nosotros mismos a través de nuestra práctica como programadores. A continuación diríjase al computador y solicitando la ayuda del monitor o de compañeros "más avanzados".1 METODOLOGÍA El profesor en clase magistral explicará algunos de los algoritmos. constantes. las palabras reservadas no se pueden utilizar como identificadores. No pretenda que el computador se los resuelva. y le recomiendo se lea "Elogio a la Dificultad" de nuestro maestro Estanislao Zuleta. Los identificadores no admiten espacios intercalados. tipos de datos. que forma el nombre de uno de estos objetos se llama identificador. y no solo a los recién iniciados. de esta lección. Todos los identificadores deben comenzar con una letra o un caracter de subrayado(_) y seguir con caracteres alfanuméricos y subrayados. Ejemplos de identificadores válidos son los siguientes: SumaTotal MoleSolvente I_V_A _identificador Max Pi Voltaje Esta_es_una_variable Acidez CiudadCapital MARIA Costo_de_la_vida Arbol AreaCuadrado VelocidadLuz Sumatoria Maria 19 . Cuando estén seguros de que los algoritmos están bien. La palabra. El lenguaje C hace diferencia entre minúsculas y mayúsculas. Si sufre un poco le diré que eso nos pasa a todos. Con un identificador definiremos variables. papel. o secuencia de caracteres. vaya al computador y cópielos en el editor del lenguaje.CAPÍTULO 2 INSTRUCCIONES SECUENCIALES 2. paradójicamente él solo le ocasionará mayor confusión. córralos y disfrute el mundo de la programación. borrador y principalmente con sus neuronas. Adicionalmente a los identificadores que definamos podemos encontrar otros. compílelos. cadena[256]. este tema será de los últimos del presente curso. y cuáles no? Para los identificadores no válidos proponga uno válido. En el último ejemplo. A[210]. Cliente y Persona son variables del tipo estructurado Registro. caracter. numero. float CxC. x+y if 454 C U A O ¿Cuáles de los siguientes identificadores son válidos. Ejemplos de definición de variables en base a tipos primitivos son los siguientes: int I. Deben ser identificadores válidos y no ser palabras reservadas. VoltajeEmisor. 20 . Cada variable debe ser declarada como de alguno de los tipos primitivos. struct Registro Persona. float Sumatoria=0. AlturaEnMetros. } Cliente.3 VARIABLES Las variables son objetos los cuales pueden cambiar de valor durante la ejecución de un programa por medio de una asignación. char *Apellidos. No se admiten espacios en blanco en medio de un identificador. VoltajeBase. nombre[30]. char *Nombre = "Tania Carolina".z. o el signo de subrayado(_). Ejemplo de definición de variables de tipo estructurado: char modulo[20]. char letra. char Ciudad[20]="Palmira Valle". int MatrizEnteros[3][3]. nueve='9'.V. contador=0. char VectorCadena[32]. float VectorReales[100]. int VectorEnteros[1000]. a .A. int edad. Abc While Cali aREa abc TotNomina Univalle Valle Apellido totalSumas acumulado integral I _contador CUAO Más MiAlgoritmo ABC serie 1 contador área xxxx 15 Quince Uno_A Pascal más UNIVALLE 2. float MatrizReales[5][4]. *codigo. tipos estructurados incorporados al lenguaje o también de tipos definidos por el usuario como variables estructuradas. Todos los nombres de variables deben comenzar obligatoriamente por un caracter alfabético. A Z. int edad. struct Registro{ char Nombre[10].Los siguientes son identificadores no válidos: Suma Total maximo valor while árbol 1_variable cantidad_en_$ do ßeta VariableNoVálida MáximoValor Nombre&Apellido I. float VoltajeDelColector. X[100]. o locamente. Otra forma de definir constantes en el antiguo C es la siguiente: #define MaxFila 100 #define PI 3. estos pueden contener uno cualquiera de los 256 caracteres del código ASCII ampliado. de la implantación de cada compilador de lenguaje y de la computadora utilizada. Los caracteres deben ir delimitados con comillas sencillas al ser asignados a variables de tipo char. Los tipos pueden ser numéricos o de caracter. esto podría ocasionar resultados indeseados y hasta en algunos casos el bloqueo del sistema operativo y la consecuente perdida de la información en memoria RAM. es decir dentro del ámbito de una función en particular.Las variables pueden ser declaradas globalmente. es decir dentro del ámbito de una función en particular. es decir fuera de las funciones que compongan el programa. Resumiendo: en las sentencias de asignación. los valores de la expresión a la derecha deben ser de tipos compatibles con el de la única variable de la izquierda.14159 const char *CAPITAL = "Bogotá". terminar='N'. y en base a estos se pueden definir tipos de datos estructurados. Las constantes pueden ser declaradas globalmente. 21 . La computadora almacena datos tanto en memoria como en dispositivos externos en código binario. Los objetos los cuales están compuestos de un solo caracter se definen con el tipo predefinido char. el cual no puede ser cambiado durante el transcurso del programa. en vez de esto permite una gran flexibilidad al programar. o locamente. es decir fuera de las funciones (ver capítulo 3) que compongan el programa.14159 #define CAPITAL "Bogotá" 2. char opcion. Lo recomendado es no mezclar tipos no compatibles al asignar valores a una variable. 2. ya que los datos son referidos mediante sus identificadores y el compilador del lenguaje hace la transferencia en forma automática.5 TIPOS DE DATOS La computadora es capaz de manejar y almacenar datos e información de varios tipos. El C++ no es un lenguaje "fuerte" en declaración de tipos. La cantidad de espacio que se asigna a cada dato depende de su tipo.4 CONSTANTES Las constantes son objetos las cuales estarán representadas por identificadores válidos y se les asigna un valor. Ejemplos de definición de constantes son los siguientes: const int MaxFila = 100. En casi todos los casos el almacenamiento es transparente para el programador y con mayor razón para el usuario. dejándolo a entera responsabilidad del programador. const float PI = 3. ya sea que el lenguaje en particular los traiga predefinidos o el usuario los defina. Ejemplos de declaración de este tipo de variables son: char letra='A'. Un valor de tipo char ocupa un byte de memoria. como por ejemplo lo es el lenguaje Pascal. 147.483.295 2. EnteroSinSigno. LONGITUD 8 8 16 16 16 16 32 32 32 64 80 bits bits bits bits bits bits bits bits bits bits bits RANGO DE VALORES 0 -128 -32.768 -32.767 32.4 * (10**-38) 1. a. numero. N=100. long EnteroLargo. Ejemplos de definiciones de variables de tipos numéricos son los siguientes: int a. Los diferentes tipos numéricos con su correspondiente longitud en Bytes.1 * (10**+4932) Si se pretende asignar a una variable un valor numérico que no corresponda al rango de valores se producirán resultados impredecibles que pueden llegar hasta el bloqueo del sistema operativo o la terminación del programa(por ejemplo en la división por cero). Total=0. EnteroCorto.535 32. EnteroLargo. terminar. int Vector[100]. caracter.7 * (10**-308) 3.4 * (10**-4932) a a a a a a a a a a a 255 127 32.4 * (10**+38) 1. unsigned int EnteroSinSigno. DoblePresicion. Los nombres de objetos que están compuestos de secuencias de caracteres se definirán con el tipo de datos predefinido char y de una de dos formas: 22 . Vector.767 4.768 0 -2.147. X. float X.967. float real.648 3. short int EnteroCorto. a. real.294. unsigned long EnteroLargoSinSigno. De esta forma se han definido las siguientes variables de tipo numérico: a. A. a las cuales se les podrá luego asignar valores ya sea por asignación dentro del algoritmo.647 3.1 TIPO unsigned char char enum unsigned int short int int unsigned long long float double long double Tipos de Datos Primitivos del C++.767 65. double DoblePresicion. A. por lectura desde el teclado o lectura desde un archivo en disco. etc.768 0 -32.char numero. digito y etc. opcion. float Matriz[10][20].483. Los objetos los cuales están compuestos por números y con los cuales se piensa efectuar operaciones aritméticas se definirán de los tipos primitivos int(entero) o float(real) o de alguno de sus tipos derivados. EnteroLargoSinSigno. y el rango de valores numéricos en cual maneja se presentan en la siguiente Tabla. N. caracter. char digito. De esta forma se han declarado las variables letra. Total. Tabla 2.7 * (10**+308) 1. es decir el espacio que ocupa cada uno en memoria. y Matriz. El lenguaje C/C++ utiliza como símbolo de asignación el igual(=). y EstaEsUnaVariableDeCadenaDeCaracteres. El valor de la expresión a la derecha debe ser de un tipo de datos compatible con la única variable a la izquierda. VectorEntero[2] = 13. en caso contrario se producirán resultados inesperados e inclusive el bloqueo de la máquina. son procesos en una sola dirección. Linea_Texto_en_Pantalla. NombreCompleto. valor = sqrt(144). 2. valor = 4. Apellido. Linea_Texto_en_Pantalla[80]. Matriz[0][0] = VectorEntero[I] * fila. La dirección de memoria corresponderá a una única variable que se ha definido inicialmente como de un tipo de datos específico y que en la expresión de asignación se coloca al lado izquierdo del símbolo igual(=). Apellido[25]. obteniendo un resultado. que es como hasta ahora lo a manejado. por esto la asignación es una operación destructiva. borrando el inicial. en una instrucción de asignación. que no tendría significado matemático. El valor que tomará la variable es el resultado de la evaluación de la expresión que se coloque al lado derecho del igual(=) en la expresión de asignación. El C++ en realidad no tiene predefinido un tipo de datos para este menester. 23 . las asignaciones en un algoritmo de computador. opcion = 'B'. ya que no se cumple para ningún X. este nuevo valor obtenido es asignado a la misma variable X(en la memoria RAM).dimensionando la variable con el tamaño adecuado a la necesidad o definiendo la variable como un puntero(*). El valor de la expresión de la derecha se asigna al de la única variable a la izquierda. Ejemplos de la declaración de variable de este tipo son los siguientes: char char char char char Nombre[20]. *NombreCompleto="Carolina Alexandra Mazuera Bravo". La expresión: X = X + 13. Se han declarado de esta forma las variables de tipo cadena de caracteres: Nombre. el proceso es el siguiente: El compilador evalúa la expresión a la derecha del símbolo de asignación(=).6 ASIGNACIÓN La asignación es una operación que coloca un valor en una dirección de la memoria RAM. VectorReal[0] = 7. Ciudad. es completamente válida. Los siguientes son ejemplos de asignaciones válidas: fila = 25. *EstaEsUnaVariableDeCadenaDeCaracteres.6.5E12. este lo asigna a la variable que está a la izquierda. Ciudad[15]= "Palmira Valle". En resumen el efecto es el incremento de la variable X en 13. Repitiendo. y significa que a la variable X se le suma el número 13. contador = contador + 1. A diferencia del símbolo igual en matemática. borrando el contenido previo que tuviera. 24 . será almacenado en la dirección de memoria de la variable que utilice la instrucción. 25 . para nuestro caso cout <<.1 Efecto en pantalla de la instrucción de lectura cin >>. Solamente por efectos de presentación en pantalla. el efecto se muestra en la misma próxima figura: cout << "Nombre de ciudad: ". adicionalmente. La presentación en pantalla sería mostrada en la figura mostrada más abajo. La instrucción cin >> en tiempo de ejecución detiene al computador y espera a que se digite un valor. La instrucción cout insertará en el flujo de salida hacia la pantalla la frase que está entre delimitadores y hará que la despliegue. A continuación el programa sigue secuencialmente en la instrucción del cin >> N. La presentación en pantalla sería la de la derecha de la siguiente figura: Figura 2.7 INSTRUCCIÓN DE LECTURA DESDE TECLADO Para transferir datos desde el teclado a la memoria RAM de la computadora utilizaremos la instrucción(en realidad es un objeto) del C++: cin >>. por ejemplo: clrscr().2. después de esto el control lo devuelve a la siguiente instrucción del programa. cout << "Digite un número: ". secuencialmente siguieran las dos instrucciones siguientes.h. cin >> N. Se detiene el programa con cin ┌─────────────────────────┐ │Digite un número: _ │ │ │ │ │ │ │ └─────────────────────────┘ nota: observe el cursor _ Luego de digitar el # y dar <ENTRAR> ┌───────────────────────────┐ │Digite un número: 13 │ │ │ │ │ │ │ └───────────────────────────┘ A continuación el valor digitado se almacena en la variable N y el programa sigue secuencialmente en la siguiente instrucción. la entrada se terminará cuando se digite la tecla de <ENTRAR>. la cual se encuentra en el archivo a incluir iostream. donde se le dijera al usuario lo que debe digitar a continuación. en espera de que el usuario digite. el valor que puede ser cualquier secuencia de caracteres ASCII terminados con la tecla de <ENTRAR>. debería ir previamente acompañada de una instrucción de impresión en pantalla. cin >> ciudad. se verá el cursor titilando. en este caso números. el programa se detendrá. Y si. 911699840 * 78. 26 .".h> #include <conio. cin >> radio. cout << "Digite el radio de la base del cilindro en centímetros: ". a partir de la lectura del radio de la base y su altura por teclado. Se detiene el programa con cin ┌─────────────────────────┐ │Digite un número: 13 │ │Nombre de ciudad: _ │ │ │ └─────────────────────────┘ nota: observe el cursor _ Luego de digitar el # y dar <ENTRAR> ┌───────────────────────────┐ │Digite un número: 13 │ │Nombre de ciudad: Palmira │ │_ │ └───────────────────────────┘ 2.58 * 78.3 Efecto de la ejecución del programa COUTIN00. cout << "\nEl volumen es de " << volumen << " centímetros cúbicos. 3.932861 centímetros cúbicos.933036 : M_PI //COUTIN00. cout << " CALCULO DEL VOLUMEN DE UN CILINDRO \n". #include <iostream. cout << "\n\n─────────────────────────────────────────────────────────". cin >> altura. volumen. ─────────────────────────────────────────────────────────_ Cálculos manuales de la secuencia que debió seguir el computador para el cálculo del Volumen: volumen volumen volumen volumen volumen = = = = = M_PI* radio*radio * altura.Figura 2.10530994 * 2.9 20.8 El siguiente algoritmo calcula el volumen de un cilindro.58 Digite la altura del cilindro en centímetros: 78.9 8. // volumen = area base( *r²) multiplicada por la altura volumen = M_PI* radio*radio * altura.h> #include <math.14159 * 2.58 * 2.h> // constante para el número main(){ float radio. cout << "Digite la altura del cilindro en centímetros: ".CPP observe la diferencia que se presenta en los decimales.CPP en pantalla CALCULO DEL VOLUMEN DE UN CILINDRO ───────────────────────────────────────────────────────── Digite el radio de la base del cilindro en centímetros: 2.2 Efecto en pantalla de la instrucción de lectura cin >>. altura.9 El volumen es de 1649. cout << "─────────────────────────────────────────────────────────\n\n".9 1649.58 * 78. } Figura 2. clrscr(). clrscr().CPP en pantalla Digite dos números enteros separados por al menos un espacio: 13 4 División entera = 3 División real = 3. cin >> Y. cin >> X. } 27 .CPP main(){ const int a=2.h> //COUTIN01. } Figura 2.h> #include <conio.2. cout << " Digite un valor real para X: ". //ensaye a borrar el reforzador cout << "\nResiduo división= " << a % b. b. cout<<"Digite dos números enteros separados por al menos un espacio:\n".h> // cout y cin //COUTIN02.4 Efecto de la ejecución del programa COUTIN01. Se introduce un reforzador de tipo en la división de las variables enteras a y b: (float). b=-3.2(Y -2) ] los valores reales para X y Y son leídos desde teclado. #include <iostream.25 Residuo división= 1_ 2.h> #include <conio.9 Ejemplo de operaciones de división en expresiones algebraicas. cout << "\n2a-3(b+2a)+3X[X-2(Y-2)] = " << 2*a-3*(b+2*a)+3*X*(X-2*(Y-2)). cout << "\nDivisión real = " << (float) a / b. Los valores para las constantes son: a=2 y b=-3 #include <iostream. cout << " Digite un valor real para Y: ". float X. Y.10 El siguiente código presenta la evaluación de la expresión algebraica: 2a .CPP main(){ int a. cin >> a >> b. getch().3(b + 2a) + 3X [ X . // simule este error: dele a "b" un valor de cero cout << "\nDivisión entera = " << a / b. y de la variable X pedidos por teclado.3 + (-1) 15 + (-1) 15 -1 14 28 . el coeficiente c: ". b. el coeficiente b: ".2. cout << "Digite cin >> b.00000 La evaluación de la expresión algebraica la efectúo el computador de la siguiente forma: Y Y Y Y Y Y Y Y = = = = = = = = a * X * X . c. cout << "Digite cin >> a.CPP main(){ float a. b. la variable X: ". 2 * 3 * 3 .h> #include <conio.h> //COUTIN03. Y. clrscr().1 * 3 + (-1) 18 . #include <iostream.1 * 3 + (-1) 6 * 3 . X.b * X + c. b * X + c. } Figura 2.11 El siguiente algoritmo evalúa la expresión cuadrática: Y = aX²-bX+c para valores de los coeficientes: a. c. cout << "Digite cin >> c.1 * 3 + (-1) 18 . valor de la variable Y es " << Y. El valor de la variable Y es 14.5 Efecto de la ejecución del programa COUTIN03. cout << "Digite cin >> X.CPP en pantalla Digite Digite Digite Digite el el el la coeficiente coeficiente coeficiente variable X: a: 2 b: 1 c: -1 3 el coeficiente a: ". Y = a * X * X cout << "\n\nEl getch(). #include <iostream.h> #include <conio.CPP en pantalla Digite un número entero para redondearlo: 879 El número redondeado es: 880 Digite cualquier tecla para terminar.. cout << "El número redondeado es: " << numero.."._ Figura 2.CPP en pantalla Digite un número entero para redondearlo: 844 El número redondeado es: 840 Digite cualquier tecla para terminar. cout << "\n\nDigite cualquier tecla para terminar.2. cout << "Digite cin >> numero. } Figura 2. * 10. / 10.h> //COUTIN04.6b Efecto de la ejecución del programa COUTIN04.6a Efecto de la ejecución del programa COUTIN04.12 Se lee un número por teclado y se redondea a la decena más próxima... numero = numero numero = numero numero = numero un número entero para redondearlo:\n".CPP main(){ int numero._ 29 . getch(). + 5.. clrscr().. 2.13 Conversión de escala termométrica centígrada a fahrenheit. #include <iostream.h> #include <conio.h> //COUTIN05.CPP main(){ float Centigrados, Fahrenheit; clrscr(); cout << " Conversión grados centígrados a fahrenheit \n"; cout << " ────────────────────────────────────────── \n\n"; cout << "Digite grados centígrados: "; cin >> Centigrados; Fahrenheit = 9.0 / 5.0 * Centigrados + 32; // observe los reales 9.0 y 5.0 en la línea anterior, // cámbielos por 9 y 5 y ejecute el programa de nuevo ¿porqué no da? cout << "\nLa temperatura en fahrenheit es: " << Fahrenheit << " "; gotoxy(1,25); cout << "Digite cualquier tecla para terminar el programa"; getch(); } Figura 2.7 Efecto de ejecución programa COUTIN04.CPP. Complételo Usted Conversión grados centígrados a fahrenheit ────────────────────────────────────────── Digite grados centígrados: 100 La temperatura en fahrenheit es: 212 Digite cualquier tecla para terminar el programa_ 30 2.14 El siguiente algoritmo encuentra la distribución de como un cajero de un banco tiene que distribuir una dada cantidad de dinero en la menor cantidad de billetes y monedas. Solo funciona para cantidades enteras. #include <iostream.h> #include <iomanip.h> #include <conio.h> //COUTIN10.CPP main(){ long int cantidad, saldo, b20000, b10000, b5000, b2000, // billetes m1000, m500, m200, m100, m50, m20, m10, m5, m2, m1; //monedas clrscr(); cout << "Cantidad a repartir: "; cin >> cantidad; b20000 = cantidad / 20000; saldo = cantidad % 20000; b10000 saldo b5000 saldo b2000 saldo m1000 saldo m500 saldo m200 saldo m100 saldo m50 saldo m20 saldo m10 saldo m5 saldo m2 m1 cout cout cout cout cout cout cout cout cout cout cout cout = = = = = = = = = = = = = = = = = = = = = = = = saldo saldo saldo saldo saldo saldo saldo saldo saldo saldo saldo saldo saldo saldo saldo saldo saldo saldo saldo saldo saldo saldo saldo saldo / % / % / % / % / % / % / % / % / % / % / % / % 10000; 10000; 5000 ; 5000; 2000; 2000; 1000; 1000; 500; 500; 200; 200; 100; 100; 50; 50; 20; 20; 10; 10; 5; 5; 2; 2; << << << << << << << << << << << << "\n──────────────────────────────────"; "\nDENOMINACION CANTIDAD TOTAL($)"; "\n──────────────────────────────────"; "\n$20,000 " << "\t" << b20000 << "\t" << "\n$10,000 " << "\t" << b10000 << "\t" << "\n$ 5,000 " << "\t" << b5000 << "\t" << "\n$ 2,000 " << "\t" << b2000 << "\t" << "\n$ 1,000 " << "\t" << m1000 << "\t" << "\n$ 500 " << "\t" << m500 << "\t" << "\n$ 200 " << "\t" << m200 << "\t" << "\n$ 100 " << "\t" << m100 << "\t" << "\n$ 50 " << "\t" << m50 << "\t" << setw(10) << 20000*b20000; setw(10) << 10000*b10000; setw(10) << 5000*b5000; setw(10)<< 2000*b2000; setw(10)<< 1000*m1000; setw(10)<< 500*m500; setw(10)<< 200*m200; setw(10)<< 100*m100; setw(10)<< 50*m50; 31 cout << "\n$ 20 " << "\t" << m20 << "\t" << setw(10) << 20*m20; cout << "\n$ 10 " << "\t" << m10 << "\t" << setw(10)<< 10*m10; cout << "\n$ 5 " << "\t" << m5 << "\t" << setw(10)<< 5*m5; cout << "\n$ 2 " << "\t" << m2 << "\t" << setw(10)<< 2*m2; cout << "\n$ 1 " << "\t" << m1 << "\t" << setw(10)<< m1; cout << "\n──────────────────────────────────\n"; cout.width(34); cout.fill('$'); cout << cantidad; cout << "\n──────────────────────────────────"; cout << "\n\n\n Digite cualquier tecla para terminar"; getch(); } Figura 2.8 Efecto de la ejecución del programa COUTIN10.CPP en pantalla Cantidad a repartir: 95673951 ────────────────────────────────── DENOMINACION CANTIDAD TOTAL($) ────────────────────────────────── $20,000 4783 95660000 $10,000 1 10000 $ 5,000 0 0 $ 2,000 1 2000 $ 1,000 1 1000 $ 500 1 500 $ 200 2 400 $ 100 0 0 $ 50 1 50 $ 20 0 0 $ 10 0 0 $ 5 0 0 $ 2 0 0 $ 1 1 1 ────────────────────────────────── $$$$$$$$$$$$$$$$$$$$$$$$$$95673951 ────────────────────────────────── Digite cualquier tecla y terminar_ 32 2.15 El siguiente programa muestra la utilización de tabuladores predefinidos para alinear en pantalla información. Así mismo presenta una introducción al formateo de números con la utilización de cout.precision y cout.fixed. Además es una introducción al manejo de cadenas de caracteres. #include <iostream.h> #include <conio.h> //COUTIN06.CPP main(){ int c1=10, c2, c3=20; // cantidades de cada fruta float p1=3.2, p2, p3=4.5; // precios de cada fruta char fruta1[10]="lulo", fruta2[10]="", fruta3[10]="papaya"; // nombres clrscr(); cout << "┌───────────────────────────────────────────────┐\n"; cout << "│ MERCADO DE FRUTAS │\n"; cout << "└───────────────────────────────────────────────┘\n"; cout << "Digite el nombre de la fruta 2: "; cin >> fruta2; //digite uvas y luego mandarina, observe que falla el tabulado cout << "digite el precio(con centavos) de la fruta 2: $ "; cin >> p2; cout << "digite la cantidad a comprar de la fruta 2: "; cin >> c2; clrscr(); cout<< setprecision(2) //formateo de los números reales << setiosflags(ios::showpoint | ios::fixed) cout << "┌───────────────────────────────────────────────┐\n"; cout << "│NOMBRE CANTIDAD PRECIO TOTAL │\n"; cout << "└───────────────────────────────────────────────┘\n"; cout <<" " << fruta1 << "\t\t" << c1 << "\t\t" << p1 << "\t" << c1*p1 << "\n"; cout <<" " << fruta2 << "\t\t" << c2 << "\t\t" << p2 << "\t" << c2*p2 << "\n"; cout <<" " << fruta3 << "\t\t" << c3 << "\t\t" << p3 << "\t" << c3*p3 << "\n"; cout << "────────────────────────────────────────────────\n\n"; } Figura 2.9 Efecto de la ejecución del programa COUTIN06.CPP en pantalla ┌───────────────────────────────────────────────┐ │ MERCADO DE FRUTAS │ └───────────────────────────────────────────────┘ Digite el nombre de la fruta 2: uvas digite el precio(con centavos) de la fruta 2: $ 7.50 digite la cantidad a comprar de la fruta 2: 10; ┌───────────────────────────────────────────────┐ │NOMBRE CANTIDAD PRECIO TOTAL │ └───────────────────────────────────────────────┘ lulo 10 3.2 32.00 uvas 10 7.5 75.00 papaya 20 4.5 90.00 ────────────────────────────────────────────────_ 33 //No hace "eco en pantalla" ni se le dio ENTER cout << "\nEl caracter digitado fue \"" << caracter << "\" su código ASCII es el " << "\"" << (int) caracter << "\" ".h> #include <conio. clrscr(). ASCII es el acrónimo de: American Standard Code for International Interchange.h> //COUTIN07. cin >> caracter. // (int) en la línea anterior es un reforzador de tipo (cast en inglés) cout << "\nDigite otro caracter cualquiera del teclado: ". cout << "\nDigite otro caracter cualquiera del teclado: ". Se hace lectura de un caracter con las funciones getch() y getche() de conio.16 Demostración de los valores del código ASCII. cout << "\nDigite otro caracter cualquiera del teclado: ". caracter = getche().10 Efecto de la ejecución del programa COUTIN07.CPP en pantalla Digite un caracter cualquiera del teclado: A El caracter digitado fue "A" su código ASCII es el "65" Digite otro caracter cualquiera del teclado: El caracter digitado fue "a" su código ASCII es el "97" Digite otro caracter cualquiera del teclado: * El caracter digitado fue "*" su código ASCII es el "42" Digite otro caracter cualquiera del teclado: Ñ El caracter digitado fue "Ñ" su código ASCII es el "165"_ 34 .h #include <iostream. //Si hace "eco en pantalla" y no se le dio ENTER cout << "\nEl caracter digitado fue \"" << caracter << "\" su código ASCII es el " << "\"" << (int) caracter << "\"". cout << "El caracter digitado fue \"" << caracter << "\" su código ASCII es el " << "\"" << (int) caracter << "\" ".CPP main(){ char caracter. } Figura 2. caracter=getch(). caracter = getche(). //Si hace "eco en pantalla" y no se le dio ENTER cout << "\nEl caracter digitado fue \"" << caracter << "\" su código ASCII es el " << "\"" << (int) caracter << "\"". getch(). cout << "Digite un caracter cualquiera del teclado: ".2. cout << "En decimal a = " << a << " b = " << b << endl << endl << "OPERACION HEXADECIMAL DECIMAL \n\n" << " a + b = " <<setw(15) <<hex <<a+b <<setw(15) <<dec <<a+b <<endl << " a . cout << "Primer operando(Digite 0x primero): ". cin >> a.CPP void main(void){ long int a. } Figura 2.11 Complete el efecto de la ejecución del programa COUTIN12. clrscr(). getch().h> <iomanip. y por medio de su conversión con los MANIPULADORES DE FLUJO siguientes: hex para base diez y seis ó hexadecimal dec para base diez ó decimal #include #include #include <iostream. se presentan operaciones matemáticas elementales. cout << "Digite operandos en hexadecimal.h> //COUTIN12.h> <conio.b = " <<setw(15) <<hex <<a-b <<setw(15) <<dec <<a-b <<endl << " a * b = " <<setw(15) <<hex <<a*b <<setw(15) <<dec <<a*b <<endl << " a / b = " <<setw(15) <<hex <<a/b <<setw(15) <<dec <<a/b <<endl << " a % b = " <<setw(15) <<hex <<a%b <<setw(15) <<dec <<a%b <<endl. b. anteponiendo 0x cada vez\n". tanto en decimal como en hexadecimal.17 A partir de la lectura de un número en base hexadecimal.2.CPP. 35 . cin >> b. cout << "Segundo operando(Digite 0x primero): ". 18. y la máquina le responda con el salario básico. Por ejemplo: Aparece en pantalla: "Digite el número 36 .43 libras/pie cúbico Kbyte = 1024 bytes lea desde el teclado el valor de la primera unidad y conteste con el correspondiente a la segunda. las comisiones. para obtener un aumento de temperatura desde Ti hasta Tf. Recuerde que cada lenguaje de programación trae gran cantidad de instrucciones.18. su cédula.03. R4 permita Gt = efectuar 1 --Rt las siguientes conversiones de 2.5 Determinar la cantidad de calor Q en calorías a proporcionar a un cuerpo. según las siguientes expresiones: 1 Rt = --R1 + 1 --R2 + 1 --R3 + que 1 --. 2. tanto de cuantos galones de gasolina a tanqueado como de cuantos kilómetros a recorrido en su vehículo.39 centímetros cúbicos gramo/cm cúbico = 62. 2.18.Ti). Plomo=0. la masa del cuerpo y el calor específico. por medio de la Ley de los gases ideales: PV = nRT.4 Calcule la presión de un gas. recuerde el dicho: "una imagen vale más que mil palabras".8( C) + 32 pulgada cúbica = 16.6 gramos Kw = 58. y la cantidad en pesos de sus ventas.6 Digite una cantidad que representará dinero(pesos($)).8 Realice unidades: Longitud: Masa: Potencia Presión Temperatura Volumen Densidad Información 1 1 1 1 1 1 1 1 programa pulgada = 2. 2.18.3 Una compañía paga a los vendedores un salario básico más un porcentaje por comisiones por las ventas efectuadas.0.18.2.69 psi F = 1. Anote las preguntas que crea conveniente efectuar al profesor. de resistores R1. tenga presente que si las ve ejecutándose deberá entender que es lo que hacen. donde R = 0. 2. y conectados en paralelo. dados su volumen.2 y Cobre = 0. y el total a pagar a este vendedor. Efectúe programa el cual le permita digitar esta información por teclado y a continuación que le conteste con el número de galones/kilómetro del vehículo. 2.18. a continuación un número real que representará un porcentaje. El programa debe responderle con la cantidad en pesos correspondiente al porcentaje digitado.082054 (atm litro)/(mol K). Utilice la ecuación Q = m C (Tf .18 ACTIVIDADES PARA EFECTUAR PERSONALMENTE 2. R2. R3 y R4 dados en ohmios.54 centímetros libra = 453.18. 2. Leer desde teclado las temperaturas inicial y final.2 Un conductor lleva registros.10.. y que sería imposible explicarsélas todas en el limitado espacio de un manual como el presente.87 BTU/minuto atm = 14.18. Para un vendedor efectúe programa el cual le permita digitar el nombre del vendedor.1 Efectúe lectura de todos los algoritmos presentados anteriormente en este capítulo. Aluminio=0. Corra el programa para cada uno de los siguientes valores de calor específico en calorías/(gramo C) siguientes: Agua = 1.7 Calcule la conductancia total Gt(Siemens) y la resistencia total Rt(ohmios). número de moles y temperatura. 18.18.11 Estudie todos los ejemplos que se ha "saltado". debe aparecer como respuesta: "Son 25. 2. de las lecciones anteriores.9 Consultando la tabla de caracteres presente en pantalla el siguiente cuadro: ASCII. a continuación el usuario digita el número 10. Codifique un programa en C el cual permita capturar el Capital. escribir un programa que Para poder obtener cada caracter debe simultáneamente tener undida la tecla de ALT(alternate) y en el teclado numérico digitar el código ASCII correspondiente. la rata de interés y los días para el préstamo de un solo cliente de una entidad prestamista. 2.4 centímetros". 2. o ha dejado para un mejor momento. incluye la división entre 365 días. por lo tanto.10 El fórmula: interés simple de un préstamo se calcula mediante la siguiente Interés = Capital x rata x días/365 La fórmula anterior supone que rata en la tasa de interés anual y. 37 . y que calcule y muestre en pantalla el Interés simple para el mismo.18.de pulgadas: ". . sinl sqrt. definiendo su sintaxis general. Estos subproblemas los podemos implementar en el lenguaje C mediante la codificación de funciones. atof. frexp. asinl _atold cosl fabsl frexpl ldexpl _matherrl powl sinhl tanhl M_PI_4 M_1_SQRTPI M_SQRT_2 39 . Una función es sitio del programa el lenguaje y las definirlas nosotros simplemente un algoritmo el cual devuelve un único valor al en que fue invocada o llamada.1 Funciones y constantes incorporadas en el archivo a incluir math. Esta estrategia también se llama diseño descendente. Hay funciones predefinidas en cuales vienen en los archivos incluidos y también podemos mismos. 3. cabsl ceil. floorl fmod. atanl atan2.CAPÍTULO 3 "DIVIDE Y VENCERÁS": FUNCIONES 3. y así sucesivamente. debido a que se parte de lo general y se diseñan soluciones específicas para sus subproblemas. Todos los programas del presente capítulo están en el disquete anexo.1 METODOLOGÍA El profesor explicará en clase magistral en qué consisten las funciones. hypotl labs log. fmodl hypot.2 FUNCIONES INCORPORADAS AL C++ A TRAVÉS DE LIBRERÍAS La principal estrategia de la programación estructurada al resolver un problema complejo es la de dividirlo en subproblemas cuya resolución sea mucho más sencilla. atan2l cabs. tanl Constantes: ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ M_PI M_PI_2 M_1_PI M_2_PI M_2_SQRTPI M_SQRT2 asin. tanh. Tabla 3. expl floor. ceill cosh. logl log10. ldexp. encontrará en el nivel de ayuda del compilador. estúdielos inicialmente y luego compílelos y ejecútelos para verificar sus expectativas. sqrtl tan. según la conveniencia. polyl pow10. cos.h Funciones ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ abs acos. pow10l sin. acosl atan. log101 modf. Estos subproblemas se pueden dividir a su vez en otros más pequeños. sinh. Más sobre las funciones incorporadas en el C++. modfl poly. pow. fabs. coshl exp. matherr. h> // MAXINT #include #include #include #include //COUTIN_6. cout <<"▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄".y. cout << "Digite un número como base: ". clrscr().h> <values. mayor que "<< x << " = "<<ceil(x). cout << "Digite el exponente: ". cout << "\nLogaritmo decimal = " << log10(x). cout << "\nNúmero real: " << x. cout<<"\nMenor entero. clrscr(). cout << "\n\nRecuerde el máximo entero es " << MAXINT. cin >> x.h> <math. cout << "\nFUNCIONES VARIAS INCORPORADAS EN <MATH.3.H>\n". } 40 . cout<<"▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀".y). cout << "\nNúmero para calcularle la raíz cuadrada: ". cin >> a. cout << "su valor absoluto es " << fabs(x). cout << "\n\nDigite un número con decimales: ".3 Este programa emplea funciones matemáticas del archivo de cabecera "math. cout << "su valor absoluto es " << abs(a). cin >> x. cout << "\Digite el otro cateto: ". cout << "Raíz cuadrada de " << x << " = " << sqrt(x).h" <iostream. float x. menor que " <<x << " = " <<floor(x). cout << "\n\nDigite un número real: ". cout << " " << x << "\ne = " << exp(x). cin >> x. cin >> x. cout<<"▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄". cout << "\n\nHipotenusa de un triángulo rectángulo: ". cout << "\nFUNCIONES VARIAS INCORPORADAS EN <MATH. y). cout<<" " <<x << " ^ " <<y << " = "<< pow(x. cout<<"\n\nA continuación ejemplo de exponenciación: \n". cin >> y. cin >> x. cout << "\n\nDigite un real negativo: ". cout << "\nDigite un valor real x para obtener e : ". cout << "\nDigite un cateto: ". cout <<"▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀".CPP void main(){ int a. cin >> x. cin >> y.h> <conio. cout << "\n\nDigite un entero negativo: ". cout << "\n\n x ". cout<<"Mayor entero. cin >> x. cout << "\n\nEl número e = " << exp(1). cout << "\nLogaritmo natural = " << log(x).H>\n". cout << "\nLa hipotenusa es " << hypot(x. 3.0.. angulo -= 30..8660254 1. // se formatean los números con 1 decimal cout. //real de doble precisión.". angulo += 30. cout << "\n\n Digite cualquier tecla y terminar.h> #include <math.0.h> funciones trigonométricas contenidas en el //COUT03.0. cout << "\nTangente (" << angulo << " ) = " << sin(angulo*M_PI/180) / cos(angulo*M_PI/180).141593 Seno ( 0 Coseno (30 Tangente (60 Cotangente(90 Secante (60 Cosecante (30 = 3.precision(7).setf(ios::scientific). angulo -= 30. angulo += 30. cout << "\nCosecante (" << angulo << " ) = " << 1/sin(angulo * M_PI/180). cout << "\nCotangente(" << angulo << " ) = " << cos(angulo*M_PI/180)/sin(angulo*M_PI/180).0.setf(ios::fixed).1e+00 ) ) ) ) ) ) = = = = = = 0 0.0. } Figura 3.. // se utiliza notación fija en números cout << "\n\nSeno ( " << angulo <<" ) = " << sin(angulo * M_PI/180).0._ 41 . cout << "\nCoseno (" << angulo <<" ) = " << cos(angulo * M_PI/180). cout.2 Efecto de la ejecución del programa COUT03. getch(). cout << " = " << M_PI. cout << "\n = " << M_PI. angulo += 30.1415927 = 3.CPP = 3.h> #include <conio. 8 bytes = 64 bits clrscr(). cout. cout << "\nSecante (" << angulo << " ) = " << 1/cos(angulo* M_PI/180).h" #include <iostream..CPP void main(){ double angulo = 0.4 El siguiente programa emplea archivo de cabecera "math.precision(1). // se formatean los números con 7 decimales cout.7320508 0 2 2 Digite cualquier tecla y terminar. // se utiliza notación científica cout << "\n = " << M_PI. h> <conio. cadena2[LargoCadena].CPP const int LargoCadena=15. strcpy(cadena1.. cout << "ahora la variable cadena1 = " << cadena1.h> <string. 42 . gets(cadena2). cout << "\n\n\n\n\n\ncualquier tecla y seguir". cout << "\na continuación se asigna la cadena2 a la cadena1\n".3. cout << "\n\nDigite una frase con mucho más de " << LargoCadena << " caracteres\n". cout << "\n\n es probable que con lo anterior se le bloquee el computador".h #include #include #include #include <iostream. cout << "La frase digitada fue: " << cadena2. cout << "Digite una frase para almacenar en la variable cadena1:\n".3 Ejecución programa COUT03. cadena2). gets(cadena1). cout << "\n\nen este momento cadena1 = " << cadena1. //para efectuar dimensionamiento de las variables de cadena void main(){ char cadena1[LargoCadena].h> // para efectuar asignación de cadenas utilizar: strcpy() <stdio. cout << "La frase digitada fue: " << cadena1.h> // para leer espacios en blanco utilizar: gets() //COUTIN09.. } Figura 3. cout << "\n\nDigite otra frase para almacenar en la variable cadena2:\n".5 Algunas funciones para el manejo de cadenas de caracteres incluidas en string. Complételo. //En conclusión debe observar que cin<< solo lee hasta el primer espacio //para leer varias palabras tiene que hacerlo con gets().CPP en pantalla. //variables de tipo cadena clrscr(). cin >> cadena1. cout << "\nlos caracteres almacenados son: " << cadena1. getch(). sound(260). delay(Tempo). delay(Tempo/2).6 El siguiente programa permite oír notas musicales entre 260 Hz y 520 Hz. ". ". ". sound(440). ". #include <iostream. cout << "\nSilencio\n". cout << "\nSilencio\n". ". delay(Tempo/4).h>: sound() y nosound(). delay(Tempo/2). delay(Tempo/2). sound(520). delay(Tempo/4). nosound(). sound(290). ". sound(342). delay(Tempo). sound(390). sound(290). sound(260). ". delay(Tempo/2). delay(Tempo). delay(Tempo/4). ". sound(520).h> #include <conio. delay(Tempo/4). nosound(). delay(Tempo/2). } cout cout cout cout cout cout cout cout << << << << << << << << "Do "Si "La "Sol "Fa "Mi "Re "Do ". ". delay(Tempo). sound(390). delay(Tempo). ". ".h> //COUT04. nosound(). delay(Tempo). 43 .h> #include <dos. sound(342).3. delay(Tempo/4). ". sound(322). delay(Tempo). ". ". sound(290). sound(390). sound(440). ". sound(260). ". delay(Tempo/2). // aproximadamente 1000 milisegundos void main(){ clrscr(). delay(Tempo/4). delay(Tempo/2). ". delay(Tempo). sound(322). cout cout cout cout cout cout cout cout << << << << << << << << "Do "Re "Mi "Fa "Sol "La "Si "Do ". sound(520). delay(Tempo/2). sound(494).CPP const Tempo=1000. ". sound(494). sound(342). cout cout cout cout cout cout cout cout << << << << << << << << "Do "Re "Mi "Fa "Sol "La "Si "Do ". delay(Tempo/4). delay(Tempo/4). a través de la utilización de funciones incorporadas en <dos. delay(Tempo/2). sound(322). ". sound(440). ". getch(). ". delay(Tempo). sound(494). arc(X/2.C IniciaModoGrafico(){ int ManejadorGrafico. IniciaModoGrafico(). fillellipse(X/2. putpixel(44. putpixel(48.Y-Y/8. setcolor(BLUE).WHITE). ManejadorGrafico = DETECT. closegraph(). "C:\\TC\\BGI").1). setcolor(WHITE). circle(X/4. initgraph(&ManejadorGrafico.360.Y/2.h> #include <conio.45.270.0. setfillstyle(1.150).100).Y-15).Y-Y/4. circle(X/4.WHITE). pieslice(X-X/4.CYAN).Y/4). Y/2.44.X-50.3.10. Y).X/2+90. ModoGrafico.Y/10). rectangle(10. Y = getmaxy().X/6).LIGHTBLUE). setfillstyle(1. X = getmaxx().40.15. setcolor(LIGHTMAGENTA). bar3d(X/2+50.X/20.7 El siguiente programa presenta una introducción a las funciones básicas ó primitivas de dibujo del modo gráfico del Turbo C.42.Y/2.WHITE). setcolor(WHITE). setfillstyle(1.40.WHITE).h> //GRAFICA1.GREEN). setcolor(GREEN).YELLOW). getch(). setfillstyle(1.Y-10).270. setcolor(LIGHTGREEN).300. setcolor(YELLOW).Y/10). #include <graphics. setfillstyle(1.50. putpixel(46. putpixel(50.. 150 ).Y/8.5 Ejecución programa GRAFICA1. 0.90. } main(){ int X.360. putpixel(42. putpixel(40. Complételo. setcolor(BLUE). Y/2. &ModoGrafico.C en pantalla.46. line( 0. sector(X/2.WHITE).Y/2. } Figura 3. bar(X-20.Y/4.RED).Y/2.48. setbkcolor(BLACK). setcolor(RED).X/6.X/20. Y/2. ellipse(X/2. Y. 100 ).X-10. X. cleardevice().90. setcolor(BROWN). circle(X/4. 44 . 50 ).WHITE). arc(X/2..X/6. setcolor(DARKGRAY). 45 . : M_PI //FUNCION0. Sabido esto podríamos trabajar las tres situaciones como entidades separadas y al final unirlas en un solo programa. En este capítulo se presentan ejemplos de funciones definidas por nosotros mismos en nuestro propio algoritmo.CPP //Definición de prototipos de las funciones 46 . EscrituraEnPantalla().h> #include <conio. en segundo lugar efectúa unos cálculos y en tercer lugar muestra en pantalla los resultados.h> // constante para el número LecturaDesdeTeclado().8 NUESTRAS PROPIAS FUNCIONES Como habíamos visto. una función es simplemente un algoritmo el cual devuelve un único valor al sitio del programa en que fue invocada o llamada.h> #include <math. CalculoConFormula(). en un diagrama de bloques se vería como en la Figura siguiente: Figura 3. Primero observemos que el algoritmo hace básicamente tres cosas: primero la lectura de datos desde el teclado. A continuación se codifica algoritmo para el cálculo del volumen de un cilindro.6 Diseño Descendente del Cálculo de un Volumen.3. ┌────────────────────┐ │ Programa │ │ Cálculo Volumen │ │ de un Cilindro │ └─────────┬──────────┘ │ ┌───────────────────────┼────────────────────────────┐ │ │ │ ┌───────────┴─────┐ ┌─────────┴────────┐ ┌────────────┴─────┐ │ Lectura de │ │ Cálculo │ │ Escritura │ │ radio y altura │ │ del Volumen │ │ del Volumen │ │ desde teclado │ │ con la fórmula │ │ en pantalla │ └─────────────────┘ └──────────────────┘ └──────────────────┘ El algoritmo y explicaciones correspondientes siguen a continuación: #include <iostream. cout << "─────────────────────────────────────────────────────────\n\n". getch(). cout << "Digite la altura del cilindro en centímetros: ". } Obsérvese. LecturaDesdeTeclado(). para ver en pantalla digite Alt+F5. No en todos los programas son necesarias las funciones. Cuando se ejecuta una instrucción de este tipo decimos que se está invocando o llamando a la función en cuestión. Sin duda. Además. escritura y posterior mantenimiento del programa. consisten a su vez. volumen. Ejecute el programa anterior paso a paso con la tecla de F7. los programas fuentes grandes // invocación de funciones // instrucción de retardo 47 . Sin embargo esta estrategia presenta varios problemas. Cuando la función termina la secuencia del programa "retorna" a la instrucción siguiente a la de la invocación. de funciones. el programa seguirá siendo correcto si se escriben estas proposiciones en cada punto del programa donde se necesiten. El profesor explicará paso a paso en clase magistral este algoritmo. main(){ //Definición de variable globales //Función principal clrscr(). main(). cout << "\n\n─────────────────────────────────────────────────────────".". cin >> altura. que las instrucciones empleadas en la función principal.float radio. } LecturaDesdeTeclado(){ cout << "Digite el radio de la base del cilindro en centímetros: ". } EscrituraEnPantalla(){ cout << "\nEl volumen es de " << volumen << " centímetros cúbicos. altura. en el algoritmo anterior. Una de las razones más obvias para escribir una secuencia de proposiciones como una función es que la secuencia se utiliza varias veces en diferentes partes del programa. } CalculoConFormula(){ // volumen = area base( *r²) multiplicada por la altura volumen = M_PI * radio*radio * altura. CalculoConFormula(). cin >> radio. Esto dificultará la lectura. cout << " CALCULO DEL VOLUMEN DE UN CILINDRO \n". En primer lugar el programa será más grande de lo necesario. esto ocasiona la transferencia de la secuencia del programa a este bloque de código y su seguida ejecución. EscrituraEnPantalla(). cout << "\ny la variable B ahora es igual a " << b. esto aumentará la legibilidad del programa. para luego unirlos como piezas de un rompecabezas en un solo programa fuente.9 El siguiente algoritmo presenta el intercambio del valor de dos variables en la memoria RAM del computador. cout << "Digite un real para almacenar en variable A: ".CPP float a. y más aún. Es de esperar que un cálculo determinado se lleve a cabo de la misma manera en todos los puntos del programa en que se necesita. cin >> a. A ahora es igual a " << a. } main(){ clrscr().b. 3. es solo por motivos didácticos de apredizaje que se presenta así. } 48 . En segundo lugar. En la sección siguiente se presentan algunos algoritmos ya resueltos en el capítulo anterior. La primera impresión será la de ¿Para qué todo esto si era más corto antes?. se verá con menor claridad la naturaleza del cálculo que realiza el programa. empero. #include <iostream. cout << "\nDespués de intercambiadas. cout << "Digite un real para almacenar en variable B: ". La verdadera importancia solo se vendrá "a sentir" cuando se desarrollen programas más grandes. permitirá el dividir el programa descendentemente y dedicarnos al trabajo de bloques de código determinados (por separado y aún por varias personas.h> #include <conio. // Variables globales IntercambioEnMemoria(){ float aux. en próximos semestres. y no complicar con mayores detalles la presentación inicial de las funciones. //variable local aux = a. cin >> b. IntercambioEnMemoria(). b = aux. sin perder la abstracción de totalidad del programa). tiene alguna diferencia? La agrupación de instrucciones a través de funciones sugiere que ellas tienen un objetivo en particular. Si esto no se hace así.requieren una porción mayor de la memoria de la computadora en tiempo de ejecución. a = b.h> //FUNCION1. Efectúe pruebas de ejecución manual a cada uno de ellos. el lector del programa abrigará sospechas y se preguntará ¿por qué se repite este código. j. cin >> i.h> #include <conio. cout << "X = " << X << " Y = " << Y << " Z = " << Z. DetY. cout << "Coeficiente de X : ". void EscribirResultados(){ cout << "\n\n". Y = DetY / DetSistema. cin >> b. Z = DetZ / DetSistema. . .i*h*c DetZ = a*f*l + e*j*d + i*b*h .h. cin >> k.f. Y. cout << "Digite términos de la Primera Ecuación: \n". DetSistema = a*f*k + e*j*c + i*b*g DetX = d*f*k + h*j*c + l*b*g . cin >> c.". DetSistema. //FUNCION2. cout << "Coeficiente de Y : ".k*h*b.3. cin >> j. getch(). . CalculoIncognitas().k. cin >> g.10 El siguiente algoritmo soluciona un sistema lineal de tres incógnitas con tres variables. cout << "Término independiente: ".i*f*d X = DetX / DetSistema.g.e. cout << "Coeficiente de Z : ". cin >> a.l.CPP // coeficientes y términos independientes // incógnitas a encontrar. #include <iostream. cout << "Coeficiente de Z : ". cout << "\nDigite términos de la Tercera Ecuación: \n". cout << "----------------------------------------\n". void LeerCoeficientes(){ clrscr(). cout << "\nDigite términos de la Segunda Ecuación: \n". cout << "----------------------------------------\n".j*g*a ..d. cout << "----------------------------------------\n".l*f*c DetY = a*h*k + e*l*c + i*l*g . cout << "Coeficiente de X : ". cout << "Coeficiente de Y : ". } void main(){ LeerCoeficientes(). cout << "\n\nDigite cualquier tecla para terminar.j*g*d . cout << "Término independiente: ". DetZ. Z. cout << "Término independiente: ".l*g*a . } // Variables locales i*f*c . por el método de Cramer. cin >> h. } void CalculoIncognitas(){ float DetX.i.h> float a. cin >> f. cout << "Coeficiente de Y : ".b. cin >> e. cin >> d..c. cin >> l.l*e*b.k*e*d. X. cout << "Coeficiente de Z : ". cout << "Coeficiente de X : ".k*e*b.j*h*a . EscribirResultados(). } 49 . cin >> entero. //variable entera a descomponer void DescomponerEntero(){ int resto. // (X. Y--.Y). X=25.Y). centenas. Y=12.h> #include <values. resto = resto % 1000.Y). getch(). #include <iostream. cout << "Decenas Y--. cout << "Recuerde que el máximo entero es: \a" << MAXINT. gotoxy(X. Y--.h> #include <conio.CPP int entero. gotoxy(X.Y) serán coordenadas en pantalla para gotoxy() gotoxy(X. Y--.3. gotoxy(X. cout << "Unidades de mil = " << resto / 1000. cout << "Centenas resto = resto % 100.h> //MAXINT //FUNCION4. = " << entero / 10000.Y).Y). cout << "Decenas de mil resto = entero % 10000. DescomponerEntero(). cout << "Unidades } main(){ clrscr(). cout << "\nDigite un entero: ". unidades de mil. = " << resto % 10. gotoxy(X.11 El siguiente algoritmo descompone una cantidad entera en decenas de mil. } = " << resto / 100. = " << resto / 10. decenas y unidades. 50 . f. M es: M = i ( 1 + i )n P ----------------( 1 + i )n .2 * 4 + 7) % 4 * 11 . La fórmula para calcular mensual.pow(2. Supóngase que se desea pedir un préstamo de P pesos para en n pagos mensuales. ¿Cuál es la caída de voltaje Vi(Voltios) para cada resistencia. e. g. como lo haría el computador.pow(3. d.12. 3.pow(3. compuesto de tres ecuaciones y tres incógnitas. así: X X = ---S Y Y = ---S Z Z = ---S 3. c. Z. 3) ) * 7) / 3 * 18 . (16 .12. por el método de Cramer. l) y calcule los valores de las incógnitas X. las siguientes expresiones. con una tasa de interés i.2) * (4 3. y luego los determinantes particulares para cada variable. h.2 debidos pagarlo el pago En economía se dispone de fórmulas para calcular los pagos mensuales a un préstamo. 10 .pow(2. 4) (16 .12 ACTIVIDADES PARA REALIZAR EN GRUPO DE ESTUDIO 3.3.1 Codifique la anterior fórmula como una expresión entendible por el computador y dentro de un programa escrito en lenguaje C++.3 Solucione un sistema de ecuaciones lineales. k.1 Expresiones algebraicas: Evalúe manualmente. recuerde que son tres rectas en el espacio. 24 y 26 conectados en serie?. b. Lea inicialmente los coeficientes (a.12. Muestre cálculos paso a paso hasta llegar al resultado final.2 * 4 * 7 / 3 * ( 18 . si pasa una corriente I de 10 Amperios por el circuito: 51 . 4) 16 . así: a S = e i b f j c g k d X = h l b f j c g k a Y = e i d h l c g k Z = a e i b f j d h l finalmente calcule cada valor de las tres variables como la división entre el determinante particular de cada variable y el determinante del sistema.2 * 4) + ( 7 % 4 * 11 ) . es el siguiente: aX + bY + cZ = d eX + fY + gZ = h iX + jY + kZ = l Método de Cramer: calcule inicialmente el determinante del sistema dado. j. El sistema general a solucionar.12. Y. i. 3) (16 .4 ¿Cuál es la conductancia Gt(Siemens) y resistencia equivalente Rt( ) para cuatro resistores de 4 . 6 Cree sendas funciones para el cálculo de determinantes de grado: 2x2 y 3x3. es decir si es negativo. La falta del + dará mala presentación a la expresión de la línea recta. tangente. Lea por teclado la distancia que esta(estaba) el palenque del objetivo militar. cotangente. obtenga la pendiente m.8 Un avión del ejército deja caer una bomba exactamente encima de un objetivo militar de la "subversión". y la distancia D entre ellos. a continuación conviértalo a radianes y por medio de las funciones trigonométricas incorporadas en la librería <MATH. Calcule el ángulo de elevación con que los sobrevivientes.x1) despejando la expresión anterior obtenemos la ecuación de la recta: y = m x . a este lamentable y no intencionado incidente reportarían que vieron al avión cuando dejo caer la bomba. coseno. Para lo anterior lea por teclado la altura sobre el terreno que en el momento de soltar la bomba.Rt = R1 + R2 + R3 + R4. y resuelva los siguientes ejemplos con el programa diseñado: a) 2 4 d) 3 2 -1 4 8 -4 2 1 b) 1 4 0 1 -1 3 12 e) 3 -2 5 6 c) 1 4 1 3 0 2 f) 3 -4 0 2 3 -2 5 3. 3.. de lo contrario. distancia que inteligencia militar había reportado 52 .y1 y .12.12.5 Digite un ángulo en grados sexagecimales. 1 Gt = ---. sí aparecerá.12.m x1 + y1 Si el término -m x1 + y1 es positivo el signo + no aparecerá en pantalla. y1) y (x2. Rt Vi = I Resistencia equivalente conductancia Ri .y2).x)² + (y2 . midió el piloto en los instrumentos del avión. ½ D = ( (x2 .7 Digite las coordenadas rectangulares de dos puntos (x1. caída de voltaje en cada resistencia 3.y1 = m (x .H> muestre los valores correspondientes a las funciones seno.x1 (x . secante y cosecante. y . la bomba seguirá desplazándose en el sentido (eje X) del movimiento del avión en el momento en que fue soltada.y1 = --------x2 . y caerá (Eje Y) debido a la acción de la fuerza de atracción gravitacional a razón de 9. Como comprenderán ustedes señores Bachilleres.8 m/s². de un palenque cercano donde cayó.y1)² ) = arctg m 3. el ángulo que forma la recta con el eje X.12. la ecuación de la línea recta que los une.x1). y2 . De las respuestas debe tomar solo los valores enteros: Balance para el material 1: Balance para el material 2: Balance para el material 3: 1200 = 3000 = 2 * clase1 + 7 * clase2 + clase3 2 * clase1 + 10 * clase2 + 12 * clase3 5 * clase2 + 13 * clase3 2564 = 16 * clase1 + donde clase1. Se debe borrar a continuación la pantalla y que aparezca lo siguiente: Nombre del cliente.con exactitud al piloto y evitar de esta forma desgracias que lamentar.12. Con estos dos datos y utilizando sus conocimientos de trigonometría. el cual está compuesto de tres materiales diferentes: A. 2 y 3. clase2 y clase3 son las cantidades de cada clase de producto solicitadas. el 16% del IVA y el total neto a cancelar. y de los cuales dispone de 1200Kg. 3. Para esto leer por teclado el nombre de el cliente. 1. y se cumple que la matriz inversa es igual a: A-1 = 1 ----Det A a22 -a21 -a12 a11 -a12 b12 = -----Det A suponga que: A-1 = b11 b21 b12 b22 a11 b22 = -----Det A a11 a21 a12 a22 de donde: b11 a22 = ---Det A b21 -a21 = ---Det A 53 . el precio unitario de venta al público (PVP).11 Sea una matriz A de 2x2: A = entonces: A es invertible ( tiene inversa) sí y solo sí determinante de A diferente a cero. El determinante de A es la multiplicación de la diagonal principal menos la multiplicación de la diagonal secundaria. B y C. 3. Determinar las cantidades óptimas a producir de cada uno de los modelos.9 Un tecnólogo industrial tiene que controlar la producción de tres clases. el descuento que se le efectuará por ser "buen cliente". de un determinado producto.10 En un almacén se va a efectuar una factura. calcule el ángulo pedido.12. total del descuento. 3.12. la cantidad total de artículos a comprar por el cliente. Sugerencia: dibuje un gráfico de lo acontecido. 3000Kg y 2564Kg respectivamente. si cada clase del producto es fabricado según la siguiente tabla: clase 1 2 3 A (kg) 2 7 1 B (kg) 2 10 12 C (kg) 16 5 13 Determine la cantidad a producir de cada uno de las clases de producto resolviendo el siguiente sistema de tres ecuaciones con tres incógnitas. total bruto de la factura. y a continuación muestre en pantalla lo siguiente: sumatoria.12 Leer N números reales por teclado. media o promedio. Calcule cada término b11. b21. si ese fuera el caso (de malas).Lea cada uno de los cuatro términos de la matriz A por teclado. NOTA: La validación de si el determinante de A es cero la dejamos para el siguiente capítulo sobre instrucciones selectivas. Calcule el determinante de A. En la siguiente fórmula Xi es cada uno de los N números a digitar (Xi . La desviación estándar está dada por la raíz cuadrada de la varianza. mientras tanto. 54 . la varianza y la desviación estándar. es decir en filas y columnas. b12. el programa se nos "caerá". b22 y muestre en pantalla adecuadamente. 3.12.Media)² Varianza = -----------------N suponga que N es igual a 4 para efectuar su algoritmo en lenguaje C++. 12.2). cout << "Q = " << q.pow(x. } Efectúe a continuación prueba de ejecución manual del algoritmo del anterior programa IF_MANUA. else Calculos(). cout << "\n\nDigite un número entero: ". Llene el siguiente tabulado.13 Efectúe prueba de ejecución manual al siguiente algoritmo. Muestre exactamente en pantalla. if (q <= p) cout << q << " es menor o igual a " << p. Escriba aquí los cálculos necesarios: r = 25 + p * 2 . q=15. #include <conio.h> #include <iostream. cout << "\nDigite un número entero: ". r = q + p * 2. 55 . r = 25 + p * 2 .2). Considere los dos casos: cuando if es verdadero y cuando es falso.CPP int p.CPP. void Calculos(){ int x. } void main(){ clrscr(). "pantalla" y los cálculos necesarios: Variables en forma tabular p q r x "PANTALLA" cin >> x.pow(x. r = q + p * 2.h> //IF_MANUA.h> #include <math. cin >> p. cout << "\nR = " << r. r.3. cout << "\nP = " << p. . 2 INSTRUCCIÓN Si .CAPÍTULO 4 INSTRUCCIÓN SELECTIVA IF 4. 4.. Efectúe pruebas de ejecución manual a los programas que el profesor no explicó en la clase magistral. hasta que le queden "los ojos cuadrados". a este trabajo debe dedicarle mínimo 10 horas. Dogmáticamente podríamos decir que "llegará a tener fe" en que determinadas instrucciones producen determinados resultados y no otros. 57 .Entonces DIAGRAMA DE FLUJO 4. Poco a poco debe irse independizando de la ejecución en la máquina para estar seguro y "creer" que es los que hace un determinado algoritmo sin ejecutarlo en ella. Ya en ella efectúe las preguntas que considere necesarias al profesor. El Profesor explicará en la clase magistral algunos de los algoritmos de esta lección. ya a estas alturas debe sentir el trabajo en computador como un "chicle". en caso contrario efectúe seria reflexión de sus intereses.1 METODOLOGÍA Estudie el tema presentado en esta lección antes de ir a la correspondiente clase magistral. Después de ejecutarlos efectúeles todas las modificaciones que se le ocurran. Luego diríjase al computador y del disquete anexo cargue los archivos de los programas correspondientes a este capítulo.. en forma personal y luego en Grupo de estudio.1 Instrucción Si-Entonces Viene el algoritmo secuencialmente │ ┌────────┴────────┐ │ Si Expresión │ Falso (0) │ booleana ├───────┐ │ ¿Verdad? │ │ │ o ¿Falso? │ │ └───────┬─────────┘ │ Verdad │ │ (<>0) │ │ ┌───────┴─────────┐ │ │ Entonces(then) │ │ │ Ejecutar │ │ │ instrucciones │ │ └───────┬─────────┘ │ ├─────────────────┘ │ Continúa el algoritmo secuencialmente . recuerde que es "obligatorio" el llevar este módulo a todas las clases. 58 .. Sea la evaluación de la instrucción Si(if) verdadera o falsa.. Pseudocódigo en Español .. . En el lenguaje C la instrucción Entonces(Then) está tácita.... . En caso de que el bloque de código a efectuar. cout << "Digite un número: ". y no se debe colocar. ... 4. if (expresión lógica){ . Si (expresión lógica) Entonces . se le debe indicar específicamente qué información debe utilizar. . la secuencia del algoritmo se salta este bloque de instrucciones..3 El siguiente ejemplo utiliza la instrucción selectiva if. Fin_Si .... si el resultado es falso. Esta evaluación produce uno de dos resultados posibles: cierto (True) o falso (False).. instrucción(es) .1 Sintaxis de la instrucción Si (If) en la forma más simple: Lenguaje C/C++ . .Un programa.. } . . no es necesario utilizar los delimitadores: { }. instrucción(es). Lo primero que hace una instrucción Si(if) es evaluar la información que se le ha proporcionado en forma de expresión booleana. #include <iostream. .. . y se ejecuta basándose en la evaluación lógica de los datos. .. el flujo del algoritmo continuará secuencialmente.. basándose en los datos que reciba.... Sin embargo si se quiere que tome decisiones. . La forma más sencilla de bifurcación condicional es la sentencia Si-Entonces. if (expresión lógica) instrucciónUnica..h> #include <conio.. clrscr().. Este tipo de acción se denomina bifurcación.h> //IF_0. en cualquiera de los dos casos. TABLA 4. de la forma más elemental.. puede elegir entre distintas acciones a seguir.. Si la evaluación es cierta el algoritmo seguirá en el bloque de instrucciones que está inmediatamente después. conste de una sola instrucción. .. . . si es verdadera la evaluación. cómo evaluarla y que acciones seguir. . en caso contrario no lo ejecutará. si es cierta la condición.CPP main(){ int numero. . ..... . la cual hace que un programa ejecute el bloque de código el cual esta a continuación.. En el C/C++ el bloque de instrucciones a continuación estará delimitado por la pareja de corchetes: { } para abrir y cerrar respectivamente.. CPP. Otra corrida Digite un número: _ FIGURA 4. Se da la tecla de ENTRAR Digite un número: 159 Se digitó un número mayor a 100_ FIGURA 4. Entero digitado y ENTRAR Digite un número: 50 _ 59 . Al correr el programa Digite un número: FIGURA 4.2 Pantalla del programa IF_0.3 Pantalla del programa IF_0.cin >> numero.CPP.CPP.CPP.1 Pantalla del programa IF_0.5 Pantalla del programa IF_0. if (numero > 100) cout << "Se digitó un número mayor a 100".4 Pantalla del programa IF_0.CPP. getch(). } FIGURA 4. Se digita un entero Digite un número: 159_ FIGURA 4. if (numero > 100){ numero = numero + 10.CPP. Digite un número: 236 Se digitó un número mayor a 100 y a continuación se incrementa en 10 para dar 246_ En la figura anterior se ve el efecto de correr el programa con un valor que produce la evaluación de la expresión lógica (numero > 100) como verdadera. mostrando de esta forma. al ser digitado por teclado. #include <iostream.CPP main(){ int numero.6 Pantalla del programa IF_00. clrscr().CPP. } FIGURA 4. FIGURA 4. cin >> numero. que es el que finalmente muestra en pantalla. cout << "y a continuación se incrementa en 10 para dar ". El IF al ser falso. Observe que la variable número tomo inicialmente el valor de 93. y luego se incremento en 10 para tomar el valor de 246. 60 . el algoritmo continúa en la instrucción: cout << numero.h> #include <conio.4. cout << "Digite un número: ".4 El siguiente algoritmo utiliza la instrucción selectiva if. El IF es verdadero. Observe que la variable número tomó inicialmente el valor de 236. delimitado con { }.7 Pantalla del programa IF_00. cout << "Se digitó un número mayor a 100 \n". El IF es falso. el mismo valor que se digitó. getch(). con un bloque de código. } cout << numero. Digite un número: 93 93_ En la figura anterior se ve el efecto de correr el programa con un valor que produce la evaluación de la expresión lógica (numero > 100) como falsa. la variable numero.h> //IF_00. al ser digitado por teclado. clrscr(). no es el promedio. if ( (b<a && cout << a if ( (a<b && cout << b if ( (a<c && cout << c } a<c) << " b<c) << " c<b) << " || es || es || es (c<a && a<b) ) el del medio". if (numero > 100). El IF es falso. clrscr(). c.CPP main(){ int numero. cin >> a.8 Pantalla del programa IF_000. el compilador no //IF_000.6 El siguiente algoritmo calcula el número medio entre tres enteros. #include <iostream.9 Pantalla del programa IF_000. cin >> c. (b<c && c<a) ) el del medio".h> #include <conio.h> //IF_01. } FIGURA 4. cout << "Digite entero: ". b. getch().5 El siguiente algoritmo detectará ningún error. (c<b && b<a) ) el del medio".4. Digite un número: 39 Se digitó un número mayor a 100_ 4. ¡Error! Marcador no definido.CPP. cout << "Digite entero: ". #include <iostream. 61 . cout << "Digite entero: ".CPP.h> #include <conio. cout << "Digite un número: ". El IF es verdadero. Digite un número: 214 Se digitó un número mayor a 100_ FIGURA 4. // punto y coma da a entender que el if termina cout << "Se digitó un número mayor a 100". cin >> b.h> presenta un error de lógica. OJO CON ESTE ERROR ¡Error! Marcador no definido.CPP main(){ int a. cin >> numero. Viene el algoritmo │ ┌────────┴────────┐ │ Si Expresión │ Falso (0) │ booleana ├───────────┐ │ ¿Verdad? │ │ │ o ¿Falso? │ │ └───────┬─────────┘ │ Verdad │ │ <>0 │ │ ┌───────┴─────────┐ ┌───────┴─────────┐ │ Entonces (then) │ │ Si_No (else) │ │ Ejecutar │ │ Ejecutar │ │ instrucciones │ │ instrucciones │ └───────┬─────────┘ └───────┬─────────┘ │ │ ├─────────────────────┘ │ │ Continúa el algoritmo secuencialmente Hasta ahora con la instrucción SI solo tenemos una escogencia... 62 .. instrucción(es).... en el caso de verdadero. . ¡Error! Marcador no definido... ...2 Sintaxis general de la instrucción Si (If) es: Lenguaje C/C++ ....SINO TABLA 4.. Fin_Si . If (expresión lógica){ . ... secuencialmente instrucciones Si-Entonces-Si_No. De esta forma y teniendo en cuenta los datos que reciba a evaluar el Si....ENTONCES .. . .. . } Else{ . instrucción(es) ..4. . ahora veremos la forma completa de la misma instrucción.7 INSTRUCCIÓN SI . } . DIAGRAMA DE FLUJO 4. instrucción(es) ..... Si_No .. instrucción(es) . puede elegir entre dos distintas acciones a seguir: una en el caso de que la evaluación lógica sea verdadera (como antes) y otra en el caso de que sea falsa.2 ¡Error! Marcador no definido.. . . Pseudocódigo en Español . ... Si (expresión lógica) Entonces . cuando la evaluación sea falsa. en la siguiente instrucción.De esta forma se efectuará una bifurcación condicional en la sentencia Si(if) de la siguiente forma: si es cierta la condición se ejecuta el bloque de código a continuación. si el bloque de código a efectuar. Sea la evaluación de la instrucción Si(if) verdadera o falsa. Esta evaluación produce uno de dos resultados posibles: cierto (True) o falso (False). deberá estar delimitada por los corchetes: { } para abrir y cerrar respectivamente. ya sea de la parte que evalúe cuando sea verdadero el Si o la parte que evalúe cuando sea falsa. lo primero que hace una instrucción Si(if) es evaluar la información que se le ha proporcionado en forma de expresión booleana. es decir cuando la condición es falsa. En el C/C++ el bloque de instrucciones a continuación. en cualquiera de los dos casos. se ejecutará el bloque de código que está a continuación de la instrucción SINO(else). el flujo del algoritmo continuará secuencialmente. en caso contrario. la secuencia del algoritmo seguirá a continuación del SINO(else). Repitiendo una vez más. 63 . conste de una sola instrucción. si el resultado es falso. Si la evaluación es cierta el algoritmo seguirá en el bloque de instrucciones que está inmediatamente después. no es necesario utilizar los delimitadores: { }. Lo mismo que para el caso de verdadero. #include <iostream.8 El siguiente algoritmo utiliza la instrucción selectiva if en su forma completa y de la forma más elemental.h> //IF_000. ¡Error! Marcador no definido. Caso verdadero. cin >> numero. Digite un número: 65 Se digitó un número menor o igual a 100 64 . Caso de falso ¡Error! Marcador no definido. else cout << "Se digitó un número menor o igual a 100".CPP. cout << "Digite un número: ". } FIGURA 4.4. if (numero > 100) cout << "Se digitó un número mayor a 100".10 Efecto en pantalla del programa IF_000.CPP main(){ int numero.CPP. Digite un número: 154 Se digitó un número mayor a 100 FIGURA 4. es decir sin bloques de código delimitados.11 Efecto en pantalla del programa IF_000. En la figura anterior se ve el efecto de correr el programa con un valor que produce la evaluación de la expresión lógica (numero > 100) como falsa.CPP. Digite un número: 236 Se digitó un número mayor a 100 y a continuación se incrementa en 10 para dar 246_ En la figura anterior se ve el efecto de correr el programa con un valor que produce la evaluación de la expresión lógica (numero > 100) como verdadera. } FIGURA 4. que es el que finalmente muestra en pantalla. ¡Error! Marcador no definido. clrscr(). cout << "Digite un número: ". El IF es verdadero. Digite un número: 93 Se digitó un número menor o igual a 100 y a continuación se decrementa en 10 para dar 83_ mayor a 100 \n". El IF es falso.CPP main(){ int numero. FIGURA 4. decrementa en 10 para dar " .10. El IF al ser falso continúa el algoritmo después de la correspondiente instrucción else y efectuando lo que tiene encerrado entre llaves. Al salir de ellas muestra el valor que tiene numero que es ahora de 83.CPP.12 Pantalla del programa IF_0000. incrementa en 10 para dar " .4. menor o igual a 100 \n". Observe que la variable numero tomó inicialmente el valor de 236 al ser digitado por teclado y luego se incrementó en 10 para tomar el valor de 246.9 El siguiente algoritmo utiliza la instrucción selectiva if en su forma completa y con bloques de código delimitados entre { }. #include <iostream. Observe que la variable numero tomo inicialmente el valor de 93 al ser digitado por teclado.h> //IF_0000.13 Pantalla del programa IF_0000. cout << "y a continuación se } cout << numero. cin >> numero. 65 . ¡Error! Marcador no definido. if (numero > 100){ cout << "Se digitó un número numero = numero + 10. cout << "y a continuación se } else{ cout << "Se digitó un número numero = numero . Explique este error. cin >> numero. cout << "Digite un número: ".4. } 4. cout << "y a continuación se decrementa en 10 para dar " . cout << "y a continuación se incrementa en 10 para dar " . numero = numero . cin >> numero. El compilador no lo dejará ejecutar.h> main(){ int numero. #include <iostream.h> #include <conio. clrscr(). #include <iostream. cout << "Se digitó un número mayor a 100 \n". debido a la falta de delimitadores { }.10. getch(). if (numero > 100) cout << "Se digitó un número mayor a 100 \n".11 Este programa presenta un error de sintaxis en la instrucción else. if (numero > 100) numero = numero + 10. numero = numero + 10.h> //IF0ERROR.CPP main(){ int numero. cout << "y a continuación se incrementa en 10 para dar " << numero.10 Este programa tiene un error de tipo lógico en las llaves { } del if. } 66 . cout << "Digite un número menor o igual a 100: ". Corríjalo. El compilador no dará ningún error. else{ cout << "Se digitó un número menor o igual a 100 \n". } cout << numero. getch(). cout << "Digite entero: ".13 El siguiente programa permite leer desde el teclado dos números y mostrar comentarios que muestren uno de los siguientes mensajes: "los dos son positivos" o "los dos son negativos" o "tienen diferente signo". cout << "Digite real: ". //IF_03. getch(). if ( a > 0 && b > 0) cout << "\nLOS DOS SON POSITIVOS".h> #include <conio.CPP #include <iostream.4. if ( (b<a && a<c) || (c<a && a<b) ) cout << a << " es el del medio". #include <iostream. cin >> b. Segunda versión. cin >> c. else cout << "\nTIENEN DIFERENTE SIGNO". cout << "Digite real: ".h> main(){ float a.12 El siguiente algoritmo calcula el número medio entre tres enteros. cin >> a. clrscr(). getch(). else cout << c << " es el del medio". no es el promedio. c. else if ( (a<b && b<c) || (c<b && b<a) ) cout << b << " es el del medio".h> #include <conio.CPP main(){ int a.h> //IF_02. cin >> b. cin >> a. b. else if (a < 0 && b < 0) cout << "\nLOS DOS SON NEGATIVOS". } 4. cout << "Digite entero: ". cout << "Digite entero: ". clrscr(). } 67 . b. cin >> p1 >> p2 >> p3.h> main(){ int x. 68 . clrscr(). else if (strcmp(p1.CPP #include <iostream.p2)<0) cout << p3 << " " << p1 << " " << p2. cout << "Digite separados por un espacio dos números enteros: ". } 4.15 Dados dos enteros leídos desde teclado. << "No son divisores entre si\a".CPP void main(){ char p1[25]. x == 0) << x << " es divisor de " << y.p3)<0 && strcmp(p3.p1)<0 && strcmp(p1. ¿uno es divisor del otro? //IF_05. clrscr().h> #include <string.4. else cout << p3 << " " << p2 << " " << p1.p2)<0 && strcmp(p2. p3[25].p3)<0 && strcmp(p3.p3)<0) cout << p2 << " " << p1 << " " << p3.p1)<0 && strcmp(p1. else if (strcmp(p2. p2[25]. getch().14 Se digitan tres palabras y a continuación se ordenan alfabéticamente.h> //IF_04. cin >> x >> y.h> #include <conio. else if (strcmp(p2.p2)<0) cout << p1 << " " << p3 << " " << p2.h> #include <conio. y.p3)<0) cout << p1 << " " << p2 << " " << p3. #include <iostream. else if (strcmp(p3. if (strcmp(p1. if (x % y cout else if (y % cout else cout } == 0) << y << " es divisor de " << x. cout << "Digite tres palabras separadas por espacios en blanco: \n".p1)<0) cout << p2 << " " << p3 << " " << p1. 5*x .h> #include <conio.4. clrscr().4.10. cin >> x . y.3.31 si X>4 y X<=10 Y = 3X^2 . getch().31. } 69 . else if (x <= 10) y = pow(x.4 si X<=4 Y = X^3 + 2X .3 si X>10 #include <iostream. cout << "Digite valor de la variable independiente X: ".h> //IF_06. teniendo en cuenta los siguientes intervalos: Y = X^2 . if (x <= 4) y = x*x .10.5X . cout << "\nVariable dependiente Y = " << y.16 Se calcula el valor de Y en función de X.3) + 2*x .h> #include <math. else y = 3*x*x .CPP main(){ float x. PVP = (CostoFijo + CostoVariable) * 1. else CostoVariable = FactorGrande * CostoFijo.2. el cual se determina multiplicando un factor.5. char Tamano. cout << "Digite inicial de tamaño de pizza a comprar: ". de la siguiente forma: pequeña=1. clrscr().0. cout << "Precio de Venta al Público = $ " << PVP. mediana y grande. En ella se determina el precio de venta al público(PVP).CPP main(){ const int CostoFijo = 1000.h> #include <conio. ------------------------------------------------------------------= Costo de cada pizza * 20% utilidad sobre cada pizza ------------------------------------------------------------------= Precio de Venta al Público En el programa se debe leer inicialmente el tamaño de la pizza y a continuación aparece el PVP correspondiente. PVP. Mostrar finalmente el PVP en pantalla de la pizza solicitada. const float FactorGrande = 3. const float FactorPequena = 1.17 Una pizzería vende pizzas de tres tamaños: pequeña.4. } 70 .0 y grande=3. así: + Un costo fijo igual para todos los tamaños + Un costo variable. getch().0. cin >> Tamano. mediana=2. Se supone un costo fijo de $1000 para cada uno de los tamaños y unos factores para el cálculo del costo variable dependiendo del tamaño.0. cout << "Tipos de pizza: Pequeña Mediana Grande\n". if (Tamano == 'P' || Tamano == 'p') CostoVariable = FactorPequena * CostoFijo. else if (Tamano == 'M' || Tamano == 'm') CostoVariable = FactorMediana * CostoFijo. #include <iostream. dependiente del tamaño. const float FactorMediana = 2. float CostoVariable.h> //IF_11. para cada tamaño por su correspondiente costo fijo. obtenido empíricamente.5. cout << "Digite segundos (0-59): ". debiendo aparecer los seis dígitos aún cuando sean ceros. if (a < b && a < c) cout << " Menor es " << a.h> #include <conio. mayor. cout << "Digite valor para a: ". cin >> c. segundo. promedio = (a + b + c) / 3. cout << "Digite minutos (0-59): ". minuto.CPP #include <iostream. } 4.4. cout << "Digite valor para b: ". cin >> hora. 71 . else cout << "Mayor es " << c. cin >> minuto. cin >> segundo.h> main(){ int hora. menor. cout << "Digite hora(1-12): ". clrscr(). if (a > b && a > c) cout << "Mayor es " << a. y a continuación presenta la hora un segundo después. //IF_07. cin >> a.h> #include <conio. else if (b > a && b > c) cout << "Mayor es " << b. cout << "Digite valor para c: ". b. b c: se imprime el mayor. getch().h> main(){ float a. //IF_09. minutos y segundos en un instante de tiempo.19 El siguiente programa permite leer la hora. cin >> b. a. else cout << " Menor es " << c. segundo = segundo + 1. c. else if (b < a && b < c) cout << " Menor es " << b. clrscr().18 Dados tres valores numéricos por teclado. La hora aparecerá en el formato HH:MM:S. promedio. cout << " Promedio de los tres números = " << promedio.CPP #include <iostream. el menor y se calcula su promedio. if (minuto < 10) cout << "0" << minuto << ":". if (hora == 13) hora = 1. segundo minuto hora "PANTALLA" 72 . } } if ( hora < 10) cout << "0" << hora << ":".if (segundo == 60){ segundo = 0. } Efectúe a continuación prueba de ejecución manual del algoritmo del anterior programa IF_09. hora = hora + 1. getch(). else cout << hora << ":".CPP. else cout << minuto << ":". else cout << segundo. if (segundo < 10) cout << "0" << segundo. con los valores correspondientes y coloque simultáneamente en pantalla lo que "cree" aparece en ella: Variables en forma tabular ¡Error! Marcador no definido . if (minuto == 60){ minuto = 0. minuto = minuto + 1. Llene el siguiente tabulado. } else if (Mes == 6){ strcpy(NombreMes. " Julio "). } else if (Mes == 2){ strcpy(NombreMes.h> // strcpy(cadena1. NumeroDias = 30. #include <iostream. } else if (Mes == 5){ strcpy(NombreMes.h> #include <conio. se determina el nombre y el número de días del mes correspondiente. if (Bisiesto == 'S' || Bisiesto == 's') // || operador lógico O NumeroDias = 29.CPP main(){ int Mes.4. " Febrero "). } else if (Mes == 3){ strcpy(NombreMes. NumeroDias = 31. " Marzo "). cout << "¿Es el año bisiesto? (S/N): ".cadena2): asigna cadena2 a cadena1 // strcmp(cadena1. cin >> Mes. " Abril "). digitado desde teclado. NumeroDias = 31. 73 . NumeroDias = 31.cadena2): si cadena1==cadena2 devuelve cero //IF_10. " Junio "). NumeroDias. " Mayo "). } else if (Mes == 7){ strcpy(NombreMes. char NombreMes[10]. NumeroDias = 30. NumeroDias = 31. if (Mes == 1){ strcpy(NombreMes. else NumeroDias = 28.h> #include <string. NumeroDias = 31. y si el año es bisiesto.20 Dado el número de un mes. } else if (Mes == 8){ strcpy(NombreMes. } else if (Mes == 4){ strcpy(NombreMes.12): ". cout << "Digite el número de un mes(1 . clrscr(). " Agosto "). Bisiesto. " Enero "). cin >> Bisiesto. " Error "). NumeroDias = 31. NumeroDias = 31. NumeroDias = 30. if (strcmp(NombreMes.} else if (Mes == 9){ strcpy(NombreMes. NumeroDias = 30. } else if (Mes == 12){ strcpy(NombreMes. " Noviembre "). " Error ") == 0) cout << "Se equivocó al digitar número del 1 al 12\a\a". else cout << NombreMes << "tiene " << NumeroDias << " días". " Octubre "). } else if (Mes == 10){ strcpy(NombreMes. } 74 . " Diciembre "). " Septiembre "). } else strcpy(NombreMes. } else if (Mes == 11){ strcpy(NombreMes. else{ HorasExtras = HoraSemanales . #include <iostream. cout << "Digite el nombre y apellido del empleado: ". cin >> HoraSemanales. clrscr(). cout << "\nDigite el salario básico por hora: ".48. if (HoraSemanales <= 48) SalarioSemanal = BasicoPorHora * HoraSemanales. Al final se muestra el nombre y el salario neto a cancelar al empleado en pantalla.21 Se lee desde teclado el nombre de un empleado. cin >> BasicoPorHora. SalarioSemanal. float BasicoPorHora.h> #include <conio. su salario básico por hora y el número de horas trabajadas durante una semana. HoraSemanales. Se calcula el salario neto.CPP main(){ char NombreEmpleado[23].4. } cout <<"\n" <<NombreEmpleado <<" devengará esta semana $" << SalarioSemanal. teniendo en cuenta si el número de horas trabajadas en la semana es mayor a 48. gets(NombreEmpleado). esas horas de más se consideran como extras y tienen un 35% de recargo. HorasExtras. SalarioSemanal = BasicoPorHora*48 + HorasExtras*BasicoPorHora*1.35.h> #include <stdio.h> //IF_12. cout << "\nDigite el número de horas laboradas en esta semana: ". getch(). } 75 . 000 retención del 5% desde $2'00. cout << "Digite el nombre y apellido del empleado: ". cout << "\nSalario Básico mensual: " << BasicoMensual.000 no hay retención en la fuente mayores a $890. la retención en la fuente y el salario neto.000 y menores o iguales a $2'000. ReteFuente. // 30 días al mes. su salario básico por mes y el número de horas trabajadas durante el mismo. float BasicoMensual. SalarioBruto. 8 horas diarias SalarioBruto = BasicoHora * HorasMensuales.0/100.ReteFuente. Para el calculo de la retención en la fuente se debe tener en cuenta lo siguiente: Para salarios brutos hasta $890. cout << "\nSalario Bruto: " << SalarioBruto.0/100.22 Se desarrolla un algoritmo para leer desde el teclado el nombre de un empleado. Se debe calcular el salario bruto.h> #include <stdio. clrscr().h> main(){ char NombreEmpleado[32]. else if (SalarioBruto <= 200000) ReteFuente = SalarioBruto*5. BasicoHora. SalarioNeto. cout << "\nSalario Neto A cancelar: $ " << SalarioNeto.001 y menores o iguales a $4'000. else ReteFuente = SalarioBruto*12.000 retención del 12% IF_13.CPP*/ #include <iostream. cout << "\nDigite el salario básico Mensual: ". HorasMensuales.00 retención del 8% mayores a $4'000. cin >> HorasMensuales. gets(NombreEmpleado). clrscr().h> #include <conio.4. cout << "\nSalario Básico por hora: " << BasicoHora. else if (SalarioBruto <= 400000) ReteFuente = SalarioBruto*8. BasicoHora = BasicoMensual / 30 / 8. } 76 . cout << "Nombre Empleado: " << NombreEmpleado. SalarioNeto = SalarioBruto . cin >> BasicoMensual. if (SalarioBruto <= 890000) ReteFuente = 0. cout << "\nRetención en la fuente: " << ReteFuente.0/100. cout << "\nDigite el número de horas laboradas en este mes: ". cout << "\nHoras trabajadas en el mes: " << HorasMensuales. cin >> Festivo.4. 77 . el cual labora en una empresa que tiene dos turnos: diurno y nocturno. clrscr().000 el nocturno. #include <iostream.h> #include <stdio. else Jornal = Horas * 1000.14 Pantalla del programa IF_14. cout << "¿Es festivo? (S/N): ". Complétela usted mismo ¡Error! Marcador no definido. Si es festivo la tarifa se incrementará en $500 el turno diurno y en $1. cout << "Turno Diurno o Nocturno (D/N): ". if (Turno == 'D' || Turno == 'd') if (Festivo == 'S' || Festivo == 's') Jornal = Horas * (1000 + 500).000 y la nocturna de $1. cin >> Horas. a destajo.CPP. else if (Festivo == 'S' || Festivo == 's') Jornal = Horas * (1500 + 1000). getch().CPP main(){ char NombreTrabajador[30]. char Turno. cout << "Número de horas laboradas en el día: ".500. cout << "\n\nJornal a cancelar a " << NombreTrabajador << " $" << Jornal.h> //IF_14. else Jornal = Horas * 1500. Horas. a un trabajador. gets(NombreTrabajador). } FIGURA 4. La tarifa por hora diurna es de $1. cin >> Turno. float Jornal. cout << "Digite el nombre y apellido del trabajador: ".23 Se calcula el jornal a pagar.h> #include <conio. Festivo. } 78 . else if ( (Sexo == 'F' || Sexo == 'f') && (Edad> 40) && (EstadoCivil == 'C' || EstadoCivil == 'c') ) cout << Nombre << " es una Mujer Casada mayor de 40 años". char Sexo. edad. if (EstadoCivil == 'C' || EstadoCivil == 'c') cout << " casado". EstadoCivil. } else cout << "\n\aNo cumple ninguna de las condiciones solicitadas". int Edad.4. cin >> EstadoCivil. #include <iostream.h> #include <conio. cout << "Edad: ". si es menor de edad casado y si es un hombre mayor de 60 años y soltero. cout << "Digite el nombre del encuestado: ". Otro): ". cout << "Sexo (M/F): ".h> #include <stdio. sexo y estado civil de una persona y luego se muestra en pantalla si esta persona es mujer mayor de 40 años y casada.CPP main(){ char Nombre[20]. si es un menor de edad. getch(). cin >> Sexo. Soltero.24 Se lee el nombre. clrscr(). gets(Nombre). cout << "Estado Civil (Casado. else if (Edad < 18){ cout << Nombre << " es un menor de edad ". if((Sexo=='M' || Sexo=='m')&&(Edad>60) &&(EstadoCivil=='S' || EstadoCivil=='s')) cout << Nombre << " hombre solterón mayor de 60 años". cin >> Edad.h> //IF_15. #include #include #include #include <iostream. cin >> EstadoCivil. gets(Nombre). 79 . clrscr(). cout << "Edad: ".h> // toupper() pasa a mayúscula //IF_16.CPP main(){ int Edad. cin >> Edad. } FIGURA 4.CPP. Soltero. edad. EstadoCivil = toupper(EstadoCivil). cout << "Sexo (M/F): ".15 Complete prueba de ejecución manual del programa IF_16. char Nombre[25]. getch(). ¡Error! Marcador no definido. Otro): ". sexo y estado civil. Sexo = toupper(Sexo).h> <stdio. else cout << "\n\aNo cumple ninguna de las condiciones solicitadas".h> <conio. EstadoCivil.h> <ctype. cout << "Digite el nombre del encuestado: ". char Sexo.25 Se desarrolla un algoritmo el cual permite leer desde teclado los datos siguientes de una persona: nombre. if ( ( Sexo=='M' && Edad<30 ) || ( Sexo=='F' && Edad<50 ) ) cout << "\n" << Nombre << " Cumple una de las condiciones". cout << "Estado Civil (Casado. se imprime el nombre solo si corresponde a un hombre casado menor de 30 años o a una mujer soltera menor de 50 años.4. cin >> Sexo. Se debe recordar que cuando el término independiente de la ecuación de la línea recta es positivo. el ángulo de inclinación.6 Dado un número entero.26.000 calcular y escribir la cantidad a retener según la siguiente fórmula: Retención = Salario mensual * porcentaje de retención adicionalmente si gana menos o igual a mensaje: "NO EFECTUAR RETENCIÓN EN LA FUENTE". Si la persona gana más de $590.000. Hágalo aparecer con la utilización de la instrucción Si. Si el sistema no tiene solución.26. de cada mes.1Desarrolle un algoritmo el cual lea desde teclado el nombre. 4. salario mensual y porcentaje de retención en la fuente. isósceles o escaleno por medio de la lectura desde teclado de sus ángulos interiores. se le descuenta sobre la factura un 3% y hasta un máximo (de descuento) de $20.26.420. el nombre del artículo y el precio unitario. Si el cliente paga dentro de los diez primeros días. 4. presentarlo en pantalla con formato monetario con separación de miles y precedido por el signo $.5 Simule emitir el total de una factura considerando lo siguiente: leer la cantidad. a cada uno de sus cliente. 4. el total de la factura y el número del día(0-31) en que está cancelando.26. 4.26. para solucionar un sistemas de tres ecuaciones con tres incógnitas. Sugerencia: Descomponga el número como unidades. Leer un real el cual representará el peso de la carta y luego muestre el costo de la carta.26. e imprima el nombre solo si corresponde a un hombre casado mayor de 30 años o a una mujer soltera menor de 50 años. decenas.00.2 Lea un registro desde teclado compuesto de los siguientes tres campos: nombre. valide previamente que la suma sea 180 . edad.7 Rehaga el algoritmo sobre la regla de Cramer.26 ACTIVIDADES PARA REALIZAR EN GRUPO DE ESTUDIO 4. y esto ocurre cuando el determinante del sistema es cero.000 presentar el siguiente El costo de enviar por correo es de $300 para cartas que pesan menos de 30 $5 por cada gramo adicional para cartas que pesan más de 30 grs. y número enviar $890. 4. 4.26.26.8 Rehaga el algoritmo el cual permite leer dos puntos desde el teclado y calcular la pendiente. el + no aparece en pantalla.4. Ejemplo: Entrada 32420 debe producir en pantalla: $32.4 Desarrolle un programa el cual determine si un triángulo es equilátero. y la ecuación de la línea recta. Finalmente agregar el 14% de IVA. 80 . muestre en pantalla: "EL SISTEMA NO TIENE SOLUCIÓN". si es mayor a $300. Si el total bruto da mayor de $150.000 hacer un descuento del 2%. 4. Debe aparecer en pantalla un aviso que diga: "CANCELANDO ANTICIPADAMENTE".000 hacer un 3% de descuento adicional de descuento. efectúa los siguientes pasos: Inicia leyendo por teclado el nombre del cliente. etc. por pronto pago. Suponga hasta un máximo valor para los enteros de 32678. 4.26.9 Una Compañía al recibir el pago de las facturas pendientes. sexo y estado civil de una persona.3 grs. centenas. número de cédula de ciudadanía. Debe aparecer en pantalla un aviso que diga: "CANCELANDO AL DÍA". En este caso debe aparecer un aviso de advertencia en pantalla que diga: "CANCELANDO TARDÍAMENTE".5% y unos gastos administrativos por cobranza a morosos de $5. el descuento o recargos.000.Si paga dentro de los diez días(11-20) siguientes paga el total factura. y el neto a cancelar en efectivo. Se deben efectuar los cálculos necesarios para mostrar en pantalla los resultados pedidos a continuación: el nombre del cliente con su cédula de identidad. de la Si paga dentro de los últimos días(21-31) se le cobra un recargo sobre la factura del 3. valor original de la factura. 81 . . . case vN: instrucción(es). Efectúe pruebas de ejecución manual a los programas que el profesor no explicó en la clase magistral..2 INSTRUCCIÓN SWITCH DEL C/C++ Si se utilizan a menudo tipos simples de datos como de caracter o enteros y adicionalmente hay múltiples condiciones a cumplir.. .1 METODOLOGÍA Estudie el tema presentado en esta lección antes de ir a la correspondiente clase magistral. case v2: instrucción(es)... La instrucción switch proporciona una forma clara de bifurcación múltiple. break. . TABLA 5. Después de ejecutarlos realícele todas las modificaciones que se le ocurran....... default: instrucción(es) } . switch (variable) { case v1: instrucción(es). Ya en ella efectúe las preguntas que considere necesarias al profesor.. a este trabajo debe dedicarle mínimo 5 horas. SegúnSea (variable) hacer valor1: instrucción(es) valor2: instrucción(es) . break.. 83 . . . valorN: instrucción(es) Si_No: instrucción(es) FinSegúnSea . .. . Debe dedicarle a esto unas tres horas. Pseudocódigo en Español .1 Sintaxis general de la instrucción En Caso de (switch): Lenguaje C/C++ . INSTRUCCIÓN SELECTIVA SWITCH 5. Luego diríjase al computador y del disquete anexo cargue los archivos de los programas correspondientes a este capítulo. ¡Error! Marcador no definido. incluyendo lo mínimo necesario para el manejo de cadenas de caracteres.CAPÍTULO 5¡Error! Marcador no definido.. Recuerde que es "obligatorio" el llevar este módulo a todas las clases. se puede utilizar esta instrucción. break. En la parte de taller el profesor le pondrá a efectuar pruebas de ejecución manual a algunos de los algoritmos y le pondrá a realizar otros tomados de la tarea asignada al final de esta lección.. en forma personal y luego en Grupo de estudio. El Profesor explicará en la clase magistral algunos de los algoritmos de esta lección. 5.. efectúe los algoritmos de tarea asignados al final de esta lección. } getch().3 Dado el número de un día de la semana. default: cout << "\aERROR.h> //SWITCH_1. break.5. cin >> Dia. break. break. hacer aparecer el nombre del día correspondiente: #include <iostream. case 5: cout << "El día es VIERNES". } 84 . break. case 3: cout << "El día es MIERCOLES". switch (Dia) { case 1: cout << "Es día es LUNES". clrscr(). break.7): ". cout << "Digite el número de un día de la semana(1 . case 6: cout << "El día es SABADO". case 2: cout << "El día es MARTES". case 4: cout << "El día es JUEVES".CPP void main(){ int Dia. case 7: cout << "El día es DOMINGO". no es un entero válido".h> #include <conio. break. break. se determina el nombre y el número de días del mes correspondiente. case 10:strcpy(NombreMes. y si el año es bisiesto. " Diciembre "). " Octubre "). " Enero "). " Septiembre "). NumeroDias. NumeroDias = 30. " Noviembre "). break. cout << "Digite el número de un mes(1 . case 2: strcpy(NombreMes. case 3: strcpy(NombreMes. " Julio "). NumeroDias = 31. default: strcpy(NombreMes. " Marzo "). break. case 9: strcpy(NombreMes. case 7: strcpy(NombreMes. break. " Abril "). case 5: strcpy(NombreMes. NumeroDias = 31.CPP #include <iostream. case 6: strcpy(NombreMes. cin >> Mes. // || operador lógico O 85 . " Febrero "). break. NumeroDias = 31.h> #include <conio. NumeroDias = 30.h> // strcpy(cadena1. else NumeroDias = 28. break. digitado desde teclado. break. case 4: strcpy(NombreMes. char Bisiesto. break. //SWITCH_4. break. clrscr(). NumeroDias = 31. " Error "). NumeroDias = 30.5.12): ".h> #include <string. cin >> Bisiesto. cout << "¿Es el año bisiesto? (S/N): ". " Mayo "). NumeroDias = 31. if (Bisiesto == 'S' || Bisiesto == 's') NumeroDias = 29. NumeroDias = 31. NumeroDias = 31. break. NumeroDias = 30.4 Dado el número de un mes. " Agosto "). case 12:strcpy(NombreMes.cadena2): si cadena1==cadena2 devuelve cero main(){ int Mes. " Junio "). break. case 11:strcpy(NombreMes. switch (Mes) { case 1: strcpy(NombreMes.cadena2): asigna cadena2 a cadena1 //strcmp(cadena1. case 8: strcpy(NombreMes. char NombreMes[10]. } 86 . " Error ") == 0) cout << "Se equivocó al digitar número del 1 al 12\a\a". else cout << NombreMes << "tiene " << NumeroDias << " días".} if (strcmp(NombreMes. centena. .5. 10. 10.CPP #include <iostream. clrscr(). 100. resto. numero = centena*100 + (decena+1)*10. .5 Se lee un número entero entre 1 y 999. break. cin >> numero.h> #include <conio. numero = centena*100 + decena*10. . decena. } (unidad) 0: 1: 2: 3: 4: 5: 6: 7: 8: 9: . centena = numero resto = numero % decena = resto / unidad = resto % switch { case case case case case case case case case case } cout << numero. //SWITCH_2. . getch(). . cout << "Digite un número entero para redondearlo:\n". 87 . . / 100. y a continuación se redondea a la decena más próxima.h> void main(){ int numero. unidad. . cout << "\t\t\tESTE ES EL MENU PRINCIPAL". // se invoca.h> #include <conio.\n". Función 2. Le servirá como plantilla para diseñar sus programas. Se efectúa invocación recursiva de la función main(). getch(). break..5. cout << "Función 3". break.. getch().. } void funcion2(){ clrscr(). cout << "\n\t\t\tB. switch ( opcion ) { case 'A': case 'a': funcion1().. cout << "Función 2"... case 'B': case 'b': funcion2().. //SWITCH_5. la función main(). Función 3. break. } if ( ! (opcion=='S' || opcion=='s') ) main(). Función 1.. case 'C': case 'c': funcion3().CPP #include <iostream. cout << "\n\n\n\t\t\tA. a sí misma (recursión) } 88 .h> void funcion1(){ clrscr().. Salir\n". cout << "\n\n\t\tDigite una opción: ". opcion = getch(). cout << "\n\t\t\tC. } void funcion3(){ clrscr().\n".6 El siguiente programa presenta un menú en pantalla. clrscr()... } void main(){ char opcion.\n". cout << "\n\t\t\tS.. cout << "Función 1". getch(). break. strcpy(und. unidades = resto % 10. ""). centenas. switch { case case case case case case case case case case case } switch { case case case case case case case case case case } switch { case case case case case case case (centenas) 0: strcpy(cent. strcpy(dec. break. "CC"). strcpy(dec. decenas = resto /10. strcpy(dec. break. ""). strcpy(dec.h> #include <string. "L"). "DCCC"). "I").break. break. 7: strcpy(cent. "CD").h>//strcat(cadena1. "X"). "M"). cout << "Digite número (1 . 1: strcpy(cent. "XX"). "LX"). break. 3: strcpy(cent. strcpy(und. "II"). strcpy(dec. strcpy(dec. "DC"). "CM"). cadena2) agrega la cadena2 a la cadena1 main(){ int numero. strcpy(dec. "XXX"). break. resto = numero % 100.CPP #include <iostream. resto. break. strcpy(dec. //SWITCH_3. break. cent[5]. "LXXX"). strcpy(und. decenas. ""). 10:strcpy(cent. strcpy(und. 89 .h> #include <conio. break. 4: strcpy(cent. break. break. cin >> numero. 5: strcpy(cent.7 Se digita un número menor o igual a 1000 y a continuación se muestra su representación en números romanos. "LXX"). "CCC"). break. "XL"). 6: strcpy(cent. dec[5]. unidades. "V"). break. "III"). "IV"). break. centenas = numero / 100. break. clrscr(). break. 2: strcpy(cent. (decenas) 0: 1: 2: 3: 4: 5: 6: 7: 8: 9: strcpy(dec. break. "D"). break. "C"). char und[5]. 9: strcpy(cent. "XC"). break. "VI"). strcpy(und. strcpy(dec. break. break. "DCC").break. break. break. 8: strcpy(cent.5. break. break. strcpy(und. break. (unidades) 0: 1: 2: 3: 4: 5: 6: strcpy(und.1000): ". case 8: strcpy(und. 5. case 9: strcpy(und. "VII").3 Recodifique al menos 5 de los algoritmos vistos en el curso anterior de pseudocódigo en español.8.1 Leer un número desde teclado inferior o igual a mil. La próxima semana es el primer parcial. break. 90 . a continuación muestre en pantalla la misma cantidad pero en palabras.8 ACTIVIDADES PARA REALIZAR EN GRUPO DE ESTUDIO 5. break. por falta de tiempo. "IX").8. "VIII"). 5.2 Estudie todos los algoritmos que no ha estudiado. } 5. } cout << cent << dec << und.case 7: strcpy(und.8. y efectúe las actividades no resueltas aún.break. . permitiendo ejecutar reiteradamente iteraciones (ciclos.. booleana){ . La instrucción Mientras(while) soluciona este problema... Instrucción(es). 91 ... Pseudocódigo en Español . booleana> hacer . Hasta el momento la única forma de hacerlo sería o copiándolas varias veces. Mientras <Exp..... Efectúe pruebas de ejecución manual a los programas que el profesor no explicó en la clase magistral.1 METODOLOGÍA Estudie el tema presentado en esta lección antes de ir a la correspondiente clase magistral. Después de ejecutarlos efectúeles todas las modificaciones que se le ocurran.CAPÍTULO 6¡Error! Marcador no definido. en forma personal y luego en Grupo de estudio. o copiarlas dentro de una función e invocarla repetidamente..2INSTRUCCIÓN WHILE DEL C/C++ La mayoría de programas requieren que una determinada cantidad de instrucciones se ejecuten más de una vez. efectúe los algoritmos de tarea asignados al final de esta lección. En la parte de taller el profesor le pondrá a efectuar pruebas de ejecución manual a algunos de los algoritmos y le pondrá a realizar otros tomados de la tarea asignada al final de esta lección.. mientras sea verdadera la expresión booleana que lo está controlando.. ejecutando las instrucciones que contiene. las instrucciones.. INSTRUCCIÓN REPETITIVA WHILE 6. Fin_Mientras . .... Debe dedicarle a esto unas tres horas.. El ciclo que produce la instrucción Mientras (while) se efectuará. 6. Instrucción(es) . Luego diríjase al computador y del disquete anexo cargue los archivos de los programas correspondientes a este capítulo.1 Sintaxis general de la instrucción Mientras(while) ¡Error! Marcador no definido. Ya en ella efectúe las preguntas que considere necesarias al profesor. lazos... El Profesor explicará en esta algunos de los algoritmos de esta lección.. bucles. De esta forma será posible "devolvernos" en la secuencia lógica del algoritmo. while (Exp. recuerde que es "obligatorio" el llevar este módulo a todas las clases.. Lenguaje C/C++ . a este trabajo debe dedicarle mínimo 5 horas. rizos). } .... Tabla 6. sino que seguiría secuencialmente el programa. 92 . la condición que controla el ciclo se vuelve falsa. y cualquier otro valor numérico como verdadero.DIAGRAMA DE FLUJO 6. La instrucción while es una palabra reservada del lenguaje C/C++. Instrucción Mientras (while) ¡Error! Marcador no definido. esta llegare a ser falsa. La expresión al ser evaluada. y secuencialmente irá ejecutando el código hasta encontrar el terminador }. lo cual no es lo más recomendado según los teóricos de la programación estructurada. un valor numérico de 0 es considerado como falso. aquí la expresión es evaluada de nuevo. o con alguna otra instrucción que lo obligará a salir. nuevamente. la ejecución lógica del algoritmo continuará secuencialmente después de la instrucción que marca el fin del ámbito de la instrucción. debido a esto decimos que la instrucción while se sale por arriba. Si al evaluarse la primera vez la condición de control. viene el algoritmo secuencialmente │ │ ┌────────┴────────┐ │ Expresión │ Falso ┌────>┤ booleana ├─────>┐ │ │ ¿Cierto/Falso? │ │ │ └────────┬────────┘ │ │ │ Cierto │ │ │ │ │ ┌─────────┴────────┐ │ │ │ Ejecutar │ │ └<───┤ instrucciones │ │ │ │ │ └──────────────────┘ │ │ ┌<──────────────┘ │ continúa el algoritmo secuencialmente La expresión booleana que controla el ciclo debe producir un resultado de verdadero o de falso. en este momento el flujo del algoritmo de "devuelve" trasladándose "arriba" a la instrucción while.1. en este momento el flujo del programa se traslada después de la llave de cerrar } y el algoritmo seguirá secuencialmente. no se ejecutarían las instrucciones contenidas en el ámbito del while. si es verdadera decimos que entra la secuencia del algoritmo dentro del ámbito de la instrucción while. y así sucesivamente hasta que en un momento y dados los cambios ocasionados dentro del ámbito del while. la cual debe ir seguida de una expresión lógica o relacional encerrada entre paréntesis. Cuando la instrucción mientras (while) evalúe la expresión booleana que controla el ciclo como falsa. si es verdadera entra la secuencia otra vez al ámbito de la instrucción. o sea el Fin_Mientras en el Pseudocódigo en Español o la llave de cerrar } del C/C++. Debe estar bien claro que la expresión lógica la cual controla el ciclo while es evaluada en la parte superior y si es evaluada como falsa se "sale por arriba" buscando la llave terminal } y de allí seguir secuenciálmente. Si la instrucción de control no toma nunca el valor de falso se producirá un ciclo infinito. y habría que interrumpir el programa con la secuencia de teclas Ctrl+Break. en C/C++. while (numero < 10){ numero = numero + 1. al ejecutarlo se verá así: ¡Error! Marcador no definido. suma = suma + numero. clrscr(). suma = suma + x.Sumatoria del a al 10 = 55_ 6. suma = 0. cout << x << " ".3 Se presenta la serie de los números pares entre 2 y 10 //WHILE_.h> #include <conio.CPP #include <iostream. suma = 0. } cout << "Sumatoria del 1 al 10 = " << suma. while (x < 10 ) { x = x + 2.h> void main(){ int x = 0. } En forma tabular las variables del algoritmo anterior tomarán los siguientes valores: ─────────┬──────┬──────────────── numero │ suma │ numero<10 ─────────┼──────┼──────────────── 0 │ 0 │ 0<10 Verdad 1 │ 1 │ 1<10 Verdad 2 │ 3 │ 2<10 Verdad 3 │ 6 │ 3<10 Verdad 4 │ 10 │ 4<10 Verdad 5 │ 15 │ 5<10 Verdad 6 │ 21 │ 6<10 Verdad 7 │ 28 │ 7<10 Verdad 8 │ 36 │ 8<10 Verdad 9 │ 45 │ 9<10 Verdad 10 │ 55 │ 10<10 Falso ──────────┴──────┴───────────────── En pantalla. } cout << "\n\nLA SUMA DE LOS NUMEROS PARES ES: " << suma. } 93 .A continuación se presenta un algoritmo para sumar los 10 primeros números: main (){ int numero = 0. cout << "DIGITE N:".h> #include <conio.CPP #include <iostream. cout << "\n". suma=0.h> const int Verdad=1. float termino. cout << "Digite el valor de N: ". float suma=0. while( i<n ){ i = i + 1..CPP 94 .i. clrscr(). while ( i < n ){ i = i + 1. termino = i * (i+1) * (i+2).h> main(){ int i=0. if (i % 2 == 0){ cout << i << " ". //WHILE_2. suma = suma . suma = suma + i. } 6.CPP #include <iostream.h> main(){ int i=0. n. } } cout << "\n\nSumatoria = " << suma. n. cin >> n. } Se muestra en pantalla la siguiente serie: #include <iostream. } S = .1 + 2 ..h> #include <conio. } cout << "\nSumatoria = " << suma.6. main(){ while (Verdad) cout << " Digite las teclas de CONTROL + BREAK para terminar \n". //WHILE_3. suma = suma + termino. } else { cout << -i << " ". cout << i << " * " << i+1 << " * " << i+2 << " = " << termino << endl.5 Se presenta un ciclo infinito. clrscr(). cin >> n. Digite Ctrl+break para terminar.4 Se presenta algoritmo para el cálculo de la sumatoria de los n primeros términos de la siguiente serie: 1*2*3 + 2*3*4 + 3*4*5 + 4*5*6 //WHILE_1.3 + 4 -5 . 6. cin >> n.+ ---.+ ---. } cout << "\n\n LA SUMA ES: " << suma.h> <conio. //WHILE_4. i=0. while (i < N){ i = i + 1.+ ---. clrscr(). termino. int i = 0..6 Se despliega en pantalla y calcula sumatoria de la siguiente serie: S = -2 +4 -6 +8 -10 +12 -14 .CPP #include #include #include #include <math. while ( i < n ){ i = i + 1. cout << setw(5) << termino . suma=0.CPP #include <iostream.+ .. } cout << "\n\nSumatoria = " << suma. termino.h> #include <conio.h> main(){ int n. } 95 . clrscr().h> <iomanip. suma = suma + termino.h> <iostream. suma = suma + termino.h> main(){ float suma = 0.h> #include <iomanip. 2). termino = 1 / pow(2*i-1.. if (i % 2 == 0) termino = 2 * i. cout << "Digite la cantidad de términos en la serie: ".. getch(). N = 50. + ---1² 3² 5² 7² 9² N! //WHILE_5. cout << setw(10) << termino. } 6. getch().7 Se suman los N primeros términos de la siguiente serie: 1 1 1 1 1 1 ---. potencia. else termino = 2 * (-i)..+ ---. X = X + 2. ModoGrafico. cout << "Digite número del 0 al 16 para el color: ". Fondo. cout << "Digite valor Xo del centro de los círculos: ". Yo. radio). cout << "Digite valor Yo del centro de los círculos: ". } 6. cin >> Fondo. cin >> Yo. //WHILE_6. int ManejadorGrafico = DETECT. while (radio <= 200){ radio = radio + 10. Y=200. Radio). cin >> Color.9 Ejemplo de movimiento de un círculo en la pantalla. circle(X. Radio). //WHILE_7. ". cin >> Color. ModoGrafico. while (X <= getmaxx() ){ setcolor(Color).\\" ).\\" ).h> main(){ int radio=0.8 Ejemplo de graficar círculos concéntricos.. X=0. &ModoGrafico." <<getmaxy() << ")\n". } closegraph(). ".h> #include <iostream. Yo.h> main(){ unsigned int Radio=40. } getch(). circle(X.h> #include <conio. closegraph(). cout << "Máximas coordenadas en esta pantalla (" << getmaxx() << ".h> #include <iostream. setcolor(Color). Y. int ManejadorGrafico = DETECT..CPP #include <graphics. circle(Xo. initgraph( &ManejadorGrafico. &ModoGrafico. setbkcolor(Fondo). Xo. cout << "Digite número del 0 al 16 para el color del círculo: ". Y. cin >> Xo. initgraph( &ManejadorGrafico. cout << "Digite número del 0 al 7 para el color del fondo: ". Color. Color. setcolor(Fondo).6. } 96 .CPP #include <graphics. y analizando más casos. } cout << "\n\n e elevado a la " << x << " = " << eX. termino.6. emplea en concepto de recurrencia: 2 3 N X X X 1 + --.h> main(){ float x. eX. --3! 4 así mismo: = debido a esto.+ --. + --2! 3! N! 2 X X --.h> #include <conio.CPP #include <iostream. } 97 . getch().le falta --2! 3 4 X --4! 3 X para obtener --3! e = observe que. int i=0. //WHILE7. se tendrá que multiplicar el termino anterior por X/i.+ .10 El siguiente algoritmo. termino = termino * x / i. cout << "Digite valor de X: ". cin >> x. donde i es el número de la iteración respectiva o lo que es lo mismo el número de término. while ( termino > 0E-04){ //10 elevado a la -4 en notación científica i++... por ejemplo. eX = termino = 1. se desprende que para cada nueva iteración que se efectúe para calcular cada nuevo término. para el cálculo del valor del número e a través de una serie. al término 3 X X --. eX = eX + termino.. Suponga que cada alumno tiene un número diferente de calificaciones. pero de tal suerte que aparezca al final el siguiente mensaje: "¿Desea continuar (Si/No)?.5 Determinar la suma y promedio de una positivos.12.12. Escribir al final el promedio de el curso. 6. y así sucesivamente hasta que digite "N" para terminar.12.1 Efectúe prueba de ejecución manual a todos los algoritmos del presente capítulo.12. 6.6.12. 6. E programa debe detenerse y permitir digitar "S" o "N". terminados con un número negativo.11 ACTIVIDADES PARA REALIZAR PERSONALMENTE Y EN GRUPO DE ESTUDIO 6. Diseñe tabulados adecuados para cada uno de los programas. Muestre para cada alumno su nota definitiva.4 Calcule la nota promedio de un salón de clase y la nota mayor con el nombre del alumno.2 Rehaga algunos de los ejercicios de la Segunda Parte. Muestre lo que aparece en pantalla. en caso afirmativo el programa debe pedirle nuevamente datos.3 Se desea leer todas las calificaciones de una clase de Algoritmos y contar el número total de aprobados y reprobados. 6. lista indefinida de números 98 . cout << "Digite frecuencia inicial en herz: ". F = F + Deltaf. cin >> Ff. Ya en ella efectúe las preguntas que considere necesarias al profesor. 7.h> #include <dos.1 METODOLOGÍA Estudie el tema presentado en esta lección antes de ir a la correspondiente clase magistral. tiempo. cout << "Digite milisegundos para que cada frecuencia suene: ". cout << "\n" << F. //WHILE_8. delay(tiempo). En la parte de taller el profesor le pondrá a efectuar algunos algoritmos a partir de los ejercicios asignados al final del presente capítulo y le pondrá de tarea el resto de ellos para su casa. El Profesor explicará en esta algunos de los algoritmos de esta lección. Debe dedicarle al estudio al menos unas seis horas. cin >> F. } 99 . recuerde que es "obligatorio" el llevar este módulo a todas las clases. } nosound(). en forma personal y luego en Grupo de estudio. cin >> Deltaf. cout << "Digite frecuencia final en herz: ".h> main(){ unsigned int F. Después de ejecutarlos efectúeles todas las modificaciones que se le ocurran. Efectúe pruebas de ejecución manual a los programas que el profesor no explicó en la clase magistral.h> #include <conio. cout << "Digite incremento de la frecuencia:".2 En el siguiente programa se hace sonar el parlante del computador a varias frecuencia. según valores digitados desde teclado. a este trabajo debe dedicarle mínimo 5 horas.CPP #include <iostream. cin >> tiempo. while (F <= Ff ){ sound(F). Ff.. clrscr(). INSTRUCCIÓN WHILE(Continuación) 7. Luego diríjase al computador y del disquete anexo cargue los archivos de los programas correspondientes a este capítulo. Deltaf.CAPÍTULO 7¡Error! Marcador no definido. main(){ int n=2. // se generan solo números impares EsPrimo = Verdad.7. EsPrimo. cout << " cout << " n = 1. //WHILE8.h> const int Verdad=1. " << n . getch(). else divisor = divisor + 2. divisor = 3.25). const int Falso=0.CPP #include #include #include #include <iostream.h> <math. return 0. NUMEROS PRIMOS ENTRE 2 Y 2000 \n\n". divisor. cout << "Digite cualquier tecla para terminar". clrscr().h> <conio. }//while gotoxy(1.h> <iomanip.3 Se imprimen en pantalla los números primos entre 2 y 2000. }//while if (EsPrimo) cout << setw(5) << n. while ( ( divisor <= sqrt(n) ) && EsPrimo ){ if (n % divisor == 0) EsPrimo = Falso. } 100 . //El 2 es el único primo par while (n < 2000){ n = n + 2. cout <<"\n\nAdiviné el " <<NumeroAlAzar <<" en " <<intentos << " intentos". cout << "\tn = ". clrscr(). Adicionalmente para cada número generado se genera esa misma frecuencia por el altoparlante. i++. cin >> N. Factorial=1. clrscr(). if (i <= N){ Factorial = Factorial * i. SumatoriaSerie = SumatoriaSerie + 1. //genera una semilla para números aleatorios while (NumeroAlAzar != N){ intentos = intentos + 1.h> #include <conio. cout << "Digite un número entero entre 1 y " << Max << ": ".4 Se generan números al azar hasta "adivinar" el número digitado por teclado. void main(){ int N. } 101 . } } cout << "\n\t\tSumatoria Serie = " << SumatoriaSerie.5 Obtenga la sumatoria de los N primeros términos de la siguiente serie: 1 1 1 1 1 + ---.h> #include <iostream. SumatoriaSerie = SumatoriaSerie + i.+ 5 + ---. randomize(). Factorial = Factorial * i.. } 7.+ . NumeroAlAzar=0.+ 3 + ---. //WHILE9. float SumatoriaSerie=0.h> #include <stdlib.h> #include <dos.7.h> void main(){ int N. } nosound().h> const int Max=1000. intentos=0. cout << NumeroAlAzar << " ".0 / Factorial.CPP #include <conio. 2! 4! 6! 8! //WHILE13. sound(NumeroAlAzar).+ 7 + ---. cin >> N. NumeroAlAzar = random(Max+1).CPP #include <iostream.. i=0.. while (i < N){ i++. //WHILE_9.7. } cout << "\n\n\tM. aux. clrscr(). n.n. while ((numero % 2) == 0 ){ cout << 2 << endl. clrscr(). } while (impar <= (sqrt(numero)+1) ){ while (numero % impar == 0 ){ cout << impar << endl. = " << m. cout << "Digite un Número para calcularle sus factores primos: ". cout << "Digite n: ".h> main(){ int m. n = aux.h> #include <conio. } if ( numero > 1 ) cout << numero. diferencia.6 Descomposición de un número en sus factores primos. numero = numero / impar.C. } 7.CPP #include <iostream. } 102 . while (m != n){ if (m < n){ aux = m.CPP #include <iostream.h> #include <conio. n = diferencia. cin >> numero. cin >> n. impar=3.h> #include <math. cin >> m. } impar = impar + 2.h> main(){ int numero. m = n. numero = numero / 2.D. cout << "\n". } diferencia = m . cout << "Digite m: ". m = n.7 ALGORITMO DE EUCLIDES PARA EL MAXIMO COMÚN DIVISOR entre dos números m y n //WHILE10. cout << setw(8) << t << setw(14) << i << setw(14) << i*i << endl. } cout << "\n──────────────────────────────────────────-".05. cout << setw(8) << t << setw(14) << i << setw(14) << i*i << endl.h> <conio. getch(). } 103 .005 segundos desde t=0 hasta t=T. cout << "\n\n tiempo i(t) i²(t)". i = 10 * exp(-t/T) * sin(2 * Pi * t/T).8 La corriente en un circuito eléctrico está dada por: i(t) = i(t) = -t/T 10 e Seno( 2 t/T ) 0 para 0 <= t <= T/2 para T/2 < t <= T calcúlese i(t) e i²(t) para intervalos de t de 0.7. Amperios */ intensidad corriente al cuadrado */ clrscr(). i2. cout << "\n──────────────────────────────────────────-\n".h> <iomanip.h> <math. #include #include #include #include <iostream.14159. i=0. main(){ float t=0. T = 1.CPP const float Pi=3.h> Suponga que T=1 segundo //WHILE11. intervalo = 0. tiempo de un ciclo */ corriente instantánea. while( t <= T/2 ){ t = t + intervalo. /* /* /* /* tiempo en segundos */ periodo. Digite cualquier tecla". //WHILE14. getch(). i = 1.h> #include <conio. clrscr(). i. } 104 . } if (suma == numero) cout << "\n\t\t" << numero. suma. while (numero <= 2000){ suma = 0. cout << "Espere un momento!\n\n".7. while ( i <= (numero / 2) ){ if (numero % i == 0) suma = suma + i. el 36 no lo es. Ejemplos: -----------------------------------------numero: 6 28 36 -----------------------------------------divisores---> 1 1 1 2 2 2 3 4 3 7 4 14 6 9 12 18 -----------------------------------------sumatoria: 6 28 55 -----------------------------------------De lo anterior el 6 y el 28 son números perfectos. i = i + 1. } cout << "\n\n\nHasta el 2000 estos son solamente.h> main(){ int numero=1.9 Un número es perfecto si la suma de sus divisores excepto él mismo es igual al propio número. numero = numero + 1.CPP #include <iostream. digito. cin >> base_origen. decimal = digito * potencia.h> main(){ int numero. clrscr(). decimal). potencia = potencia * base_origen. cociente = cociente / 10. clrscr(). cociente = numero / 10. decimal = decimal + potencia * digito. cout << "\nDigite número en base del 2 al 9(cero para terminar): ". base_origen.se hacen divisiones entre 10 hasta obtener un cociente de cero //WHILE15.h> #include <conio. } } 105 . nota: no hace validaciones de si el número es de esa base o no Ejemplo: convertir el número 1110 en base 2 a base 10 0 1 2 3 1110 => en decimal: 0*2 + 1*2 + 1*2 + 1*2 = 0 + 2 + 4 + 8 = 14 para esto se debe descomponer el número en sus dígitos dividiendo sucesivamente entre 10. así: 1110 │ 10 0 ├──── │ 111 │ 10 1 ├──── │ 11 │ 10 1 ├──── │ 1 │ 10 ├──── │ 0 <--.7. cociente. y obtener una respuesta en base diez. digito = numero % 10. decimal. cin >> numero.CPP #include <iostream. cin >> numero. desde el 2 al 9.10 Leer un número en cualquier base. potencia = 1. potencia. while (cociente > 0){ digito = cociente % 10. while ( numero > 0 ){ cout << "base del número digitado: ". getch(). } cout <<("en base 10 = %d\n". cout << "\nDigite número en base del 2 al 9(cero para terminar): ". 7.5 Aceptar como entrada una serie de N valores enteros.. 7.7 Se efectuó una encuesta de población.. 7. El número 9 será incluido como la calificación centinela y se usa para verificar el fin de la introducción de los datos. TRABAJA.. construya un algoritmo para calcular la calificación definitiva. Tabule desde un tiempo de 0 segundos con intervalo de 1 segundo hasta un tiempo de 15 segundos.+ ---2! 3! X + . 7. La información para un número 106 . peso máximo 90 Kg. el correspondiente desplazamiento e.7. Adicionalmente se deberá mostrar la calificación mayor y la menor.5t3 donde e es la distancia en metros y t es le tiempo en segundos... 7.11.11.11. minutos y segundos.+ ---. EDAD.11.11.3! 5! X2 X3 ---..1 Suponga se tiene un conjunto de calificaciones.11. Elabore un algoritmo en el cual se lea el nombre. del 0 al 5. * Ln(1+X) = X - + . C) El mayor y el menor de la serie. NACIONALIDAD.2 Una partícula se mueve en una recta de acuerdo a la siguiente expresión: e = 130 + 100t ..2! 3! X7 ---7! X4 ---4! + .11 ACTIVIDADES PARA REALIZAR EN GRUPO DE ESTUDIO 7. TIENE CASA PROPIA?.. estatura y el peso del deportista.80 m. en la cual a cada persona se le pidió la siguiente información: SEXO.3 Se leen desde teclado dos tiempos diferentes en horas.20t2 + 2. la velocidad(primera derivada) y la aceleración(segunda derivada). Lea varios pares de valores. Como condición de terminación de lectura de datos debe colocar en pantalla: ¿Desea continuar(s/n)?. por consiguiente no deberá intervenir en los cálculos.11.. de un estudiante. NUMERO DE HIJOS.6 Coldeportes está interesada en promover el basquetball y para ello desea encontrar personas con las siguientes características: edad menor a 18. verifique si cumple las condiciones impuestas. ESTADO CIVIL. Calcular e imprimir: A)¿Cuántos son pares y múltiplos de 13. Al final diga cuántos cumplieron las condiciones. ¿Calcule la diferencia entre estos dos tiempos?. estatura mínima 1. 7.4 Calcule el valor de las siguientes series efectuándolas con recurrencia y sin ella: * X2 X3 e = 1 + X + ---. + XN ---N! a) para N dado desde teclado b) hasta que N sea tal que XN ----N! menor a 10-4 * Seno(X) = X - X3 X5 ---. B) ¿Cuántos son divisibles por siete?.+ ---. la edad. total matricula.8 + 9 + 10 + 11 .7 + 8 + ..17 + 19 + . valor por materia.9 + 10 + 11 + 12 + .Porcentaje de mujeres solteras. 107 . Tome como población el total de mujeres en la muestra. .. nombre y apellido..12 + . 10 + 12 .14 + . y escriba todos los números primos encontrados. número de materias a matricular.Porcentaje de colombianos que tienen casa propia . es decir se obtiene un número compuesto. nombre y apellido. calcule: .8 Se tiene un registros con los datos de los estudiantes de una universidad así: código del estudiante. Se requiere leer los registros de todos los estudiantes(suponga un código de 0 como condición de terminación) e imprimir un listado con la siguiente información por estudiante: código. 9 .1 + 2 = 1 + 2 + = 1 ... Tome como población el número de hombres con edad en el mismo intervalo.. 7.2 + 4 = 1 + 3 3 3 3 6 5 + + + + 4 4 4 8 7 + + 5 + 6 . Elabore un algoritmo que a través de la utilización de funciones. número de materias. + 100 5 + 6 + 7 .11. para cada caso..Invente otras dos preguntas que se adapten a la muestra encuestada.Porcentaje de hombres que trabajan entre 19 y 25 años.Los porcentajes de mujeres que trabajan sobre el total de mujeres en la muestra y sobre el total de la población..11 + 13 + 15 .9 Calcular el valor de las siguientes series: S S S S S = . 7. al final se debe mostrar el total a recibir por matrículas y el número total de estudiantes matriculados..Número de menores de edad extranjeros . determine para qué valor de N la ecuación falla. Con la fórmula N²-N+41 se obtienen gran cantidad de números primos.indeterminado de encuestados debe ser introducida por teclado. valor del recargo por matrícula... valor por materia. . valor del recargo. .11.2 + = . 5 + 6 + 7 + 8 . CAPÍTULO 8¡Error! Marcador no definido.. PASO POR VALOR Y RETORNO EN FUNCIONES 8.1 METODOLOGÍA Estudie el tema presentado en esta lección, sobre el paso de parámetros por valor y el retorno de valores de las mismas, antes de ir a la correspondiente clase magistral. El Profesor explicará la mecánica del paso de parámetros por valor en en cualquier lenguaje en general y en el C++ en particular. A la clase magistral algunos de los algoritmos de esta lección, recuerde que es "obligatorio" el llevar este módulo a todas las clases. En la parte de taller el profesor le pondrá a efectuar pruebas de ejecución manual a algunos de los algoritmos y le pondrá a realizar otros tomados de la tarea asignada al final de esta lección. Luego diríjase al laboratorio de computadores y del disquete anexo cargue los archivos de los programas correspondientes a esta lección. Después de ejecutarlos efectúeles todas las modificaciones que se le ocurran, a este trabajo debe dedicarle mínimo 5 horas. Efectúe pruebas de ejecución manual a los programas que el profesor no explicó en la clase magistral; efectúe los algoritmos de tarea asignados al final de esta lección. 8.2 PASO DE PARÁMETROS POR VALOR EN FUNCIONES. Las funciones pueden ser utilizadas para pasar parámetros al ser invocadas; este paso de parámetros es de dos formas: paso de parámetros por valor y paso de parámetros por referencia. En el caso de parámetros por valor: el valor de la variable que se esté pasando, es asignado a la variable local que es declarada al definir la función. Tanto la variable que se utilice al efectuar la invocación como la que la recibe "por valor" deben ser del mismo tipo, en caso contrario se presentará un error de tipo. 8.3 El siguiente ejemplo, SONIDO1.CPP, debe copiarlo en el computador y ejecutarlo para poder seguir adecuadamente las explicaciones(no copie los números de la izquierda): 0: 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: #include <dos.h> NOTA(int Herz){ sound(Herz); delay(1000); } main(){ int frecuencia=260; NOTA(frecuencia); frecuencia=440; NOTA(frecuencia); nosound(); } //SONIDO1.CPP 109 Al ejecutar el programa anterior, iniciando por la función main(), se define la variable frecuencia en la línea 8 y simultáneamente se inicializa con el valor de 260; En la línea 10 se efectúa invocación de la función NOTA() y se pasa el parámetro frecuencia el cual tiene almacenado el valor de 260. El flujo del programa se traslada a la línea 2 en la cual está definida la función NOTA(), aquí el valor que la variable frecuencia a pasado "por valor" es asignado a la variable local Herz() la cual tomará el valor de 260; la variable Herz solo es definida después de la invocación de la función NOTA(). Continuará, el programa secuencialmente en la instrucción de la línea 3, en la cual la función sound() hará sonar el altoparlante del computador en el valor que tenga almacenado Herz, es decir 260. Continúa inmediatamente en la línea 4, donde la función delay detendrá al computador por 1000 milisegundos, después de esto, en la línea 4, termina la función NOTA() y de esta forma se retorna a la instrucción siguiente a la que efectúo la invocación, en este caso la instrucción de la línea 12. Es de señalar que cuando la función NOTA() termina, la variable local frecuencia es desasignada de la memoria, vale decir "no existirá ya". En la línea 12 se asigna a la variable local a la función main() frecuencia el valor de 440. A continuación en la línea 13 se efectúa una nueva invocación de la función NOTA(), pasando el valor que tiene frecuencia a la variable local Herz, línea 2, la cual es asignada a la memoria nuevamente y recibe el valor de 440. Debido a la línea 3 sonará el altoparlante ahora a esta nueva frecuencia, almacenada en la variable local Herz, y debido a la instrucción delay() de la línea 4 por espacio de 1000 milisegundos; terminando la función NOTA() en la línea 5. Se retorna a la instrucción de la línea 14: nosound() la cual hará que deje de sonar el altoparlante del computador, terminando el programa en la línea 15. Es de mucha importancia tener en cuenta que las variables locales solo tienen ámbito dentro de su correspondiente función. Se les asigna un lugar en memoria cuando son definidas dentro de la función, cuando la correspondiente función termina y se retorna a donde fue invocada, todas las variables locales "desaparecerán". En el programa anterior si dentro de la función NOTA() utilizáramos el identificador frecuencia nos daría un error de identificador desconocido, ya que este es local a la función main(). Y viceversa, si dentro de la función main() utilizáramos el identificador Herz nos daría un error de identificador desconocido, ya que este es local a la función NOTA(). Simule estos dos últimos errores y todo los que se le ocurra en este momento en el computador. 110 8.4 El siguiente programa permite oír sonidos en Herzios. Mediante funciones: sound() y nosound(), incorporadas en la unidad <dos.h>. Este programa no corre en las versiones de C++ para Windows. #include <iostream.h> #include <conio.h> #include <dos.h> //SONIDO3.CPP Sonido(int f, int ms){ sound(f); delay(ms); nosound(); } main(){ int Frecuencia, Segundos; clrscr(); cout << "Digite una frecuencia en Herz(ciclo/segundo): "; cin >> Frecuencia; cout << "Segundos que desea suene: "; cin >> Segundos; Sonido(Frecuencia, Segundos*1000); Sonido(Frecuencia*2, Segundos*1000); } 111 efectuará la invocación de la función Fahrenheit. cout << "\nson " << F << " Fahrenheit". } void main(){ float centigrados. y dar la tecla de <ENTRAR>. presentando el siguiente aspecto: ¡Error! Marcador no definido. #include <iostream.CPP float Fahrenheit(float grados){ float F. cout << "Digite temperatura en grados centígrados: ". la cual es invocada por valor y devuelve a su vez otro.Digite temperatura en grados centígrados: 100 son 212 Fahrenheit_ 112 .5 El siguiente algoritmo utiliza una función.8. esta retornará un resultado. F = 9. se detendrá inicialmente debido al efecto de la instrucción de lectura: cin >> centígrados. un número. // se invoca a continuación función Fahrenheit(): Fahrenheit(centigrados). } En el anterior algoritmo al ejecutarlo. clrscr(). se detendrá nuevamente en la instrucción getch(). getch(). el algoritmo continuará secuencialmente. Específicamente efectúa una conversión de unidades termométricas.Digite temperatura en grados centígrados: _ Al digitar una temperatura.h> #include <conio. el cual será escrito en pantalla.0 / 5 * grados + 32. presentando el siguiente aspecto en pantalla: ¡Error! Marcador no definido.h> //FUNCION3. cin >> centigrados. cout << "Sol ". Mi(ms). Si(ms). La(ms). delay(Tempo).h>. } Fa(int Tempo){ sound(342). cout << "La ". ms/=2. delay(Tempo). Re(ms). DO(ms). Fa(ms). La(ms). cin >> ms.h> #include <dos. getch(). cout << "Do ". cout << "Milisegundos que desea suene cada nota: ". } 113 .h> //SONIDO2.6 El siguiente programa permite oír notas musicales entre 260 Hz y 520 Hz. Do(ms). delay(Tempo). Sol(ms). Sol(ms). delay(Tempo). delay(Tempo). cout << "Do ". Mi(ms). Do(ms). delay(Tempo). cout << "Fa ". delay(Tempo). Si(ms). DO(ms). Fa(ms). nosound(). } main(){ int ms. delay(Tempo). mediante funciones: sound() y nosound(). } Sol(int Tempo){ sound(390). Re(ms). #include <iostream.8. cout << "\nSilencio\n".h> #include <conio. cout << "Mi ". } DO(int Tempo){ sound(520). cout << "Re ". } Re(int Tempo){ sound(290). } Mi(int Tempo){ sound(322). } La(int Tempo){ sound(440). Silencio(ms). } Silencio(int Tempo){ nosound(). delay(Tempo). cout << "Si ". // milisegundos clrscr(). } Si(int Tempo){ sound(494).CPP Do(int Tempo){ sound(260). incorporadas en la unidad <dos. } 8. Una función puede tener más de una instrucción de retorno(return).8. //RETURN_1. empero por la primera que pase la secuencia de ejecución del programa.h> float Fahrenheit(float grados){ float F. El profesor el siguiente ejemplo: 8. //RETURN_2 #include <iostream. cout << "Digite entero: ". return (F). clrscr(). a donde fue invocada && a<c) || (c<a && a<b) ) a. cout << "Digite entero: ".8 El siguiente algoritmo calcula el número medio entre tres enteros. && c<b) || (b<c && c<a) ) c.0 / 5 * grados + 32. la función terminará retornando el valor correspondiente. b. no es el promedio. int c){ int Medio. 114 . Comparar con el programa FUNCION3.h> #include <conio.CPP. cin >> a. Ver el programa IF_01. int b. con la palabra reservada return podemos hacer que la secuencia de ejecución de la función se interrumpa y devuelve o retorne "al sitio" en el que fue invocada un valor.7 RETORNO DE VALORES EN FUNCIONES Hasta ahora todas las funciones que hemos utilizado no han devuelto nada(void). cin >> c. b. cout << "Digite entero: ". //la función retorna el valor de F.CPP #include <iostream. c) << " es el del medio". && b<c) || (c<b && b<a) ) b. cout << CalculaMedio(a.h> #include <conio.CPP como comparación. empero. return Medio. la cual es invocada por valor y devuelve a su vez otro.9 El siguiente algoritmo utiliza una función. F = 9. c.h> CalculaMedio(int a. cin >> b. if ( (b<a Medio = if ( (a<b Medio = if ( (a<c Medio = } main(){ int a. Específicamente efectúa una conversión de unidades termométricas. cin >> b. if ( valor1 > 0 && valor2 > 0) strcpy(mensaje. "\nLOS DOS SON NEGATIVOS"). "\nTIENEN DIFERENTE SIGNO"). //se invoca función cout << "\nson " << Fahrenheit(centigrados) << " Fahrenheit". } void main(){ float a.CPP.h> #include <conio. RETURN_3.CPP #include <iostream. } 8. b. int valor2){ char *mensaje. getch(). else if (valor1 < 0 && valor2 < 0) strcpy(mensaje. clrscr(). Comparar con el programa IF_03. "\nLOS DOS SON POSITIVOS"). return mensaje.10 El siguiente programa permite leer desde el teclado dos números y a continuación desplegar en pantalla comentarios con uno de los siguientes mensajes: "los dos son positivos" o "los dos son negativos" o "tienen diferente signo". cin >> a. cout << "Digite real: ". getch().//Observe que es otra forma de manejar cadenas de caracteres //la cual utilizaremos en próximos cursos. cout << "Digite real: ". else strcpy(mensaje. b).h> char *CompararValores(int valor1. cout << "Digite temperatura en grados centígrados: ". cout << CompararValores(a.h> #include <string.} void main(){ float centigrados. clrscr(). cin >> centigrados. } 115 . cin >> b.9*pow(x. b. cout << "Digite valor inicial intervalo (b): ".CPP #include <iostream. penultimo = 0.11 Encontrar raíces de función entre intervalos dados por error y ensayo: Evaluar la función: y = x^3 .5. Observe hasta que N se puede ejecutar este programa. clrscr().15).CPP #include <iostream.h> #include <math.1 y b = 7 con incrementos de x de 0. //WHILE12.h> #include <iomanip.9x^2 + 23x . DeltaX. while (X <= b) { Y = F(X).3) . X = a. cout << "───────────────────────────" << endl. cout << "Digite valor inicial intervalo (a): ". case 2: return (1). } 8. Las tres raíces se obtienen donde la y = 0. else cout << endl. Cambie la línea donde esta evaluada la función con otras expresiones y corra el programa repetidamente con nuevos intervalos e incrementos y determine las raíces en cada caso. default: 116 . Y. sin que cometa error. X = X + DeltaX.h> #include <conio.8.h> float F(float x){ return (pow(x. cin >> a.h> int Fibonacci (int N){ // Calcula el enésimo término de la serie de Fibonacci int ultimo = 1. } cout << "───────────────────────────". cout << "───────────────────────────" << endl. cout << "Digite incremento de X: ".h> #include <conio.15 entre el intervalo a = . //Invoca función F() cout << setw(12) << X << setw(12) << Y. } main(){ float a. X.12 Obtener el enésimo término de la serie de Fibonacci y decir si es primo. if (Y == 0) cout << " Raíz exacta" << endl. i=2.2) + 23*x . Fib. cin >> DeltaX. cout << " X Y " << endl. switch (N){ case 1: return (0). //WHILE16. } } 117 . cin >> N.while ( i < N ) { i++. penultimo = ultimo. } return (Fib). cin >> N. if (numero == 2) //Si es 2 devuelve 1. while (numero % impar != 0) //Prueba si da división exacta entre impares impar = impar + 2. if (numero == impar) //Si impar es igual a numero es primo return (1). } } EsPrimo (int numero){ int impar = 3. //El número evaluado no es primo } FibonacciEsPrimo (int N){ int F. else return (0). } main(){ int N. Fib = penultimo + ultimo. El 2 es el único par primo return(1). //Calcula el enésimo término de la serie de fibonacci if ( EsPrimo (F) ) cout << "Fibonacci = " << F << " es primo\n". clrscr(). No es primo return (0). ultimo = Fib. cout << "Digite un N(0 para terminar): ". F = Fibonacci (N). else cout << "Fibonacci = " << F << " no primo\n". while (N > 0){ FibonacciEsPrimo (N). cout << "Digite un N(0 para terminar): ". cout << "Calcula enésimo término serie Fibonacci y se dice si es primo\n\n". if (numero % 2 == 0) // Si es par devuelve 0(falso). . CAPÍTULO 9¡Error! Marcador no definido.. INSTRUCCIÓN REPETITIVA DESDE 9.1 METODOLOGÍA Estudie el tema presentado en esta lección antes de ir a la correspondiente clase magistral. El Profesor explicará en la clase magistral algunos de los algoritmos de esta lección, recuerde que es "obligatorio" el llevar este módulo a todas las clases. En la parte de taller el profesor le pondrá a efectuar pruebas de ejecución manual a algunos de los algoritmos y le pondrá a realizar otros tomados de la tarea asignada al final de esta lección. Luego diríjase al laboratorio de computadores y del disquete anexo cargue los archivos de los programas correspondientes a esta lección. Después de ejecutarlos efectúeles todas las modificaciones que se le ocurran, a este trabajo debe dedicarle mínimo 5 horas. Efectúe pruebas de ejecución manual a los programas que el profesor no explicó en la clase magistral; efectúe los algoritmos de tarea asignados al final de esta lección. 9.2 INSTRUCCIÓN DESDE O PARA La estructura repetitiva Desde(FOR) permite que las instrucciones las cuales contiene en su ámbito, se ejecuten un número de veces determinado. DIAGRAMA DE FLUJO 10.1 Instrucción repetitiva Para(FOR) ¡Error! Marcador no definido. viene secuencialmente el algoritmo │ ┌─────────────┴───────────────┐ │ contador = ValorInicial │ └─────────────┬───────────────┘ ┌──────────────────┤ │ ┌─────────────┴───────────────┐ falso │ │ ¿contador <= ValorFinal? ├──┐ │ └─────────────┬───────────────┘ │ │ │ cierto │ │ ┌─────────┴──────────┐ │ │ │ Ejecutar │ │ │ │ instrucciones │ │ │ └─────────┬──────────┘ │ │ ┌────────────────┴───────────────┐ │ │ │contador = contador + incremento│ │ │ │(esto lo hace "automáticamente")│ │ │ └────────────────┬───────────────┘ │ └──────────────────┘ │ ┌──────────────────┘ sigue secuencialmente el algoritmo ... ... Una variable de control, que llamamos contador, se incrementa o decrementa desde un valor inicial hasta un valor final, dado por el incremento o decremento correspondiente. 119 TABLA 9.1 Sintaxis general de la instrucción FOR del C/C++ ¡Error! Marcador no definido. for(Contador=ValorInicial; Contador<=ValorFinal; contador=contador+incremento){ ...; Instrucción(es); ...; } Nota: La anterior solo es la forma general del FOR, tenida en cuenta por la mayoría de lenguajes de programación. El C/C++ permite otras características que lo hacen muy flexible, potente y extraño para los dogmáticos. 9.3 Efectúe prueba de ejecución manual del siguiente algoritmo. //FOR_01.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> main(){ int N, i; float suma = 0; clrscr(); cout << "Introducir un número entero: "; cin >> N; for( i = 1; i <= N; i++){ cout << setw(5) << i; suma = suma + i; } cout << "\n\nla suma del 1 al " << N << " es " << suma; getch(); } Efectúe prueba manual al siguiente algoritmo, el cual cuenta de dos en dos, desde el 0 al 400 //FOR_02.CPP #include <oistream.h> #include <conio.h> main(){ int x, y; clrscr(); for(x=0, y=0 ; x + y <= 400; x++, y++) cout << "\t" << x + y; getch(); } 120 9.4 Cuenta del 1 al 50 varias veces, con variantes de la instrucción FOR. //FOR_7.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> main(){ int i=1; clrscr(); for( ; i<=50; i++) cout << setw(5) << i; cout << "\n\n"; for(i=1; i<=50; i++) cout << setw(5) << i; cout << "\n\n"; i = 0; for( ; i<50; ) { i++; cout << setw(5) << i; } cout << "\n\n"; for(i=1 ; i<=50; ) { cout << setw(5) << i; i++; } cout << "\n\n"; i = 0; for( ; ; ) { i ++; if (i > 50) break; else cout << setw(5) << i; } getch(); } 121 9.5 Se calcula la siguiente serie: S = 1 + 2 + 3 - 4 + 5 + 6 + 7 - 8 +... //FOR_3.CPP #include <iostream.h> #include <conio.h> main(){ int n, suma=0, i=1; clrscr(); cout << "DIGITE UN VALOR PARA N:"; cin >> n; gotoxy(1,4); for ( ; i <= n ; i++){ if ( i % 4 == 0 ){ cout << "\t" << -i; suma = suma - i; } else { suma = suma + i; cout << "\t " << i; } } cout << "\n\nSumatoria = " << suma; getch(); } 9.6 Efectúe prueba de ejecución manual del siguiente algoritmo. //FOR_4.CPP #include <iostream.h> #include <conio.h> main(){ int i, j, termino=0; clrscr(); for( i = 1; i <= 6; i++ ) { for( j = i; j <= 6; j++ ) { termino = termino + i; cout << termino << "\t"; } cout << "\n"; } } 122 cout << coeficiente << " ".h> #include <conio.7 Expansión binomial: n n-i i (a+b)_ = ( n! / (i! (n-i)!)) a b i=0 El siguiente algoritmo muestra en pantalla los coeficientes de la expansión binomial para un N dado por teclado: //FOR_5.h> float factorial(int numero){ int i. } main(){ int n.CPP #include <iostream. i++) f = f * i. for(i=1. return f. float f=1. } getch(). } 123 . cout<<"Digite exponente(n) para calcular coeficientes del binomial (a+b)_: ". i++) { coeficiente = factorial(n) / (factorial(i)*factorial(n-i)). cout <<"\n". i<=numero. for(i=0. coeficiente. i<=n. i. a. clrscr(). b. cin >> n. return 0.9. 9.8 Expansión binomial y triángulo de Pascal. n n-i i (a+b)_ = ( n! / (i! (n-i)!)) a b i=0 El siguiente algoritmo muestra en pantalla los coeficientes de la expansión binomial para un N dado por teclado. Por ejemplo para N=10: 1 1 1 1 1 1 5 1 6 4 10 3 6 10 2 3 4 5 1 1 1 1 1 1 1 15 20 15 6 1 1 7 21 35 35 21 7 1 1 8 28 56 70 56 28 8 1 9 36 84 126 126 84 36 9 1 10 45 120 210 252 210 120 45 10 1 //FOR5.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> float factorial(int numero){ int i; float f=1; for(i=1; i<=numero; i++) f = f * i; return f; } main(){ int n, i, a, b, coeficiente, espacio; clrscr(); for(n=0; n<=10; n++){ for(espacio=1; espacio <=40-2*n; espacio++) cout << " "; for(i=0; i<=n; i++) { coeficiente = factorial(n) / (factorial(i)*factorial(n-i)); cout << setw(5) << coeficiente ; } cout << endl; } getch(); return 0; } 124 9.9 El siguiente algoritmo presenta las equivalencias de centígrados y fahrenheit entre un valor inicial y uno final. #include <iostream.h> #include <conio.h> float Centigrado_A_Fahrenheit(float Centigrados){ float Fahrenheit; Fahrenheit = 32 + 9 * Centigrados / 5; return Fahrenheit; } main(){ float C, Co, Cf, Delta, F; temperatura entre //FOR_6.CPP clrscr(); cout << "Digite temperatura inicial en centígrados: "; cin >> Co; cout << "Digite temperatura final en centígrados: "; cin >> Cf; cout << "Digite intervalo de temperatura en centígrados: "; cin >> Delta; cout << "\nCENTIGRADOS FAHRENHEIT\n"; cout << " --------------------------"; for(C = Co; C <= Cf; C = C + Delta) { F = Centigrado_A_Fahrenheit(C); cout << "\n\t" << C << "\t" << F; } cout << "\n--------------------------"; } 9.10 Se presentan en pantalla las dimensiones de diversos tipos de papel de la serie A de la norma DIN: #include <iostream.h> #include <iomanip.h> #include <conio.h> //FOR_12.CPP void main(){ int ancho= 841, largo=1188, serie, aux; clrscr(); cout << "------------------------------------------- \n"; cout << " FORMATOS DE PAPEL DIN CLASE A \n"; cout << "------------------------------------------- \n"; cout << "SERIE ANCHO(mm) LARGO(mm) \n"; cout << "------------------------------------------ \n"; for (serie=0; serie<=8; serie++){ cout << serie << setw(15) << ancho << setw(15) << largo << endl; aux = ancho; ancho = largo / 2; largo = aux; } } 125 9.11 Efectúe prueba Escriba enunciado. #include <iostream.h> #include <conio.h> de ejecución manual al siguiente algoritmo. ¿Qué hace? //FOR_08.CPP total( int x ){ int suma = 0, i, contador; for( i = 0; i <= x; i=i+1) { suma = suma + i; for(contador = 0 ; contador < 10; contador++) cout << "."; cout << "la suma del 0 al " << i << " es " << suma << "\n"; } } main(){ int t; clrscr(); cout << "Digitar un número: "; cin >> t; total(t); getch(); } 9.12 El siguiente algoritmo genera un "cuadrado de números". //FOR_9.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> main(){ int N, i, j; clrscr(); cout << "Digite un número entero entre 1 y 20: "; cin >> N; for (i=1; i<=N; i++){ for (j=1; j<=N; j++){ cout << setw(3) << j; } cout << endl; } getch(); } 126 9.13 Se genera un "cuadrado de números". Efectúe prueba manual de ejecución. //FOR10.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> const int N=5; main(){ int f, c, MayorFila = N; clrscr(); for (f=1; f<=N; f++){ for (c=f; c<=MayorFila; c++) cout << setw(10) << c; cout << endl; MayorFila++; } getch(); } 9.14 Se generan combinaciones desde la variable "inicial" hasta la variable "final" tomados de a tres. Ensaye con las siguientes parejas: 1 y 3, 4 y 6, 1 y 9 como valores inicial y final respectivamente. //FOR11.CPP #include <iostream.h> #include <conio.h> main(){ int i, j, k, inicial, final, combinaciones=0; clrscr(); cout << "Digite valor inicial: "; cin >> inicial; cout << "Digite valor final: "; cin >> final; cout << endl; for (i=inicial; i<=final-2; i++) for (j=i+1; j<=final-1; j++) for (k=j+1; k<=final; k++){ combinaciones++; cout << i << "\t" << j << "\t" << k << endl; } cout << "\nTotal de combinaciones: " << combinaciones; getch(); } 127 12). for(longitud = (80.h> void main(){ char cadena[20]. gets(cadena). else if (N > 2) if (N % 2 == 0) EsPrimo = falso.h> <iostream.CPP #include #include #include #include <string.h> <conio. else for(impar = 3. cout << cadena.longitud >0. longitud--) cout << " ". impar <= sqrt(N) && EsPrimo. else cout << " No es primo". impar. cout << "Digite un entero: ". gotoxy(1. cout << "Digite frase para luego centrarla en pantalla: \n".16 Se digita un número entero y se determina si es primo.9. clrscr().h> #include <math.CPP #include <iostream. impar = impar + 2 ) if (N % impar == 0 ) EsPrimo = falso. cin >> N.h> <stdio. const int falso=0. clrscr(). EsPrimo=verdad.strlen(cadena)) / 2. if (N < 2) EsPrimo = falso.h> const int verdad=1.15 Se digita una frase y luego se centra en la pantalla. } 9. clrscr(). //FOR13. int longitud. //FOR_11. main(){ int N. } 128 .h> #include <conio. if (EsPrimo) cout << " Es primo". + .+ ---. main(){ int i. cout << "----------------------------------------------.h> const int N=20. cout << "-----------------------------------------------\n". Y se compara con la función Sin() incorporada en la librería math.14159. mejor la precisión const float Pi=3. i++){ termino = . } cout << angulo. cout << " CALCULO DE FUNCIÓN TRIGONOMETRÍA SENO\n". i<=N. ---7! 9! 11! N! el ángulo X está en radianes.---.---. angulo.. float termino. //Son los términos en la serie. termino = X. for (i=2.+ ---. Entre más.9. senX.h DIFERENCIA\n". angulo = angulo + 10){ X = angulo * Pi / 180. cout <<setw(15)<<senX<<setw(15) <<sin(X) <<setw(15) <<senX-sin(X)<<endl. angulo<=180. } 129 .termino * pow(X. clrscr().CPP #include <iostream. senX = senX + termino.. cout << "-----------------------------------------------\n".2)/((2*i-1)*(2*i-2)).. X.\n".h //FOR12..h> #include <conio.h> #include <math. senX = termino. for (angulo=0. cout << "ANGULO SERIE math.17 Se encuentra el valor aproximado de la función trigonométrica Seno con la siguiente serie: 3 5 X X Seno( X ) = X . } getch().3! 5! 7 9 11 N X X X X ---.h> #include <iomanip. M ESES-> AÑO 1994 1995 1996 1997 1998 1 empresa tiene para los últimos años el siguiente cuadro de 2 3 4 5 6 7 8 9 10 11 12 234 4 532 1 567 345 3 635 3 454 3 655 543 654 4 653 3 567 56 234 345 5 764 3 454 5 754 5 665 123 4 864 3 434 454 5 976 753 3 875 5 345 2 454 4 345 4 345 4 913 4 454 2 123 4 554 754 4 956 6 123 3 186 6 545 3 744 3 966 5 454 5 665 4 453 2 343 2 965 4 5454 234 3322 6543 1045 4 5453 434 5332 3466 9544 2321 678 2345 6543 9555 Calcular: 130 ..2 La infinita: función 1 1 2 3 se 5 8 13 21 34 55 89 . calcular y escribir el cuadrado de los N primeros números naturales.1.18 ACTIVIDADES PARA EFECTUAR EN GRUPO DE ESTUDIO 9. dada por: 0 9.+ .18.1Calcular el enésimo término de la serie de Fibonacci...0 con incrementos de 0.18.0 y 1. 9.. la suma de la serie EXP(x) puede calcular mediante x2 x3 xn e = 1 + x + ---. 9. Calcule dicho valor tomando solamente los 10 primeros términos de la serie. + ---2! 3! n! x 9.9.18.+ ---.4 Si se suman los números impares se obtienen los cuadrados así: 1 1 + 3 1 + 3 + 5 1 + 3 + 5 + 7 = = = = 1 4 9 16 = = = = 12 22 32 42 empleando esta curiosidad matemática.3 se desea calcular el valor EXP(x) para x entre 0.6 Una producción: ¡Erro r! Marca dor no defin ido.18.18. 131 . de N objetos tomados M cada vez. 2) El mes de mayor producción de 1993.5 El número de combinaciones.1) El promedio de producción de cada uno de los años.M)! calcule el número de combinaciones. 3) El año de menos producción. Elaborar dos algoritmos por separado de la siguiente forma: 1) Defina una función para el cálculo del factorial. está dado por: N! C = ------------M! (N . para N objetos de M en M cada vez. C. C. 9.18. 2) Elabore algoritmo con una expresión recurrente. . Cuando la instrucción mientras (while) evalúe la expresión booleana que controla el ciclo como falsa. efectúe los algoritmos de tarea asignados al final de esta lección. en C/C++.. booleana). Hacer . recuerde que es "obligatorio" el llevar este módulo a todas las clases. Instrucción(es) . y cualquier otro valor numérico como verdadero.1 METODOLOGÍA Estudie el tema presentado en esta lección antes de ir a la correspondiente clase magistral... Pseudocódigo en Español .. Luego diríjase al computador y del disquete anexo cargue los archivos de los programas correspondientes a este capítulo... a este trabajo debe dedicarle mínimo 5 horas.1 Sintaxis general de la instrucción Hacer. . En la parte de taller el profesor le pondrá a efectuar pruebas de ejecución manual a algunos de los algoritmos y le pondrá a realizar otros tomados de la tarea asignada al final de esta lección... do{ . Mientras <Exp. Ya en ella efectúe las preguntas que considere necesarias al profesor. en forma personal y luego en Grupo de estudio... Después de ejecutarlos efectúeles todas las modificaciones que se le ocurran... El ciclo que produce la instrucción Mientras (while) se efectuará. Instrucción(es).. INSTRUCCIÓN REPRTITIVA DO.... Efectúe pruebas de ejecución manual a los programas que el profesor no explicó en la clase magistral.. La expresión booleana que controla el ciclo debe producir un resultado de verdadero o de falso.WHILE Tabla 10. booleana> . un valor numérico de 0 es considerado como falso.. ejecutando las instrucciones que contiene..2 INSTRUCCIÓN DO. 133 .... . la ejecución lógica del algoritmo continuará secuencialmente en la siguiente instrucción. Lenguaje C/C++ .WHILE 10... 10.... mientras sea verdadera la expresión booleana que lo está controlando.. El Profesor explicará en la clase magistral algunos de los algoritmos de esta lección. }while (Exp.Mientras ¡Error! Marcador no definido.. Debe dedicarle a esto unas tres horas..CAPÍTULO 10. suma = 0. el usuario diría que es el mismo programa. en lecciones anteriores. . cout << "Sumatoria del 1 al 10 = " << suma..DIAGRAMA DE FLUJO 1O.. se dice que es transparente el cambio para él. solo para el programador sería evidentemente diferente. A continuación se presenta un algoritmo para sumar los 10 primeros números: main (){ int numero = 0.1. 134 . viene el algoritmo secuencialmente │ ┌─────────┴────────┐ │ Ejecutar │ │ instrucciones ├<─────┐ │ │ │ └─────────┬────────┘ │ │ │ ┌────────┴────────┐ │ │ Expresión │ │ │ booleana ├────>─┘ │ ¿Cierto/Falso? │Verdadera └────────┬────────┘ │Falso │ continúa el algoritmo secuencialmente . do{ numero = numero + 1. Instrucción Hacer.Mientras (do....while) ¡Error! Marcador no definido.. }while (numero < 10). suma = suma + numero.. } El resultado es idéntico al presentado con la intrucción while.. Verifique los códigos producidos con las tablas presentadas en el apéndice. m = n.h> main(){ int c.10. aux. } 10.CPP 135 . do { if (m < n) { aux = m.d = " << m << "\n". } //TECLADO. } while (m != n). y para secuencias de ESC ó códigos extendidos. n. m = n. if(c==0){ cout << c << " ". cout << c << "\n".h> #include <conio.n. cout << "Digite ESC para terminar el programa\n" do{ c=getch().c.3 Algoritmo de Euclides sobre el máximo común divisor. cout << "Digite m: ".h> void main(){ int m. cin >> m. c=getch(). n = resto.CPP #include <iostream. cout << "\nEl m. n = aux. cin >> n. ya que le será de gran utilidad en el trabajo de sus proyectos de software. cout << "Digite n: ". //DO_1. para códigos ASCII. Tengalo muy pendiente. clrscr(). resto. } resto = m . clrscr(). } else cout << c << "\n".4 El siguiente programa permite mostrar los códigos de las teclas y secuencias de teclas del teclado. } while(c!=27). #include <iostream.h> #include <conio. switch (opcion) { case 'A' : funcion1().. } void funcion3(void){ clrscr().h> <conio..h> <ctype. opcion = toupper(getch()). //DO_3.5 Plantilla del diseño de un menú con invocación de funciones. } void funcion2(void){ clrscr(). break. delay(1000). .10. cout << "Función 3".. delay(1000). do{ clrscr(). cout << "\n\t\tS.h> <dos. cout << "\n\t\tB..CPP #include #include #include #include <iostream. } void main(){ char opcion.. break. delay(1000). cout << "\n\t\tA.\n". . break. case 'C' : funcion3(). } } while (!terminar).\n".. } 136 ...\n". cout << "Función 2".. cout << "\n\t\tC. Salir\n".. int terminar=0. . cout << "Función 1".h> void funcion1(void){ clrscr(). case 'S' : terminar = 1.. case 'B' : funcion2().. case 'G':cout << "Sol ". clrscr(). case 'K':cout << "Do ". if(kbhit() || tiempo>2000){ if (tiempo>2000) nosound().6 El siguiente programa convierte las teclas ASDFGHJK en teclas musicales. break. cout << "DIGITE EN EL TECLADO LAS LETRAS A S D F G H J K". switch ( nota ){ case 'A':cout << "Do ". break.h> #include <ctype.10. case 'S':cout << "Re ". cout << "\n en cualquier orden. do{ tiempo++. sound(440).h> #include <dos. case 'J':cout << "Si ". break. break. break. sound(260).h> #include <conio. cout << "\npara terminar digite cualquier otra tecla\n".h> main(){ char nota='A'. //DO_5. sound(322). break. sound(390). tiempo=0. nota = toupper(getch()). case 'D':cout << "Mi ". sound(520).CPP #include <iostream. case 'F':cout << "Fa ". } 137 . break. sound(494). sound(290). } } } while ( nota=='A' || nota =='S' || nota=='D' || nota=='F' || nota=='G' || nota =='H' || nota=='J' || nota=='K' ). nosound(). break. int tiempo=0. case 'H':cout << "La ". y oirá las notas musicales". sound(342). Calcular e imprimir la retención de este mes y la retención acumulada por cada trabajador. monbre y apellido. El listado debe darse a nivel de Facultad. Los Cargos Variables se calculan como un 0. 10. c. Más de $1'850. Se debe leer información. para una empresa cualquiera y a continuación producir los cálculos correspondientes.7 ACTIVIDADES PARA EFECTUAR EN GRUPO DE ESTUDIO Y/O PERSONALMENTE 10. precio de venta por tonelada. Se tienen registros con los datos de la facultad. en pesos $. total de retención pagado hasta el momento.7. renta.1 Suponer que la administración de impuestos calcula la retención en la fuente(R) por trabajador. número de hijos. En cada registro a leer encontraremos los siguientes campos: código del estudiante.000 pagan un 2%. 10. 138 .7. nombre del estudiante. 10.000 y menos de $1'850. Hasta sueldos de $ 700. renta. salario básico. toneladas producidas.40000 * NH. b. soltero). patrimonio. para salarios brutos(SB) mayores a tres salarios mínimos en la siguiente forma: R = SB/5 .7. tomados estos datos de la correspondiente declaración de renta de los acudientes del estudiante. Cada empleado tiene una tarjeta así: Código del empleado. toneladas exportadas. y se debe obtener una impresión en papel del nombre y apellido del estudiante.3 Suponga que la Administración de Impuestos calcula la retención en la fuente. Universidad y ciudad. para lo cual los datos entran ordenados por esta clave.15% de la renta gravable. 10.4 Una universidad está interesada en elaborar una relación de los estudiantes que estando casados trabajen. d.000 y más de 2 hijos no pagan. para cada uno de los años .7. desde 1970 a 1996. Calcular lo siguiente: . Sueldo Mensual. según la siguiente tabla (es solo un ejemplo ficticio): a. Número de Hijos. patrimonio. cargos variables y el total de la matrícula a cancelar. situación laboral (trabaja.2 del patrimonio más un 0. Hasta sueldos de $ 700.7. cargos fijos. toneladas vendidas localmente.Total toneladas exportadas. estado civil (casado. (NH:Número de Hijos). Los Cargos fijos son iguales a un salario mínimo.000 pagan un 4%.000 y 1 ó 2 hijos un 1%. no trabaja).2 Calcular la cantidad a pagar de matrícula por cada estudiante de la siguiente forma: El total a pagar es igual a los cargos fijos más los cargos variables.10.Ingresos. la cual contenga: Número de Cédula.Inventario acumulado(stock) al 01 de enero de 1997 . edad. para un número indeterminado de personas. Más de $ 900.5 Se tienen en una empresa cementera registros con los siguientes campos: año de producción. Numeros[I] = pow(2. cada una con la capacidad de albergar un elemento de datos. A los componentes de un arreglo se asignan valores de forma similar que a cualquier otra variable. Para accesar un elemento específico del arreglo se hace referencia a su número de celda o valor del índice. apellidos[25]. y es la implementación de la idea de sucesión en la matemática. 7. a menos que se dé implicitamente el tamaño del arreglo por medio de la inicialización del mismo como en: char Operador[] = {'+'. A manera de ejemplo. int Enteros[] = { 4. Numeros[100]. '-'. 6. '/'}. es obligatorio. y queda inicializado con los correspondientes carateres dados entre llaves. Es posible formar arreglos de los tipos de datos simples como int. Ya dentro del algoritmo podríamos presentar las siguientes instrucciones: Numeros[3] = 4569. -23. esto se llama dimensionamiento. cout << "Precio máximo = $" << Precio[articulo]. Los elementos de una variable arreglo. 345. 139 . Como se ve. se declara el tipo de datos del arreglo y su tamaño. el número de elementos del arreglo estará dado por el número colocado entres [ y ] al declararlo.CAPÍTULO 11. podríamos hacer las siguientes declaraciones de arreglos: int X[7]. char y de sus modificadores de tipo y de tipos estructurados. asignándoles valores antes de efectuar ninguna otra operación con ellos. puede ser accesado o referido en forma directa. En el primer ejemplo. 5. 13. Precio[artículo] = costo[articulo] + utilidad[articulo]. 45. Operador será un arreglo de cuatro posiciones. el dimensionamiento.3. char letras[26]. Un arreglo puede concebirse como un grupo de celdas o contenedores. o vector. float Anualidades[max]. en donde cada uno. ARREGLOS UNIDIMENSIONALES 11. cantidades[100]. Por esto es conveniente inicializar o efectuar lectura.10). Anualidades[I] = Anualidades[I-1] * 1. costo[250]. es una colección de elementos del mismo tipo. El índice para un arreglo debe ser de tipo entero. no reciben valores cuando el arreglo se declara(tendrán "basura"). Cuando se declara un arreglo. -12}. char nombres[20]. float Precio[250].1 INTRODUCCIÓN En ciencias de la computación un arreglo lineal. Cada arreglo de esta forma será una colección de elementos del mismo tipo. '*'. El segundo ejemplo el vector Enteros tendrá 10 posiciones. float. 0. utilidad[250]. Este. En general si I es un entero. En los arreglos anteriores. Similarmente podríamos hablar para vectores de otros tipos de datos. leido por teclado. los cuales coincidan con las posiciones válidas del arreglo correspondiente. ser asignado directamente en el código del algoritmo por medio de la instrucción: X[0] = 126. las posiciones válidas van desde el cero hasta N menos uno. etc. El valor de 126 a podido. ocupa en memoria 2 byte. X[0] se refiere al primer elemento del vector y tiene almacenado el entero 126. o identificador del arreglo unidimensional o vector. La representación gráfica o abstracción que debemos tener de un vector o arreglo unidimensional es la siguiente: Vector X ┌──────┐ │ 126 │ ├──────┤ │ 47 │ ├──────┤ │ -4 │ ├──────┤ │ 0 │ ├──────┤ │ 10 │ ├──────┤ │ -99 │ ├──────┤ │ 69 │ └──────┘ El vector X ha sido declarado como: int X[7]. Cada elemento del vector X. deben tener valores enteros. el número 3 es el índice. al ser tipo int. los índices: I. X[3] es el cuarto elemento del vector y tiene almacenado un valor de 0. 140 . el arreglo X ocupará 2 * 7 = 14 bytes en la memoria RAM del computador. Los arreglo unidimensionales son más comunmente conocidos como vectores. desde disco. y nos lo podemos "imaginar" vertical u horizontal vector X ┌────┬────┬────┬────┬────┬────┬────┐ │126 │ 47 │-4 │ 0 │ 10 │ -99│ 69 │ └────┴────┴────┴────┴────┴────┴────┘ X[0] X[1] X[2] X[3] X[4] X[5] X[6] índice o subíndice encerrado entre [ ] X[0] X[1] X[2] X[3] X[4] X[5] X[6] X es el nombre. será el valor que ocupa la posición I del vector. por ejemplo por teclado con la siguiente instrucción: cin >> X[3].cin >> Numeros[i]. este valor puede ser asignado directamente. El valor de 0 en la posición 3 a podido ser leido. tendremos que X[I]. por ejemplo. como veremos en los ejemplos siguientes de este capítulo. por lo tanto. el número 0 es el índice. gets(nombres[persona]). Recuerde si el arreglo es de N elementos. articulo y persona. i++){ cout << setw(4) << vector[i]. } 141 . clrscr(). float vector[Max]. } while(!kbhit()).i<N. cout << setw(20) << F[i].h> #include <conio. } 11. //VECTOR_1.h> const int Max=10.CPP #include <iostream. for (i=0. cin >> vector[i].h> const int N=64. F[0] = 0.h> #include <iomanip. for (i=0. //VECTOR_2.i<N.CPP #include <iostream.i++){ cout. } cout << endl << endl.11.h> #include <iomanip.2 Se lee un vector por teclado y luego se muestra en pantalla.h> #include <conio.setf(ios::fixed).3 Se generan los N primeros términos de la serie de Fibonacci. void main(){ float F[N]. int i. F[1] = 1.i++) F[i] = F[i-1] + F[i-2]. for(i=2. void main(){ int i. for(i=0. i++){ cout << "Real para posición " << i << ": ". clrscr(). i<Max. } while(!kbhit()). i<Max. if (item == vector[i]) cout << "\Encontrado en posición " << i. void main(){ int i. while(!kbhit()). //VECTOR1. i = 0. cin >> item.4 Se genera un vector. } 142 . i < N.CPP #include <iostream. cin >> N. } //ALGORITMO DE BUSQUEDA SECUENCIAL EN ARREGLO UNIDIMENSIONAL float item. cout << "\aElementos a generar al azar en vector(Máximo " << Max << "): ". de la cantidad de posiciones "deseadas". i++){ vector[i] = random(100). cout << setw(4) << vector[i].h> #include <iomanip. for (i=0. float vector[Max]. else cout << "\n\aNo encontrado en vector". //Válida el valor de N en el rango adecuado randomize(). Finalmente se pide buscar un elemento en el vector. cout << "\n\nDigite un número para encontrar su posición en vector: ".h> const int Max=200. N. do{ clrscr().h> #include <conio. while( i<N && item != vector[i]) i++. aleatoriamente mostrándolo en pantalla.h> #include <stdlib.11. } while (N<1 || N>Max). int pos. cout << "\nAhora el VECTOR tiene " << N << " elementos". i--. con los valores actuales for (i=0. i < N.h> #include <iomanip. } while (pos<0 && pos>N). cout << "\aElementos a generar al azar en VECTOR(Máximo " << Max << "): ". else{ cout << "\n\nDigite un número para INSERTAR en el VECTOR: ".5 Se inserta un elemento en una posición dada en vector en memoria. //Válida el valor de N en el rango adecuado randomize(). for (i=0. cin >> N.CPP #include <iostream. i++) cout << setw(4) << VECTOR[i]. i = N. i < N. // La cantidad de elementos en el VECTOR aumenta en uno //Se lista el VECTOR.11. // Oserve que sería lo mismo: VECTOR[i] = item N++. cout << setw(4) << VECTOR[i].h> const int Max=100.h> #include <conio. cin >> pos. } } 143 . una posición while(i > pos){ VECTOR[i] = VECTOR[i-1]. if (N==Max) cout << "\n\n\aNo se pueden insertar más elementos en el VECTOR". main(){ int i. N. } VECTOR[pos] = item. } //ALGORITMO DE INSERCION DE ELEMENTO EN POSICION DADA DE UN VECTOR float item. no está ocupada //ahora se "corren" los elementos a la derecha de pos. cin >> item. //VECTOR2. i++){ VECTOR[i] = random(100). } while (N<1 || N>Max). do{ cout << "\nDigite posición en la que desea insertarlo(0-" << N <<"): ". float VECTOR[Max]. //observe que la posición N en el VECTOR. do{ clrscr().h> #include<stdlib. i++){ X[i] = random(100).h> <iomanip. } N--. do{ clrscr(). } //ALGORITMO DE ELIMINACION DE ELEMENTO EN UNA DADA POSICION DE VECTOR float item.CPP #include #include #include #include <iostream. do{ cout<<"\nDigite posición de número que desea eliminar(0-" << N-1 <<"): ". //VECTOR3. pos++. i++) cout << setw(4) << X[i]. // La cantidad de elementos en el X se decrementa en uno //Se lista el X. main(){ int i. cout << "\aElementos a generar al azar en vector(Máximo " << Max << "): ".h> <conio. while(!kbhit()). i < N. } while(pos<0 || pos>N-1).h> <stdlib.width(4). for (i=0. for (i=0. N.6 Se elimina un elemento de un vector a partir de su posición. //Válida el valor de N en el rango adecuado randomize(). a continuación. cin >> N. } 144 . i < N. cout << "\n\nAhora el vector tiene " << N << " elementos". float X[Max].h> const int Max=50. while(pos < N){ X[pos] = X[pos+1]. cout << X[i]. sin item eliminado cout << endl << "Eliminado: " << item << " del vector siguiente: \n". cout. int pos.11. cin >> pos. } while (N<1 || N>Max). return 0. item = X[pos]. float A[Max].h> #include <stdlib.h> #include <iomanip.h> const int Max=10. } else cout << "\nNo se encontró el elemento \a". } 145 . //Se generan números reales de esta forma cout << setiosflags(ios::fixed) << setw(8) << A[i]. while (i < N-1){ A[i] = A[i+1]. } if(item == A[pos]){ //se encontró elemento y se procede a eliminarlo i = pos. i < N.11. } N--. i++){ A[i] = random(1000)/13. i++) cout << setw(4) << A[i]. a continuación. pos = 0. //Se decrementa en uno la cantidad de elementos en el vector A //Se lista el vector A.7 Se genera un vector. while( pos < N && A[pos] != item ){ //Búsqueda secuencial del elemento pos++.0. aleatoriamente mostrándolo en pantalla. cout << "\nAhora el vector tiene " << N << " elementos". cout << "\aElementos a generar al azar en A(Máximo " << Max << "): ". do{ clrscr(). Finalmente se elimina un elemento a partir de su búsqueda.CPP #include <iostream. cout << "\nDigite valor del elemento que desea eliminar: ". N. } //ALGORITMO DE ELIMINACION DE ELEMENTO EN VECTOR CON PREVIA BUSQUEDA float item. sin item eliminado for (i=0. i < N. //VECTOR4. for (i=0.h> #include <conio. //Válida el valor de N en el rango adecuado randomize(). de la cantidad de posiciones "deseadas". } while (N<1 || N>Max). main(){ int i. int pos. cin >> N. cin >> item. i++. 8. 11.9 Leer un vector.5 Leer valores numéricos en un vector en desorden. 11.11.8. por medio de la utilización de arreglos unidimensionales paralelos.8. de N posiciones.100 3 85 .8 Lea un vector de N elementos y luego imprima cuántos y cuáles elementos son múltiplos del elemento siguiente.6 Generar por medio de la función random() vector de 100 elementos en desorden. Generar a partir de él otros otros tres vectores A. 11.8. 11. lo siguiente: El El El El El El número de aspirantes aceptados en el plan 751.8. a continuación mostrarlo en la misma secuencia pero ignorando los elementos repetidos y diciendo ¿cuántos se imprimieron?. plan que más aspirantes tuvo. no incluya elementos repetidos?. número total de Estudiantes. promedio de calificaciones por plan. A continuación clasificar en orden ascendente los números pares y en orden descendente los impares.8. Determinar el número de veces (frecuencia) que aparece cada uno de los (diez) dígitos en el vector.4 Se tiene un vector de N posiciones de tipo entero.8. número de aspirantes que presentaron exámenes en el plan 749.100 2 78 . en el cual cada uno de sus componentes puede ser solo un dígito. 11.3 Lea un vector A de N elementos todos diferentes y un vector B de M elementos los cuales pueden ser repetidos.1 Se tiene un arreglo unidimensional. en B los impares y en C los múltiplos de 10. 11.8. (El que estaba de primero quedará de último y viceversa). B y C de suerte que en A estén solo los números pares. ¿Cuántas veces se encuentra presente cada elemento de A en B? 11.8 ACTIVIDADES PARA REALIZAR EN GRUPOS 11. 11.100 Cada estudiante tiene un registro con la siguiente información: ╔════════╦══════╦══════════╦═══════════╦═══════════╗ ║ CODIGO ║ PLAN ║ PUNTAJE ║ PUNTAJE ║ PUNTAJE ║ ║ ║ ║ EXAMEN 1 ║ EXAMEN 2 ║ EXAMEN 3 ║ ╚════════╩══════╩══════════╩═══════════╩═══════════╝ Solamente se tienen los planes de estudio 747 al 751. EXAMENES PUNTAJES 1 80 . número de aspirantes aceptados en el plan 748.8. ¿Cuántas veces se encuentra presente cada elemento de A en B. y luego invertirlo sobre él mismo.7 Una Universidad exige a los estudiantes aspirantes a los planes de Ingeniería los siguientes puntajes en cada uno de tres examenes para ser aceptados. 146 . Elabore un algoritmo que permita calcular.2 Leer un vector A de N elementos y un vector B de M elementos (pueden ser repetidos en cada vector). 11. 147 . haga lo siguiente: Inicializar el vector de el estado de las sillas. (este es el estado 0) de la siguiente forma: vector que representa cada una de las 25 sillas ┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┐ │0 │0 │ 0│ 0│ 0│ 0│ 0│ 0│ 0│ 0│ 0│ 0│ 0│ 0│ 0│ 0│ 0│ 0│ 0│ 0│ 0│ 0│ 0│ 0│ 0│ └──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 A continuación diseñe un menú el cual permita invocar iterativamente a las funciones: Reservar(). y cuando se aborda el avión (recibe el "pasabordo") debe quedar con un dos. cuando se reserve un uno. es decir en Estado 1 no se podrá efectuar reserva. d)Listado de los nombres de todos los pasajeros que viajaron. si ya está reservada. Su nombre y en que silla quiere la reserva. c) Sillas totales vacías (Estado 0 + Estado 1). cuyos elementos representen los números de cada una de las sillas. Cancelar(). al pasajero. b) Total sillas reservadas y que no viajó el pasajero(Estado 1). con Cero.11 Una línea aérea desea controlar las reservas de vuelo de un avión. para esto asígnele un número DOS(2).11. (Vuelve al estado 0). de tipo entero. En esa posición se debe asignar un UNO (1). main(). Observe. Al final escriba el vector en orden inverso. CANCELAR RESERVA: Se pide el número de silla que tiene reservada y se debe asignar a esa posición un CERO (0). En la función principal. uno para los nombres de los pasajeros y otro. CONFIRMAR RESERVA: Cuando el pasajero se presenta al aeropuerto se le debe solicitar el número de silla y marcarla como "ocupada" en el vector.(Estado 1 de reservada). Utilice vector de enteros para almacenar cada uno de los residuos que se calculan repetidamente al dividir entre 2. para el estado de cada una de las sillas. Se debe presentar un menú el cual cual permita invocar las siguientes funciones: RESERVAR CUPO: El algoritmo debe pedir. de lo anterior que el número de la silla lo dará la posición respectiva en el vector.8. En Reservar() debe pedir el nombre del pasajero y el número de la silla en la cual quiere viajar. recuerde: cuando una silla está vacía debe tener un cero. (Este es el estado 1). a) Números de sillas que van ocupadas(Estado 2).8. en orden alfabético. Se supone que al pasajero se le está mostrando un plano del avión con las sillas numeradas. Inicie definiendo variables tipo vector y globales para el nombre y el estado de la silla. en base 2. Confirmar() y Cerrar(). (Este será el estado 2). En la posición del número de la silla asignarle un 1. CERRAR EL VUELO(y terminar el programa): Cuando producir un listado con la siguiente estadística: el avión vaya a despegar. adecudamente escrito. siempre y cuando esté en el estado 0. es decir vacía. El número de cupos disponible para el vuelo es de 25. Para lo anterior debe definir dos vectores "paralelos".10 Leer un número en base 10 y a continuación presentarlo. j=0.h> #include <conio. while( i < N ){ Menos++. j. clrscr(). quedando en estado de ocupada. volviendo al estado de vacía. void main(){ int i.En cancelar() se debe digitar el número de la silla que el pasajero quiere cancelar y se le debe asignar un 0. Al cerrar el vector podría ser que estuviera en el siguiente estado: vector que representa cada una de las 25 sillas ┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┐ │2 │0 │ 1│ 2│ 0│ 2│ 0│ 2│ 2│ 2│ 2│ 0│ 0│ 0│ 0│ 2│ 0│ 1│ 0│ 2│ 2│ 2│ 0│ 0│ 2│ └──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 11. y a En Cerrar() presentar en pantalla la estadística pedida y a continuación terminar el programa. } } for (i=0. Vector[i-1] = -i. i++) cout << setw(5) << Vector[i].8.12 Efectue prueba de ejecución manual al siguiente algoritmo: //VECTOR10. Vector[i-1] = i.h> const int Max=500. } if ( i < N ){ i++. de la silla.h> #include <iomanip. cin >> N. i = Menos = 0. i < N. while(j < Menos && i < N){ j++. En Confirmar() se debe pedir al pasajero el número continuación asignarle un 2. i++. } 148 . cout << "\aElementos a generar al azar en vector(Máximo " << Max << "): ". float Vector[Max]. N. Menos.CPP #include <iostream. se hace igual a i+1 o sea que a j se le asigna 1. i < N-1. } La variable índice i toma el valor inicial de cero. a continuación el índice j. j < N. vector[i] = aux. aux .h> const int N=5. } for (i = 0. i<N. j++) if (vector[i] > vector[j]) { aux = vector[j]. i++. } Prueba de ejecución manual del programa anterior. j < N.1 Se digitan N números se almacenan en vector y luego se ordenan. j. se presenta a continuación para un N=5: en su fragmento de for (i = 0. cout << "Digite " << N << " enteros\n". main(){ int vector[N]. vector[i] = aux.h> #include <conio. i++) cout << i+1 << ": " << vector[i] << "\n". for(i=0. i++) for (j = i+1.CAPÍTULO 12. clrscr(). while (i < N){ cout << i+1 << ": ". i++) for (j = i+1.CPP #include <iostream. ALGORITMOS DE CLASIFICACIÓN DE VECTORES 12. vector[j] = vector[i]. vector[j] = vector[i]. como se muestra al comienzo de la siguiente tabla: 149 . } cout << "\nLos números ordenados en orden ascendente son:\n\n". j++) if (vector[i] > vector[j]) { aux = vector[j]. //VECTOR_3. cin >> vector[i]. ordenamiento.¡Error! Marcador no definido. i < N-1. i=0. VECTOR EN ORDENAMIENTO ASCENDENTE ─────────────────────────────────────────────────────────────────────────────── 150 .──────────────────────────────────────────────────────────────────────────────── VECTOR ORIGINAL EN DESORDEN POSICIONES A COMPARAR INTERCAMBIO 0 1 2 3 4 (N=5) i i<N-1 j j<N vector[i] > vector[j] ──────────────────────────────────────────────────────────────────────────────── ┌───┬───┬───┬───┬───┐ │ 8 │ 4 │ 2 │ 3 │ 1 │ 0 0<5-1 1 1<5 8>4 SI └───┴───┴───┴───┴───┘ ┌───┬───┬───┬───┬───┐ │ 4 │ 8 │ 2 │ 3 │ 1 │ └───┴───┴───┴───┴───┘ ┌───┬───┬───┬───┬───┐ │ 2 │ 8 │ 4 │ 3 │ 1 │ └───┴───┴───┴───┴───┘ ┌───┬───┬───┬───┬───┐ │ 2 │ 8 │ 4 │ 3 │ 1 │ └───┴───┴───┴───┴───┘ 0 2 2<5 4>2 SI 0 3 3<5 2>3 NO 0 4 4<5 2>1 SI 5 5<5 Falso ---------------------------------------------------------------┌───┬───┬───┬───┬───┐ │ 1 │ 8 │ 4 │ 3 │ 2 │ 1 1<5-1 2 2<5 8>4 SI └───┴───┴───┴───┴───┘ ┌───┬───┬───┬───┬───┐ │ 1 │ 4 │ 8 │ 3 │ 2 │ └───┴───┴───┴───┴───┘ ┌───┬───┬───┬───┬───┐ │ 1 │ 3 │ 8 │ 4 │ 2 │ └───┴───┴───┴───┴───┘ 1 3 3<5 4>3 SI 1 4 4<5 3>2 SI 5 5<5 falso ---------------------------------------------------------------┌───┬───┬───┬───┬───┐ │ 1 │ 2 │ 8 │ 4 │ 3 │ 2 2<5-1 3 3<5 8>4 SI └───┴───┴───┴───┴───┘ ┌───┬───┬───┬───┬───┐ │ 1 │ 2 │ 4 │ 8 │ 3 │ └───┴───┴───┴───┴───┘ 2 4 4<5 4>3 SI 5 5<5 Falso ---------------------------------------------------------------┌───┬───┬───┬───┬───┐ │ 1 │ 2 │ 3 │ 8 │ 4 │ 3 3<5-1 4 4<5 8>4 SI └───┴───┴───┴───┴───┘ 5 5<5 Falso ---------------------------------------------------------------┌───┬───┬───┬───┬───┐ │ 1 │ 2 │ 3 │ 4 │ 8 │ 4 4<5-1 Falso └───┴───┴───┴───┴───┘ POSICIÓN FINAL. h> const int N=5. while (!kbhit()). } } Escribir(){ int i=0. } 151 . do{ cout << i+1 << ": ". vector[j] = vector[j+1]. aux . while (i < N){ cout << i+1 << ": " << vector[i] << "\n". i++.h> #include <conio. i++) for (j = 0. //VECTOR_4. for (i = 1. (versión 1). i < N. en forma descendente. int vector[N]. cin >> vector[i]. cout << "Digite " << N << " enteros\n". i++. Leer(). j++) if (vector[j] < vector[j+1]) { aux = vector[j]. } while (i < N). } } main(){ clrscr(). } Ordenar(){ //ALGORITMO DE CLASIFICACIÓN POR EL MÉTODO DE LA BURBUJA int i. por el algoritmo de la burbuja. cout << "\nLos números en orden descendente son:\n\n".12. j < N-i. vector[j+1] = aux.2 Se digitan N números se almacenan en vector y luego se ordenan. Escribir().CPP #include <iostream. Ordenar(). //variable global Leer(){ int i=0. j. j. cout << setw(5) << vector[i]. menor. } cout << endl.h> const int Max=10. if (N==Max) cout <<"\n\aNo se pueden insertar elementos en vector. int pos.h> #include <stdlib. for (i=0. //A CONTINUACIÓN ALGORITMO DE INSERCIÓN EN UN VECTOR ORDENADO ASCENDENTEMENTE: //VECTOR5. pos_menor. i++){ vector[i] = random(100)+100. //Valida el valor de N en el rango adecuado randomize(). //Se busca posición donde se debe insertar el nuevo elemento while (pos < N && item > vector[pos]) pos++. N. 152 . } while (N<1 || N>Max). } } vector[pos_menor] = vector[i]. vector[i] = menor. pos_menor = j. cin >> N. //VECTOR5. for (j = i+1. do{ clrscr().CPP float item. i++) { menor = vector[i]. Tiene el máximo".3 Se efectúa inserción de elemento en un vector clasificado ascendentemente. //Algoritmo de clasificación por selección directa(straigh selection)(versión1): for (i = 0. j < N. i < N. else{ cout << "\n\nDigite valor del item a insertar: ". cout << "\aElementos a generar al azar en vector(Máximo " << Max << "): ". i < N. } for (i=0.12.h> #include <conio. i < N-1. pos = 0. i++) cout << setw(5) << vector[i]. void main(){ int i. cin >> item. pos_menor = i.h> #include <iomanip. j++){ if (vector[j] < menor) { menor = vector[j].CPP #include <iostream. float vector[Max]. //en una posición a la derecha i = N. i < N. for (i=0. i++) cout << setw(5) << vector[i]. } } 153 . } vector[pos] = item. cout << "\n\nAhora el vector tiene " << N << " elementos". //Se inserta el item N++. while (i > pos){ vector[i] = vector[i-1]. // El número de elementos en el vector aumenta en uno cout << endl.//A continuación se "corren" todos los elementos a la derecha de pos. i--. h> #include <conio. int i=0.(versión 2) //VECTOR_5.h> #include <stdlib. j++) if (vector[j] > vector[j+1]) { aux = vector[j]. i<Max . } A continuación se presenta prueba de ejecución manual del ordenamiento del programa anterior: for (i= Max-1. j++) if (vector[j] > vector[j+1]) { aux = vector[j]. i>=1. aux . } for (i=Max-1. vector[j] = vector[j+1].i++) cout << setw(8) << vector[i]. main(){ float vector[Max]. clrscr(). j<i. j<i.h> const int Max=5. for(i=0. j. } La variable i toma el valor de Max-1 = 5-1 = 4. cout.width(8).CPP #include <iostream.12. como se muestra en la siguiente tabla: 154 . vector[j+1] = aux. } cout << "\n\nAhora clasificado:\n". vector[j] = vector[j+1]. i--) // Max=5 posiciones(0-4) para el vector for (j=0. vector[j+1] = aux.4 Se digitan N números se almacenan en vector y luego se ordenan por el algoritmo de la burbuja. i>=1. i< Max . cout << vector[i] .h> #include <iomanip.i++){ vector[i] = rand(). for(i=0. i--) for (j=0. cout << "Vector generado aleatoriamente: \n". randomize(). ─────────────────────────────────────────────────────────────────────────────── PRUEBA DE EJECUCIÓN MANUAL DEL PROGRAMA VECTOR_5. VECTOR EN ORDEN ASCENDENTE 155 .CPP VECTOR ORIGINAL EN DESORDEN POSICIONES QUE SE COMPARAN INTERCAMBIO 0 1 2 3 4(Max=5) i i>=1 j j+1 j<i Vector[j]>vector[j+1] ──────────────────────────────────────────────────────────────────────────────── ┌───┬───┬────┬────┬───┐ │ 8 │ 4 │ 2 │ 3 │ 1 │ 4 4>=1 0 1 0<4 8>4 SI └───┴───┴────┴────┴───┘ ┌───┬───┬────┬────┬───┐ │ 4 │ 8 │ 2 │ 3 │ 1 │ └───┴───┴────┴────┴───┘ ┌───┬───┬────┬────┬───┐ │ 4 │ 2 │ 8 │ 3 │ 1 │ └───┴───┴────┴────┴───┘ ┌───┬───┬────┬────┬───┐ │ 4 │ 2 │ 3 │ 8 │ 1 │ └───┴───┴────┴────┴───┘ 1 2 1<4 8>2 SI 2 3 2<4 8>3 SI 3 4 3<4 8>1 SI 4 4<4 Falso -------------------------------------------------------------------┌───┬───┬────┬────┬───┐ Observe que el mayor quedó en su sitio │ 4 │ 2 │ 3 │ 1 │ 8 │ 3 3>-1 0 1 0<3 4>2 SI └───┴───┴────┴────┴───┘ ┌───┬───┬────┬────┬───┐ │ 2 │ 4 │ 3 │ 1 │ 8 │ └───┴───┴────┴────┴───┘ ┌───┬───┬────┬────┬───┐ │ 2 │ 3 │ 4 │ 1 │ 8 │ └───┴───┴────┴────┴───┘ 1 2 1<3 4>3 SI 2 3 2<3 4>1 SI 3 3<3 Falso -------------------------------------------------------------------┌───┬───┬────┬────┬───┐ el segundo mayor quedó en su sitio │ 2 │ 3 │ 1 │ 4 │ 8 │ 2 2>=1 0 1 0<2 2>3 NO └───┴───┴────┴────┴───┘ ┌───┬───┬────┬────┬───┐ │ 2 │ 3 │ 1 │ 4 │ 8 │ └───┴───┴────┴────┴───┘ 1 2 1<2 3>1 SI 2 2<2 Falso -------------------------------------------------------------------┌───┬───┬────┬────┬───┐ │ 2 │ 1 │ 3 │ 4 │ 8 │ 1 1>=1 0 1 0<1 2>1 SI └───┴───┴────┴────┴───┘ 1 1<1 Falso ┌───┬───┬────┬────┬───┐ │ 1 │ 2 │ 3 │ 4 │ 8 │ └───┴───┴────┴────┴───┘ 0 0>=1 Falso POSICIÓN FINAL. } while (N<1 || N>Max). } //Clasificación por selección directa(straigh selection)versión 2 for (i = N-1. N. //Se busca posición donde se encuentra el elemento while (item > Arreglo[pos] && pos < N) pos++.h> const int Max=10. } } Arreglo[PosMayor] = Arreglo[i].h> #include <stdlib. j++){ if (Arreglo[j] > Mayor) { Mayor = Arreglo[j]. //Valida el valor de N en el rango adecuado randomize().12. i--) { Mayor = Arreglo[i]. for (i=0.h> #include <conio. cin >> item. do{ clrscr(). //en una posición a la izquierda 156 . cout << "\n\nDigite valor del item a eliminar: ". cin >> N.h> #include <iomanip. i++){ cout << setw(10) << Arreglo[i]. if (item == Arreglo[pos]){ //A continuación se "corren" todos los elementos a la derecha de pos. i < N. Mayor. cout << "Elementos a generar al azar en Vector(Máximo " << Max << "): ". PosMayor.CPP #include <iostream. Arreglo[i] = Mayor. j < i. int Arreglo[Max]. cout << setw(10) << Arreglo[i]. for (i=0. j. } cout << endl. pos = 0. PosMayor = j. PosMayor = i. i++){ Arreglo[i] = random(32767). for (j = 0. void main(){ int i. i >=0. } //ALGORITMO DE ELIMINACIÓN EN VECTOR ORDENADO CON PREVIA BÚSQUEDA: float item. //VECTOR6.5 Se efectúa eliminación de elemento en vector clasificado a partir de su búsqueda (versión 1). int pos. i < N. Arreglo[1] = Arreglo[1+1] └───┴───┴────┴────┴───┘ ┌───┬───┬────┬────┬───┐ │ 1 │ 3 │ 4 │ 4 │ 8 │ para i = 2. explique el algoritmo de clasificación como ejercicio. Arreglo[2] = Arreglo[2+1] └───┴───┴────┴────┴───┘ ┌───┬───┬────┬────┬───┐ │ 1 │ 3 │ 4 │ 8 │ 8 │ para i = 3. for (i=0. i++. de la siguiente forma para cada i: 0 1 2 3 4 ┌───┬───┬────┬────┬───┐ │ 1 │ 3 │ 3 │ 4 │ 8 │ para i = 1. A continuación la variable N se decrementa en uno. cout << "\n\nAhora el Vector tiene " << N << " elementos". while (i < N){ Arreglo[i] = Arreglo[i+1]. después de efectuar la clasificación el vector está así: 0 1 2 3 4 ┌───┬───┬────┬────┬───┐ │ 1 │ 2 │ 3 │ 4 │ 8 │ └───┴───┴────┴────┴───┘ VECTOR EN ORDEN a continuación eliminaremos el item 2. // El número de elementos en el Vector se decrementa en uno cout << endl. y de esta forma tendremos eliminado el item deseado: 0 1 2 3 ┌───┬───┬────┬────┐ │ 1 │ 3 │ 4 │ 8 │ └───┴───┴────┴────┘ 157 . i < N. debido a la instrucción: Arreglo[i] = Arreglo[i+1]. supongamos que. y luego se le asigna a la i. } Del programa anterior.i = pos. } else cout << "\n\nElemento no se encuentra en el Vector\a\a". después de la búsqueda la variable pos tendrá el valor de 1. Ahora. } N--. Arreglo[3] = Arreglo[3+1] └───┴───┴────┴────┴───┘ para i=4 el while(i<N-1) se vuelve falso. i++) cout << setw(10) << Arreglo[i]. en el ciclo while los valores del arreglo variaran. while (!kbhit()).12. cin >> cadena[i]. Leer(). se almacenan en vector y luego se ordenan //VECTOR_7. i < N-1. //observe que es un arreglo bidimensional Leer(){ int i=0. for (i = 0. } } Ordenar(){ int i. i++){ gotoxy(10. cout << "\n\tLas palabras ordenadas son:\n\n". char cadena[N][LargoCadena]. strcpy(cadena[j].h> #include <string.h> #include <conio. Escribir().4+i). cout << cadena[i].2). Ordenar(). cout << "Digite " << N << " palabras". strcpy(cadena[i]. i < N. cadena[j]). j++) if (strcmp(cadena[i]. } 158 . gotoxy(10. } } main(){ clrscr().6 Se digitan N palabras. char aux[LargoCadena]. cadena[i]).j. i++) for (j = i+1. for(i=0.CPP #include <iostream. for (i = 0. aux). i++){ gotoxy(10.12+i). } } Escribir(){ int i. const int LargoCadena=20.h> const int N=5. i < N. cadena[j]) > 0) { strcpy(aux. j < N. Mayor.CPP //VECTOR_6. } while (i < N). } } Escribir(){ int i=0. } A continuación se programa VECTOR_6. clrscr().h> #include <conio. cin >> vector[i]. j < N. i < N-1. } void main(){ Leer(). clrscr(). j++){ if (vector[j] > Mayor) { Mayot = vector[j]. en ella inicialmente se borra la pantalla.7 Se digitan N números se almacenan en vector y luego se ordenan por el algoritmo de determinar el mayor y colocarlo en su posición. int vector[N]. pos = i. j. vector[i] = Mayor. Ordenar().CPP presenta prueba de ejecución manual para el anterior El programa inicia su ejecución en la función main().h> const int N=5. pos = j. do{ cout << i << ": " << vector[i] << "\n". Escribir(). (Versión 2. pos. } } Ordenar(){ int i. //variable global Leer(){ int i=0. ver vector6.cpp) El programa fuente: #include <iostream. i++) { Mayor = vector[i]. i++. for (j = i+1. y a continuación se invoca una tras otra las 159 . i++.12. while (i < N){ cout << i << ": ". } } vector[pos] = vector[i]. cout << "\nOrdenados descendentemente:\n\n". for (i = 0. cout << "Digite " << N << " enteros:\n\n". while. dando como resultado el ordenamiento del vector en forma descendente. └───┘ └──────────────────┘ ─────────────────────────────────────────────────────────────────────────────── 160 . en ella se propone al usuario que digite N números enteros. cuando la i toma el valor igual a N se termina el ciclo y luego la función retorna a la función main(). la cual se vuelve falsa cuando la variable local i se iguala con N. en este caso 5. los cuales son almacenados en posiciones sucesivas. 3. esto se repite sucesivamente. 1. Se muestra a continuación la presentación en pantalla y los valores en memoria después de invocarse la función Leer(): ────────────────────────────────────────────────────────────────────────────── Pantalla ┌──────────────────┐ Vector (en RAM) │ i │ │ Digite 5 enteros │ ┌─────┬─────┬─────┬─────┬─────┐ ├───┤ │ │ │ 13 │ 7 │ 27 │ 6 │ 58 │ │ 0 │ │ 0: 13 │ └─────┴─────┴─────┴─────┴─────┘ │ 1 │ │ 1: 7 │ 0 1 2 3 4 │ 2 │ │ 2: 27 │ │ 3 │ │ 3: 6 │ la variable local i toma sucesiva. para esto se utiliza la instrucción repetitiva while la cual es controlada por la variable i. de la variable global Vector. │ 5 │ │ │ 2. en este caso 5.funciones programa. 5. Ordenar() y Escribir() para de esta forma terminar el La primera función invocada es Leer(). La función Escribir() nos muestra en pantalla los valores del vector en orden descendente.. 4.. por teclado. por medio de la instrucción repetitiva do.│ 4 │ │ 4: 58 │ ente los siguientes valores: 0. Leer(). La función Ordenar() produce la clasificación del vector por el método de encontrar el mayor elemento y colocarlo en "su sitio". i. es decir en la posición más a la izquierda. │ │ │ │ │ │ │ │ │ │ 58 │ 4 │ │ │ │ │ │ │ │ │ ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┤ │ │ │ │ │ │ │ │ │ │ │5 │ F │ │58 │ 7 │27 │ 6 │58 │ │ │ │ │ │ │ │ │ │58 │ 7 │27 │ 6 │13 │ ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┼───┼───┼───┼───┼───┤ │1 │1<4 V│ 7 │ 7 │ 1 │2 │ V │27>7:verdad│ │ │ │ │ │ │ │ │ │ 27 │ 2 │ │ │ │ │ │ │ │ │ ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┤ │ │ │ │ │ │ │ │ │ │ │3 │ V │6>27:falso │ │ │ │ │ │ ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┤ │ │ │ │ │ │ │ │ │ │ │4 │ V │13>27:falso│ │ │ │ │ │ ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┤ │ │ │ │ │ │ │ │ │ │ │5 │ F │ │58 │ 7 │ 7 │ 6 │13 │ │ │ │ │ │ │ │ │ │58 │ 27│ 7 │ 6 │13 │ ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┼───┼───┼───┼───┼───┤ │2 │2<4 V│ 7 │ 7 │ 2 │3 │ V │6>7:falso │ │ │ │ │ │ ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┤ │ │ │ │ │ │ │ │ │ │ │ 4│ V │13>7:verdad│ │ │ │ │ │ │ │ │ │ 13 │ 4 │ │ │ │ │ │ │ │ │ ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┤ │ │ │ │ │ │ │ │ │ │ │ 5│ F │ │58 │27 │ 7 │ 6 │ 7 │ │ │ │ │ │ │ │ │ │58 │27 │13 │ 6 │ 7 │ ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┼───┼───┼───┼───┼───┤ │3 │3<4 V│ 6 │ 6 │ 3 │ 4│ V │7>6:verdad │ │ │ │ │ │ │ │ │ │ 7 │ 4 │ │ │ │ │ │ │ │ │ ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┤ │ │ │ │ │ │ │ │ │ │ │ 5│ F │ │58 │27 │13 │ 6 │ 6 │ │ │ │ │ │ │ │ │ │58 │27 │13 │ 7 │ 6 │ En orden ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┼───┴───┴───┼───┼───┤ │4 │4<4:F│ │ │ │ │ │ │ │ │ │ └──┴─────┴──────┴─────┴───┴──┴─────┴───────────┴───────────┴───┴───┘ 161 . según la siguiente prueba tabular de ejecución: ┌──┬─────┬──────┬─────┬───┬──┬─────┬───────────┬───────────────────┐ │i │i<N-1│Vector│Mayor│Pos│J │J< N │ if │ VECTOR │ │ │i< 4 │ [i] │ │ │ │J< 5 │Vector[J]>M│ 0 1 2 3 4 │ ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┼───┬───┬───┬───┬───┤ │ │ │ │ │ │ │ │ │13 │ 7 │27 │ 6 │58 │ ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┼───┼───┼───┼───┼───┤ │0 │0<4 V│ 13 │ 13 │ 0 │1 │ V │7>13:falso │ │ │ │ │ │ ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┤ │ │ │ │ │ │ │ │ │ │ │2 │ V │27>13:verd.En la invocación de la función Ordenar() se produce clasificación descendente del vector.│ │ │ │ │ │ │ │ │ │ 27 │ 2 │ │ │ │ │ │ │ │ │ ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┤ │ │ │ │ │ │ │ │ │ │ │3 │ V │6>13:falso │ │ │ │ │ │ ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┤ │ │ │ │ │ │ │ │ │ │ │4 │ V │58>13:verd. 4 Efectúe prueba de ejecución manual al siguiente fragmento. 12. Vector[Der] = Aux.8. en el cual se ordenan por medio de el algoritmo de Inserción Binaria.1 Efectúe prueba de ejecución manual al siguiente fragmento.CPP. del programa VECTOR12. i++){ Aux = Vector[i]. while(Izq < Der){ Medio = (Izq + Der)>>1. j>=Der+1.8.Se muestra a continuación la presentación en pantalla y los valores en memoria después de ejecutarse la invocación a la función Escribir(): Pantalla ┌──────────────────────────────────┐ │ Digite 5 enteros: │ │ │ │ 0: 13 │ │ 1: 7 │ │ 2: 27 │ │ 3: 6 │ │ 4: 58 │ │ │ │ Ordenados Descendentemente: │ │ │ │ 0: 58 │ │ 1: 27 │ │ 2: 13 │ │ 3: 7 │ │ 4: 6 │ │ │ └──────────────────────────────────┘ Vector (en RAM) ┌─────┬─────┬─────┬─────┬─────┐ │ 58 │ 27 │ 13 │ 7 │ 6 │ └─────┴─────┴─────┴─────┴─────┘ 0 1 2 3 4 │ i │ ├───┤ │ 0 │ │ 1 │ │ 2 │ │ 3 │ │ 4 │ │ │ └───┘ 12. en el cual se ordenan número por el algoritmo de intercambio directo ó burbuja.3 Dado un vector que almacene los nombres de pila de los estudiantes de la Universidad.8. calcule la frecuencia de cada nombre. } 12.2 Se tienen dos vectores ordenados y sin elementos repetidos cada uno en memoria. Izq = 0. Ver "Algoritmos y Estructuras de Datos" de Niklaus Wirth. for (i = 1. 162 . else Der = Medio. del programa VECTOR11. } for (j=i. 12. j--) Vector[j] = Vector[j-1].CPP. Una forma de resolver podría ser clasificando en orden ascendente los nombres. i < N. Copiar los elementos que estén en ambos solo una vez. if (Vector[Medio] <= Aux) Izq = Medio + 1. Der = i. producir a partir de ellos uno tercero también ordenado(fusión).8. Ver "Algoritmos y Estructuras de Datos" de Niklaus Wirth.8 ACTIVIDADES PARA REALIZAR EN GRUPOS Y PERSONALMENTE 12. for (i = 1. Vector[j-1] = Vector[j].5 Efectúe prueba de ejecución manual al siguiente fragmento. k = Der. j--) if (Vector[j-1] > Vector[j]) { Aux = Vector[j-1]. j >= Izq.8. j<=Der. i < N. k = N-1. j++) if (Vector[j-1] > Vector[j]){ Aux = Vector[j-1]. for (j=Izq. Ver "Algoritmos y Estructuras de Datos" de Niklaus Wirth. Vector[j] = Aux. } Izq = k+1. 163 . } 12. i++) for (j = N-1. del programa VECTOR13. do{ for (j = Der. } Der = k-1. j--) if (Vector[j-1] > Vector[j]){ Aux = Vector[j-1]. } while (Izq < Der). Vector[j] = Aux. k = j. en el cual se ordenan por intermedio del algoritmo de Vibración (shakesort). Izq = 0. Der = N-1. Vector[j-1] = Vector[j].CPP. Vector[j] = Aux. j >=i. Vector[j-1] = Vector[j]. . i++) if (A[i]!=0) cout << setw(5) << A[i]. observe que el algoritmo "pierde tiempo" borrando de nuevo a los pares que ya estaban en el paso anterior: ┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬── │ │ │ 2│ 3│ 0│ 5│ 0│ 7│ 0│ 0│ 0│11│ 0│13│ 0│ 0│ 0│17│ 0│19│ 0│ 0│ 0│23│ 0│25│. └──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴── A continuación se eliminan todos los múltiplos de 3.h> #include <conio.1 Cálculo de números primos por la Criba de Eratóstenes. i=i+2) A[i] = 0.CAPÍTULO 13. for (i=2 i < Max. } i += 2. ┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬── │ │ │ 2│ 3│ 4│ 5│ 6│ 7│ 8│ 9│10│11│12│13│14│15│16│17│18│19│20│21│22│23│24│25│. for (i=2.. i < Max. ALGORITMOS CON VECTORES (Continuación) 13.¡Error! Marcador no definido. while (multiplo < Max){ A[multiplo] = 0. //Se "eliminan" todos los pares i = 3. └──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴── 165 .h> #include <iomanip. //VECTOR8. por medio de la asignación de un número cero: ┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬── │ │ │ 2│ 3│ 0│ 5│ 0│ 7│ 0│ 9│ 0│11│ 0│13│ 0│15│ 0│17│ 0│19│ 0│21│ 0│23│ 0│25│. i++) A[i] = i. └──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴── En el segundo FOR se eliminan todos los pares.h> const int Max=2000. el cual es un número primo. A[Max]. i < Max. for (i=4.. multiplo = multiplo + i... el valor de su posición: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25. con excepción del 2. multiplo. } El algoritmo anterior sigue la siguiente secuencia: en la primera instrucción FOR se asigna a cada posición. while ( i < (Max/2) ){ //Se eliminan todos los múltiplos de impares multiplo = i*2. void main(){ int i. } clrscr().CPP #include <iostream.. iniciando en 2. h> #include <stdlib. j++) if (A[i] > A[j]) { aux = A[j]. M. i++) //Se genera "al azar" el vector A A[i] = random(100). i < N.h> const int Max=10. main(){ int i. C[Max*2]. i++) //Se genera "al azar" el vector B B[i] = random(100). k. for (i=0. clasificados en un tercer vector C de tamaño M+N.Se incrementa el contador en dos para obtener 5 y se procede a borrar los múltiplos del mismo. i++) //Clasificación vector A for (j = i. cin >> M. for (i=0. i < M. 13. } for (i = 0. cout <<"\n\aElementos a generar al azar en B(Máximo " << Max << "): ".2 Se efectúa la fusión de dos vectores. 166 . cout <<"\aElementos a generar al azar en A(Máximo " <<Max << "): " << M. cin >> N. //Valida el valor de N en el rango adecuado randomize(). así: ┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬── │ │ │ 2│ 3│ 0│ 5│ 0│ 7│ 0│ 0│ 0│11│ 0│13│ 0│ 0│ 0│17│ 0│19│ 0│ 0│ 0│23│ 0│ 0│. aux.. B[Max]. //Valida el valor de M en el rango adecuado do{ clrscr(). } while (M<1 || M>Max).h> #include <iomanip.h> #include <conio. cout << "\aElementos a generar al azar en A(Máximo " << Max << "): ". float A[Max]. B[j] = B[i]. j < N. A[j] = A[i]. N. A de tamaño M y B de Tamaño N. B[i] = aux. for (i = 0. } while (N<1 || N>Max). A[i] = aux. j. i++) //Clasificación vector B for (j = i. j++) if (B[i] > B[j]) { aux = B[j].CPP #include <iostream. //VECTOR7. do{ clrscr(). l. i < M. └──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴── y así sucesivamente. j < M. i < N. l<N.CPP cout << "\n\nFUSION DE LOS DOS VECTORES:\n". k++. k++. i++) cout << setw(5) << A[i]. l<M. j++. i++) cout << setw(5) << B[i]. for(i=0. i<N. //ALGORITMO DE FUSIÓN DE DOS VECTORES CLASIFICADOS EN UNO TERCERO //VECTOR7. while(i < M && j < N ){ if (A[i] <= B[j]){ C[k] = A[i]. cout << "\nVector B:\n". l++){ C[k]=B[l]. } 167 . } for (i=0. l++){ C[k]=A[l]. i < M+N.} clrscr(). i<M. } else //Se término primero el vector B for (l=i. } if(i==M) //Se término primero el vector A for (l=j. i++. i++) cout << setw(4) << C[i]. } else{ C[k] = B[j]. for(i=0. cout << "Vector A:\n". } k++. i = j = k = 0. j++){ vector[j] = random(MAXINT). HaHabidoIntercambio.3 Se digitan N números se almacenan en vector luego se ordenan y finalmente se presenta el algoritmo de búsqueda binaria. pasada. verdad=1. for (j=0.CPP #include <iostream. else if (item < vector[medio]) der=medio-1. izq=0. j < N-pasada-1. for (j = 0. } 168 . medio = (izq+der)/2.h> //funciones para generar al azar #include <values. } pasada++. randomize(). HaHabidoIntercambio=verdad. medio = (izq+der)/2.h> #include <conio. //VECTOR_8. vector[j] = aux. HaHabidoIntercambio=verdad. } pasada=0. medio.h> #include <stdlib. j++) if (vector[j] > vector[j+1]){ aux = vector[j+1]. // ALGORITMO DE LA BÚSQUEDA BINARIA cout << "\n\nDigite un número para encontrarlo en el vector: ". vector[j+1] = vector[j].h> #include <iomanip. else cout << "No encontrado \a". der=N-1. cin >> item.h> //MAXINT main(){ const falso=0. j<N. } cout << "\n\nLOS MISMOS NÚMEROS AHORA EN ORDEN ASCENDENTE:\n\n". j++) cout << setw(8) << vector[j]. item. while (pasada<N && HaHabidoIntercambio){ HaHabidoIntercambio=falso.13. aux. N=10. while (vector[medio] != item && izq < der){ if (item > vector[medio]) izq=medio+1. cout << N << " NÚMEROS GENERADOS AL AZAR\n\n". j<N. } if (vector[medio] == item) cout << "\nEncontrado en posición " << medio. for (j=0. cout << setw(8) << vector[j]. int vector[N] j. clrscr(). } } void main(){ Leer().4 El siguiente programa permite leer palabras en un vector de cadena(matriz de caracteres) y a continuación invertirlo. i < Max.13.4+i). i < Max. i++){ gotoxy(10. cadena[i]). //cambie para Max igual a un número par void Leer(){ gotoxy(10. } } void Escribir(){ cout << "\n\tEste es ahora el orden de las palabras:\n\n". i++){ gotoxy(10.h> #include <conio.2). //VECTOR9. } } Intercambiar(){ int i. char aux[LargoCadena]. const int LargoCadena=20. j++) for (i = 0. i++) { strcpy(aux. for(int i=0. cadena[i+1]). cout << cadena[i]. j < Max. for (j = 1. Intercambiar(). strcpy(cadena[i+1]. i < Max-j. el primero quedará de último y viceversa. aux). Escribir(). } 169 . cin >> cadena[i]. char cadena[Max][LargoCadena].h> const int Max=5.j.CPP #include <iostream. for (int i = 0. cout << "Digite " << Max << " palabras".h> #include <string.12+i). strcpy(cadena[i]. 8 Calcule el producto escalar de dos vectores A y B.1 Lea un vector de N elementos de tipo real. Obtenga un vector C con aquellos elementos en posición impar de A y que son menores que el respectivo elemento en posición impar de B. 13. .5. Se deben leer por teclado N elementos para el vector A y m elementos para el B.. 13.5.5. a continuación efectuar el cálculo correspondiente al producto escalar y luego presentarlo en pantalla adecuadamente. C y D de MAX elementos.4 Se tendrán cuatro vectores A..7 Lea dos vectores A y B de igual número de elementos.10 Lea un vector de N elementos de tipo entero y luego muestre solo los que son múltiplos de un número M el cual debe ser digitado previamente por teclado.5. + anbn recuerde que el resultado de esta expresión es un escalar. encontrar todos sus factores primos. bn) y de esta forma el producto escalar A B. se debe obtener un vector C que guarde en cada posición la suma de los correspondientes de A y B.5. 13. 13.. Almacene en otro vector los elementos mayores que el número pi.CPP por medio del algoritmo de la Criba de Eratóstenes. 13.3 Leer un número entero y utilizando el vector obtenido en el programa VECTOR8.. teniendo en cuenta que: A = (a1. 13.2 Dado un vector "cantidad" de N posiciones.5. 13. está dado por: A B = a1b1 + a2b2 + .5 ACTIVIDADES PARA REALIZAR EN GRUPOS 13. b2.5. 170 . 13. 13.13. B. an) B = (b1.5.9 Debe digitar por teclado los n componentes de cada uno de los dos vectores. .5. a2.. Calcular el volumen de ventas semanal en pesos en otro vector "ventas" para cada uno de los artículos... Por ejemplo si se digita el 960 se debe imprimir en pantalla: 960 = 2x2x2x2x2x2x3x5.6 Si los vectores A y B tienen igual cantidad de elementos. donde cada elemento contiene las unidades vendidas de un determinado artículo durante una semana y el vector "Precio-unitario" donde cada elemento contiene el precio en pesos al cual se vende el artículo. Finalmente calcule el total vendido en la semana.5.5 Obtenga vector C que almacene el doble de cada elemento del vector con menos cantidad de elementos y un vector D que almacene la raíz cuadrada de cada elemento del vector con mayor cantidad de elementos. strcpy(cadena[i]. strcpy(cadena[i]. for (i = 0. strcpy(cadena[i]. while(i<j) { strcpy(aux. strcpy(cadena[i]. la variable cadena está en memoria y se ha definido así: char cadena[Max][LargoCadena]. } while(i<=Max/2).13. do{ strcpy(aux[i]. cadena[Max-i-1]). cadena[i]). j--. cadena[i]). } } void Intercambio4(){ int i. i++) strcpy(cadena[i]. aux). char aux[LargoCadena].11 Efectúe prueba de ejecución manual a cada una de las funciones. siguientes //Max y LargoCadena son constantes globales void Intercambio1(){ int i=0. strcpy(cadena[j]. } } //observe que aux es un vector de cadenas 171 . j=Max-1. cadena[i]). char aux[LargoCadena]. strcpy(cadena[Max-1-i]. char aux[LargoCadena]. } void Intercambio3(){ int i. for (i = 0. char aux[Max][LargoCadena]. cadena[j]). strcpy(cadena[j]. i++) { strcpy(aux. i++. i < Max/2. i < Max/2.j = Max. cadena[j]). } } void Intercambio2(){ int i=0. cadena[Max-1-i]). cadena[i]). i++. i<Max. for(i=Max/2. aux). strcpy(aux.5. aux). aux[Max-i-1]). i++) { j--. . está almacenado un 23. De esta forma en la fila 0 columna 0 está almacenado el número entero 34. de la cual nos hacemos la siguiente idea o abstracción: ¡E rr or ! Ma rc ad or no de fi ni do . así por ejemplo se podría dar esta definición: int Matriz[5][4]. ¡Error! Marcador no definido. corresponde al número de dimensiones. aquí trataremos solamente los de dos dimensiones. un índice para las filas y otro para las columnas. las cuatro columnas se numerarán desde el 0 hasta el 3. En los arreglos multidimensionales el número de índices específicos que se requieren para accesar un elemento.CAPÍTULO 14.1 INTRODUCCIÓN Los arreglos pueden tener múltiples dimensiones. el cero corresponde a la fila y el uno a la columna. mejor conocidos como matrices o tablas. En la posición Matriz[0][1].ARREGLOS BIDIMENSIONALES 14. está posición se denotará como Matriz[0][0]. por esto en los arreglos bidimensionales o matrices necesitaremos dos índices. 0 1 2 3 4 0 1 2 3 34 0 76 53 19 23 -5 15 69 23 67 45 13 -7 0 123 87 111 73 33 las cinco filas se numeran desde el 0 hasta el 4. que se lee "Matriz su cero uno". 173 . El dimensionamiento en lenguaje C/C++ se efectuará de la siguiente forma: se coloca el tipo. y se lee como "Matriz su cero cero". esta sería una variable estructurada compuesta por 5 filas y 4 columnas. a continuación el identificador correspondiente para el nombre de la variable y luego encerrado entre llaves [ ] el tamaño de las filas y el tamaño de las columnas. el 3 corresponde a la fila y el 4 corresponde a la columna. En la posición Matriz[3][4]. está almacenado un 23. el 4 corresponde a la fila y el 1 corresponde a la columna. está almacenado un 73. 174 .En la posición Matriz[4][1]. clrscr(). columna.h> #include <stdlib. for ( fila = 0. columna++) cout << setw(6) << MATRIZ[fila][columna]. columna++) { cout << "Posición: (" << fila << ". fila < MaxFilas. //MATRIZ1.3 Se genera al azar un arreglo bidimensional y luego se muestra en pantalla adecuadamente. fila++) for ( columna = 0. } } 14. fila < MaxFilas. fila++) { for ( columna = 0. void main(){ int fila. } } 175 . columna < MaxColumnas. cout << setw(6) << MATRIZ[fila][columna]. columna++) { MATRIZ[fila][columna] = random(100)+100. MATRIZ[MaxFilas][MaxColumnas]. clrscr().h> #include <iomanip.h> #include <conio. MATRIZ[MaxFilas][MaxColumnas]. } clrscr(). const int MaxColumnas=13. const int MaxColumnas=4. for ( fila = 0.h> const int MaxFilas=24. fila++) { for ( columna = 0.h> #include <iomanip. //MATRIZ2. } cout << endl.CPP #include <iostream. columna < MaxColumnas. fila < MaxFilas.14.h> const int MaxFilas=5. columna < MaxColumnas. main(){ int fila. cin >> MATRIZ[fila][columna]. randomize(). cout << endl.CPP #include <iostream." << columna << "): ".2 Se lee un arreglo bidimensional por teclado y luego se muestra en pantalla adecuadamente.h> #include <conio. columna. for ( fila = 0. columna++) { cout << setw(4) << MATRIZ[fila][columna]. 12. const int MaxColumnas=5. }. columna. for ( fila = 0. 8. 43. 26. columna < MaxColumnas.h> #include <stdlib. float Suma = 0. Suma += MATRIZ[fila][columna]. 0. fila < MaxFilas. } while (!kbhit()). 54. 12. Finalmente y "recorriendo la matriz por columnas" se suman sus columnas. } cout << endl. main(){ int fila.h> #include <iomanip. cout << "\nSumatoria de la fila " << fila << " = " << Suma.CPP #include <iostream. 90. fila++) Suma += MATRIZ[fila][columna]. columna < MaxColumnas. 32. for ( fila = 0. } cout << endl. 34.h> #include <conio. se muestra en pantalla con su sumatoria. 75.4 Se dan valores a un arreglo bidimensional al definirlo. for ( fila = 0.14. for ( columna = 0. float MATRIZ[MaxFilas][MaxColumnas] = {14. fila++) { for ( columna = 0. //MATRIZ3. for ( columna = 0. cout << "\nSumatoria de la columna " << columna << " = " << Suma. columna++){ Suma = 0. columna++) Suma += MATRIZ[fila][columna]. -30. } 176 . fila < MaxFilas. -10 clrscr(). Luego se presenta suma de cada una de sus filas.h> const int MaxFilas=4. 98. } cout << "\nSumatoria de la matriz = " << Suma << endl. columna < MaxColumnas. 54. fila < MaxFilas. 67. fila++) { Suma = 0. 23. -5. 12. for ( i = 0.h> #include <conio. } } 14. MATRIZ[MaxFilas][MaxColumnas]. } cout << endl. i < 10. i < 10. for ( j = 0.6 Se generan las tablas de multiplicar del 1 al 10. clrscr(). columna++) { MATRIZ[fila][columna] = fila * Columnas + columna + 1. for ( i = 0. j++) Tabla[i][j] = (i+1)*(j+1).h> #include <iomanip. j < 10. cout << " ". fila < Filas.3). //MATRIZ4. clrscr(). gotoxy(1. cout << endl. } } 177 . i++) cout << setw(4) << i+1. fila++) { for ( columna = 0. cin >> Filas.h> #include <iomanip. cout << "Digite el número de filas deseado (Máximo " << MaxFilas << "): ". cout << "Número de columnas deseado (Máximo " << MaxColumnas << "): ". columna < Columnas.h> const int MaxFilas=24. main(){ int fila. cin >> Columnas.CPP #include <iostream. cout << setw(5) << MATRIZ[fila][columna]. i < 10. Columnas. for ( fila = 0. const int MaxColumnas=15. Filas.CPP #include <iostream. es decir se numeran las posiciones de izquierda a derecha y de arriba hacia abajo. i++) for ( j = 0. cout << endl << endl.5 Asigna a una matriz los números desde uno hasta filas*columnas. j++) cout << setw(4) << Tabla[i][j].h> main(){ int i. j < 10. j. for ( i = 0.14.h> #include <conio. Tabla[10][10]. columna. i++) { cout << setw(4) << i+1 << " ". //MATRIZ5. fila < n. MATRIZ[fila][columna] = MATRIZ[columna][fila]. cout << endl. } while (n<1 && n>N). columna < n. columna. columna < fila. //MATRIZ6. fila++) { for ( columna = 0. columna++) cout << setw(5) << MATRIZ[fila][columna].h> #include <conio. fila < n. do{ clrscr(). fila++) //Se produce intercambio en relación a la diagonal principal for ( columna = 0. } cout << endl.7 Una matriz de orden NxN es generada al azar y luego se intercambian los valores en las posiciones [i][j] con los valores en la posición [j][i]. fila++) { for ( columna = 0. void main(){ int fila. float MATRIZ[N][N]. MATRIZ[columna][fila] = AUX. n. // Se genera al azar la matriz for ( fila = 0. AUX. cin >> n. for ( fila = 0. } for ( fila = 1.h> #include <stdlib. es decir en relación a la diagonal principal. cout << setw(5) << MATRIZ[fila][columna]. cout << "Digite dimensión de matriz deseada (Máximo " << N << "): ". } getch(). } cout << "\nIntercambio de Filas por Columnas: \n". columna++) { AUX = MATRIZ[fila][columna]. columna < n. randomize().CPP #include <iostream. } 178 .14.h> #include <iomanip. columna++) { MATRIZ[fila][columna] = random(100). Se produce un intercambio alrededor de la diagonal principal o sea intercambio de filas por columnas.h> const int N=10. fila < n. void main(){ int i. i++) // i recorre las columnas cout << setw(5) << B[j][i]. } while (N<1 && N>MaxN). cout << "\nMATRIZ A:\n". M. i < M.8 Una matriz A de orden MxN es generada al azar y luego se intercambian sus filas y columnas en otra matriz B de orden NxM. B[MaxN][MaxM]. cout << setw(5) << A[i][j]. j++) B[j][i] = A[i][j]. j < N. randomize(). } getch(). N. for ( i = 0. j++) { A[i][j] = random(100). do{ cout << "Número para N deseado (Máximo " << MaxN << "): ".h> #include <stdlib.h> const int MaxM=10. i++) { for ( j = 0. i++) for ( j = 0. cout << "\nMATRIZ B:\n". clrscr(). j < N. i < M.14. //MATRIZ7. for ( j = 0.CPP #include <iostream. } 179 . } cout << endl. } while (M<1 && M>MaxM).h> #include <iomanip. j < N. cout << endl. cin >> N. i < M.h> #include <conio. j++) { // j recorre las filas for ( i = 0. j. do{ cout << "Digite el número para M deseado (Máximo " << MaxM << "): ". const int MaxN=8. float A[MaxM][MaxN]. cin >> M. } for ( i = 0. } for ( c = 0. c < MaxColumnas. 91. const int MaxColumnas=5. luego se muestra en pantalla con su correspondiente sumatoria. for ( f = 0. for ( c = 0. float SumaMatriz=0.h> #include <stdlib. 98. } 180 . } } clrscr(). for ( c = 0. 76. for ( f = 0. c++) cout << setw(4) << VectorColumna[c]. 12. main(){ int f. float Matriz[MaxFilas][MaxColumnas] = {14. for ( c = 0. 8. cout << " " << SumaMatriz. 54. f < MaxFilas. 34. VectorFila[MaxFilas]. f++){ VectorColumna[c] += Matriz[f][c]. -5. c++) VectorFila[f] += Matriz[f][c]. f < MaxFilas. Luego se recorre la matriz por columnas efectuando la sumatoria de las mismas en correspondientes posiciones de otro vector. c.h> const int MaxFilas=4. cout << "\n\n". f++) { cout << f << ": ". VectorColumna[MaxColumnas]. 75. //MATRIZ8. c++){ VectorColumna[c] = 0. for ( f = 0. f++) { VectorFila[f] = 0. cout << " ". Posteriormente se efectúa la suma de las filas asignando el resultado a correspondientes posiciones de un vector.9 Se dan valores a una matriz al definirla. 23. 54. 32. 12. 43. for ( c = 0. SumaMatriz += Matriz[f][c]. c < MaxColumnas. f < MaxFilas. 0. c < MaxColumnas.h> #include <iomanip. c++) cout << setw(4) << Matriz[f][c]. -3. Finalmente se presentan las sumas de filas y columnas de la matriz contenidas en los sendos vectores. cout << " " << VectorFila[f] << endl. 12.CPP #include <iostream. 67. c < MaxColumnas.14.h> #include <conio. c < MaxColumnas. 65}. } cout << endl << " ". c++) cout << setw(4) << c. } while (matriz[x][y]!=' '). } cout<<"\n\n".j<3.h> #include<stdlib. do{ clrscr(). cin >> x >> y.j++) matriz[i][j]=' '.i<3.h> main(){ char matriz[3][3]. intenta otra coordenada\n". EL COMPUTADOR CON 0\n" << "Teclee sus coordenadas separadas por un espacio en blanco: ". #include<stdio. if (ganador==' '){ //verifica si gano el jugador //turno del computador 181 .i<3.i++) for (j=0.y. //mostrar la matriz for(i=0.i++) if(matriz[i][0]==matriz[i][1] && matriz[i][0]==matriz[i][2]) ganador=matriz[i][0].x.i++) if(matriz[0][i]==matriz[1][i] && matriz[0][i]==matriz[2][i]) ganador=matriz[0][i]. matriz[x][y]='X'.i<3.10 El siguiente programa presenta un sencillo algoritmo el cual permite jugar al tres en raya o "triqui".h> #include<conio. //verificación de triunfo del jugador for(i=0. for(i=0. if (matriz[x][y]!=' ') cout<<"no se puede. if(matriz[0][2]==matriz[1][1] && matriz[1][1]==matriz[2][0]) ganador=matriz[0][2]. x--. if(matriz[0][0]==matriz[1][1] && matriz[1][1]==matriz[2][2]) ganador=matriz[0][0]. int i. //inicializar la matriz con un espacio en blanco en cada posición for (i=0. do{ //turno del jugador do{ cout<< "USTED JUEGA CON LA X.14.i<3.i++){ cout<<" "<<matriz[i][0]<<" | "<<matriz[i][1]<<" | "<<matriz[i][2]. y--.h> #include<iostream. if(i!=2) cout<<"\n---|---|---\n". } while ( (x<1 || x>3) || (y<1 || y>3) ).j. ganador. y++) if(matriz[x][y]==' ')break. getch().x++){ for(y=0. if(matriz[x][y]==' ')break. } else matriz[x][y]='O'. for(i=0. if(matriz[0][2]==matriz[1][1] && matriz[1][1]==matriz[2][0]) ganador=matriz[0][2]. } 182 . if(matriz[0][0]==matriz[1][1] && matriz[1][1]==matriz[2][2]) ganador=matriz[0][0]. i<3.i++){ cout<<" "<<matriz[i][0]<<" | "<<matriz[i][1]<<" | "<<matriz[i][2]. exit(0).\n". usted acaba de ganar".y<3. else cout<<"\nlo siento. } //verificacion de triunfo del computador for(i=0. i++) if(matriz[0][i]==matriz[1][i] && matriz[0][i]==matriz[2][i]) ganador=matriz[0][i]. } while (ganador==' '). //presentación del tablero final clrscr(). } //Escribe el mensaje de triunfo según el ganador if (ganador=='X') cout<<"\nfelicitaciones.i<3. } if(x*y==9){ cout << "Tablas.for(x=0. i++) if(matriz[i][0]==matriz[i][1] && matriz[i][0]==matriz[i][2]) ganador=matriz[i][0]. for(i=0. getch().x<3. if(i!=2) cout<<"\n---|---|---\n". i<3. el computador gano". j < P. cin >> A[i][j]. void main(){ int A[M][P]. } clrscr(). j++) cout << setw(10) << C[i][j]. for ( i = 0. i < M.11 El siguiente programa presenta la multiplicación de dos matrices A y B. } cout << endl. i < M. i < P. k < P. B de " << P << "x" << N << ":\n". i < P. i. } cout << endl. for ( i = 0. C[M][N]. cout << endl. j < N. j++) { cout << "Posición: (" << i << ". k++) C[i][j] = C[i][j] + A[i][k] * B[k][j]. j < N. j. N=3. i++) for ( j = 0. cin >> B[i][j]. << j << "): ". j < N. j++) { cout << "Posición: (" << i << ". for ( i = 0. j < P. Ver la primera pregunta en los ejercicios asignados. P=4. cout << endl." } de " << M << "x" << P << ":\n". B[P][N]. para refrescar la memoria sobre esta multiplicación. } } 183 . k. j < N.h> #include <iomanip. j++) cout << setw(10) << B[i][j]. << j << "): ".14. i++) { for ( j = 0. j++) cout << setw(10) << A[i][j]. i < M.h> const int M=2. i++) for ( j = 0. clrscr(). //MATRIZ9." } clrscr(). i++) { for ( j = 0. // ALGORITMO: MULTIPLICACIÓN DE DOS MATRICES for ( i = 0. cout << endl. cout << "\nDigite valores de la matriz for ( i = 0. for ( k = 0. i++) for ( j = 0.h> #include <conio. j++){ C[i][j] = 0. i++) { for ( j = 0. i < M. cout << "Digite valores de la matriz A for ( i = 0.CPP #include <iostream. h> #define MaxFilas 20 #define MaxColumnas 15 void main(){ int fila.. El producto de A y B es una matriz Cij de orden m x n y en la cual cada uno de sus cij términos son iguales a ai bj.4). for ( fila = 0. cout << "Número de columnas deseado (Máximo " << MaxColumnas << "): ".. los vectores ai y bj tendrían diferente número de componentes y el producto escalar correspondiente no estaría definido.14. MATRIZ[MaxFilas][MaxColumnas].h> #include <iomanip. C = A x B. Para obtenerse la expresión final: cij = ai1b1j + ai2b2j + . La matriz Bij debe ser de orden p x m y en la cual su j-ésima columna la denotamos por bj.12. fila++) { for ( columna = 0. De otra forma. clrscr().1 Estudie el algoritmo de multiplicación de matrices.CPP #include <iostream. columna++) { MATRIZ[fila][columna] = fila * Columnas + columna + 1. Filas. columna < Columnas. cin >> Columnas. fila < Filas. cout << "Digite el número de filas deseado (Máximo " << MaxFilas << "): ". + ainbnj NOTA: Dos matrices pueden multiplicarse sólo si el número de columnas de la primera es igual al número de filas de la segunda. el ij-ésimo elemento de C es el producto escalar de la i-ésima fila de A. cin >> Filas. 14. } getch(). } cout << endl. //MATRIZ_1. } 184 . y la j-ésima columna de B. Columnas.2 Efectúe lectura del siguiente algoritmo.CPP.12 ACTIVIDADES PARA RESOLVER POR GRUPOS DE ESTUDIO 14. gotoxy(1. cout << setw(5)<< MATRIZ[fila][columna]. columna. dado en el programa MATRIZ11. para esto tenga en cuenta lo siguiente: La matriz Aij debe ser de orden m x o y en la cual su i-ésima fila la denotamos por ai.12.h> #include <conio. Esto es. 14.12.14.12. Z.4 Estudie y mejore el juego de "triqui" o tres en raya presentado en el programa TRIQUI. f.MESES --> 1 empresa tiene para los últimos años el siguiente cuadro de 2 3 4 5 6 7 8 9 10 11 12 185 . ecuaciones y tres incógnitas. Y. e. así: ¡ E r r o r ! M a r c a d o r n o d e f i n i d o .5 Una producción: ¡Error! Marcado r no definid o. b. recuerde que son tres rectas en el espacio. l) y calcule los valores de las incógnitas X. j.CPP anterior. d. es el siguiente: aX eX iX + + + bY fY jY + + + cZ gZ kZ = = = d h l Lea los coeficientes y los términos independientes en una matriz de 3x4 y efectúe a partir de ella los cálculos correspondientes al método de Cramer. Observe que es muy fácil ganarle al computador y no debiera ser así.3 Solucione un sistema de ecuaciones lineales. a e i b c d f j g k h l 14. El sistema general a solucionar. compuesto de tres Lea inicialmente los coeficientes (a. k.12. i. c. h. g. por el método de Cramer. AÑO 1994 1995 1996 1997 1998 234 4 532 1 567 345 3 635 3 454 3 655 543 654 4 653 3 567 56 234 345 5 764 3 4545 7545 665 1234 8643 434 4545 976 7533 8755 3452 4544 3454 3454 9134 4542 1234 554 7544 9566 1233 1866 5453 7443 9665 4545 6654 4532 3432 9654 5454 234 3322 6543 10454 5453 434 5332 3466 9544 2321 678 2345 6543 9555 Defina una matriz de 5 filas y 12 columnas de tipo float. b) El mes de mayor producción de 1996. similares. 186 . c) El año de menos producción. d) Invente dos preguntas más. y calcule lo siguiente: a) El promedio de producción de cada uno de los años. cuando esté ejecutándose el programa) en memoria. estos dos bytes son el desplazamiento(offset) de la variable entero.2 PUNTERO A ENTERO El siguiente es un ejemplo con un puntero que apuntará a un entero(recuerde que un entero ocupa 2 bytes en memoria): int *p. En memoria un puntero ocupa 2 bytes. La variable VAR se encuentra en la dirección de memoria 1000(inicia desde hay). la verdadera la dará el sistema operativo por intermedio del compilador. *. p ┌────┐ │ │ └────┘ entero ┌─────────┐ │ 1 │ 3 │ └────┴────┘ 1500 1501 1500 es la dirección base de la variable entero. se lee esta instrucción así: "la dirección(&) de la variable entero se asigna a la variable puntero p". sino en binario. La abstracción que se debe hacer es la de que P apunta o señala a VAR. decimos entonces que el puntero "apunta" a esta variable. al identificador del mismo. entero=13. de la siguiente forma: P ┌────┐ │1000│ └────┘ VAR ┌───────────────────────┐ │ │ └───┴───┴───┴───┴───┴───┘ 1000 "P apunta a VAR" 1000 es una dirección(ficticia en nuestro ejemplo. al efectuar su declaración se debe anteponer un asterisco. A continuación el puntero p tomará la dirección de la variable entero: p = &entero. en memoria el efecto es el siguiente: 187 .CAPÍTULO 15 PUNTEROS Y PASO POR REFERENCIA 15. la variable P almacena un valor de 1000. La dirección de memoria RAM la cual almacena un puntero(p) corresponderá a la dirección base de otra variable(var) que está en memoria. entero al ocupar 2 bytes estamos suponiendo que ocupará las direcciones 1500 y 1501.1 INTRODUCCIÓN Los punteros son variables las cuales guardan direcciones de memoria RAM. 15. empero lo supondremos de esta forma por facilidad. Observe que el 13 almacenado en la variable entero no está en base 10 como es mostrado. Se puede definir un puntero de cualquier tipo básico o de tipos estructurados. de punto flotante. ha sido definida como un puntero a un entero. real=4. otra vez. para saber cual es el valor al que apunta p.3 PUNTERO A VARIABLE DE PUNTO FLOTANTE Los punteros pueden apuntar a variables de cualquier tipo. en este caso la variable p. la sintaxis de la declaración será: float *pf. y para saber cual es el valor al cual apunta p.67. en el siguiente ejemplo un puntero. apuntarará a una variable. A través del puntero podemos. y estamos suponiendo que ocupará las direcciones 2500 a la 2503. como sabemos este última tipo de variables ocupan 4 bytes en memoria. real. estos cuatro bytes son el desplazamiento(offset) de la variable real. Está mostrará el valor de 13 en pantalla. esto se efectúa así: *p = 21.p ┌────┐ │1500│ └────┘ entero ┌─────────┐ │ 1 │ 3 │ └────┴────┘ 1500 1501 Si se quiere visualizar el valor de la variable entero a través del puntero escribiremos la siguiente instrucción: cout << *p. *p debe ser leído como: "el valor al cual apunta p". debemos "saber" la dirección que tiene almacenada p y a qué tipo de datos apunta. debemos conocer la dirección que almacena. de esta forma en memoria las variables quedarán así: p ┌────┐ │1500│ └────┘ entero ┌─────────┐ │ 2 │ 1 │ └────┴────┘ 1500 1501 el 13 ha sido destruido al efectuarse la asignación *p = 21. 188 . pf ┌────┐ │ │ └────┘ real ┌───────────────────┐ │ 4. se leerá "al valor al que apunta p se le asigna 21". modificar el valor de la variable a la cual esté apuntando.67 │ └────┴────┴────┴────┘ 2500 2501 2502 2503 2500 es la dirección base de la variable real. además y es lo más importante. real ocupa 4 bytes en RAM. A continuación el puntero pf tomará la dirección de la variable real: pf = &real. pf. sabemos. 15. De similar forma podremos efectuar una lectura por teclado y asignárselo a la variable entero a través del puntero con la instrucción: cin >> *p. 56.67 ha sido destruido al efectuarse la asignación *pf = -23. en memoria nos no imaginaremos así: pf ┌────┐ │2500│ └────┘ real ┌───────────────────┐ │ 4.4 PUNTERO A UN VECTOR Supongamos tenemos la siguiente declaración de variables: int *pv. debemos "saber" la dirección que tiene almacenada pf y a qué tipo de datos apunta.67 │ └────┴────┴────┴────┘ 2500 2501 2502 2503 Para mostrar el valor de la variable real por medio puntero pf. y para saber cual es el valor al cual apunta pf.-6. de esta forma en memoria las variables quedarán así: pf ┌────┐ │2500│ └────┘ real ┌───────────────────┐ │ -23. la cual corresponde a la siguiente abstracción: vector pv 0 1 2 3 4 <---índices ┌────┐ ┌───────┬───────┬───────┬───────┬───────┐ │ │ │ 17 │ 2 │ -6 │ 3 │ 28 │ └────┘ └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘ direcciones---> 500 501 502 503 504 505 506 507 508 509 Para hacer que el puntero.56 │ └────┴────┴────┴────┘ 2500 2501 2502 2503 el 4. A través del puntero podemos modificar el valor de la variable a la cual esté apuntando: *pf = -23. escribiremos la siguiente instrucción: cout << *pf. para saber cual es el valor al que apunta pf.67 en pantalla. se leerá "al valor al que apunta pf se le asigna -23. Mostrará el valor de 4. 15. De similar forma podremos efectuar una lectura por teclado y asignárselo a la variable entero a través del puntero con la instrucción: cin >> *pf. en este caso p sabemos ha sido definido como un puntero a un float.56.2. tome la dirección base del vector se debe escribir la siguiente instrucción: 189 . debemos conocer la dirección que almacena. *pf debe ser leído como: "el valor al cual apunta pf". otra vez.28}.56". pv.se lee esta instrucción así: "la dirección(&) de la variable real se asigna a la variable puntero pf".3. vector[5] = {17. veamos prueba de ejecución manual del anterior fragmento en el siguiente tabulado: 190 . vector[2].pv = vector. 506. se puede indexar de igual forma que se hace con los identificadores de los arreglos. i++) cout << setw(4) << pv[i]. esto se codificará así: pv = vector. vector. Al ejecutar el fragmento anterior el valor en memoria de pv es de 500. pv++. pv. La abstracción que debemos tener quedará: vector pv 0 1 2 3 4 <---índices ┌────┐ ┌───────┬───────┬───────┬───────┬───────┐ │ 500│ │ 17 │ 2 │ -6 │ 3 │ 28 │ └────┘ └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘ direcciones---> 500 501 502 503 504 505 506 507 508 509 Los arreglos tienen gran relación con los punteros y deben ser vistos como punteros a los cuales no se les puede cambiar la dirección(la dirección base que almacenan) es decir como punteros constantes. cambiando la dirección del puntero. } En pantalla el efecto sería idéntico que en el caso anterior. según el siguiente fragmento: for(i=0. i++. al ser un entero se desplazará en dos bytes. 504. el índice es el que "avanza" en el arreglo. es decir que de 500 pase a 502. desde la dirección 500 hasta 509. vector[1]. observe que no se coloca el operador de dirección &. es decir apunta todo el tiempo a la dirección base. la variable pv cada que se le "suma uno" se incrementará según el tipo de datos al que apunta. El anterior arreglo. i<5. 508 las cuales son las posiciones base de cada uno de los elementos enteros del vector: vector[0]. para entenderlo. que nos mostrará en pantalla los valores: 17 2 -6 3 28. Es decir que el puntero. se puede recorrer con el puntero. aparecerán: 17 2 -6 3 28. En este caso la variable vector tiene una dirección base de 500 y un desplazamiento de 2 bytes*5=10 bytes. vector[3] y vector[4]. En memoria sería muy diferente. Diferente será si queremos avanzar en el vector. while (*pv && i<5){ cout << setw(4) << *pv. cout << "\nA la variable p se le asignó el valor: " << p. mostrado como ???. cout << "\nDigite un valor para la variable N: ". después de esto. cin >> *p. quedaría así: vector pv 0 1 2 3 4 <---índices ┌────┐ ┌───────┬───────┬───────┬───────┬───────┐ │ 510│ │ 17 │ 2 │ -6 │ 3 │ 28 │??? └────┘ └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘ direcciones-> 500 501 502 503 504 505 506 507 508 509 510 El puntero pv apuntaría a un valor de "basura". cout << "\nN = " << *p. <<"\n\nVariable N está en la dirección de memoria: "<<&N. cout << "N = " << N. eventualmente. getch().5 Esta es una demostración del manejo de un puntero a un número real. p = &N. cout cout cout cout } << "\nN = " << N. <<"\n\nPuntero p está en la dirección de memoria: " <<&p. *p. 191 . y por esto mostraría. si no se coloca la instrucción i<5 para que termine.h> //PUNTERO1. algo inesperado. en pantalla. <<"\n\nVariable N está en la dirección de memoria: " <<p. clrscr().CPP void main(){ float N=5.h> #include <conio. 15.──────────────────────────────────────────────────────────────────── pv *pv while(*pv) cout<<setw(4)<<*pv pv++ ──────────────────────────────────────────────────────────────────── 500 17 verdad 17 502 502 2 verdad 2 504 504 -6 verdad -6 506 506 3 verdad 3 508 508 28 verdad 28 510 510 ??? ??? La abstracción de lo que ocurre en memoria. #include <iostream. 2. 0. pR++.2. pE = &entero. } cout <<"\n". 2.'i'.15. for (i=0.45.9}. \t" << *pR << "\t" << pR << "\n\n". caracter = ' '. i++) { cout <<"\nvectorR[" << i << "]\t" << *pR << "\t" << pR. entero=234. vectorE[] = {3.7.5. cout << "VARIABLE pR = &real. 6. real = 7. 9.8.h> #include <stdio. matrizR[][3] = {4.'\0'}. 1."Colombia" }. 0. 9. Cadena[] = {'C'. 4. 6. cout <<"real VALOR DIRECCION\n\n". pE++. j<3. *Cadenas[] = {"Palmira ".4. -5.6 Esta es una demostración del manejo de los punteros. pR = vectorR. 8. "Valle ". vectorR[] = {3.3.'l'.5. } getch(). 7. 6. i<5.23. i++) { cout <<"\nvectorE[" << i << "]\t" << *pE << "\t" << pE. pE = (int *) matrizE. j.2}. char *pC = "Esta es una demostración\n\n". 0. i<3.8.3.5.'a'.CPP main(){ int *pE. 7. j++){ cout <<"\nmatrizE[" <<i <<"][" <<j <<"]\t" <<*pE<<"\t" <<pE. i. *Cad[] = {'\0'}. clrscr().6}. 9}.h> //PUNTERO2. clrscr(). cout << "VARIABLE VALOR DIRECCION\n\n". 2. float *pR. 2.h> #include <conio. #include <iostream.67. for (i=0. 192 . 9.4. i++) for (j=0. i<5. pE = vectorE. matrizE[][3] = {4. for (i=0. pE++. cout << "entero \t" << *pE << "\t" << pE << "\n\n". 0. cout <<"VARIABLE VALOR DIRECCION\n\n". cout <<"caracter\t"<<*pC<<"\t"<<pC<<"\n\n". pR++. *Cad = Cadena.//No dá la dirección pC = Cadena. j++){ cout <<"\nmatrizR[" <<i <<"][" <<j <<"]\t" <<*pR <<"\t"<<pR. getch(). for (i=0. for (i=0. i<3. cout <<"*Cad\t"<< *Cad<< "\t"<<Cad<<"\n\n". while (*pC) { cout<<"\nCadena["<<i<<"]\t"<<*pC <<"\t"<<pC. clrscr(). } 193 . } getch(). j<3. pC = &caracter.//No dá dirección pC++.//No dá la dirección cout <<"Cadena \t" << Cadena <<"\t" << &Cadena << "\n\n".} cout << "\n". i=0. i++) for (j=0. i++) cout<<"\n*Cadenas["<<i<<"]\t"<<Cadenas[i]<<"\t"<<&Cadenas[i]. } cout <<"\n". pR = (float *) matrizR. i<3. i++. return 0. //FUNCION8.CPP #include <iostream. cin >> p->alto. float alto. //PUNTERO3. *a = *b. *b = *aux. cout << "Digite un real para almacenar en variable B: ". por medio de una invocación de una función por referencia al estilo del C.h> #include <conio. cout << "\ny la variable B ahora es igual a " << b.b.8 El siguiente algoritmo presenta el intercambio del valor de dos variables en la memoria RAM del computador. cout << "Edad: ". cout << p->nombre << " " << p->edad << " " << p->alto. Ver el siguiente capítulo para la definición de este tipo de datos estructurado.h> typedef struct persona PERSONA. } main(){ PERSONA amigo. //variable local *aux= *a. cout << "Altura: ". cout << "Digite un real para almacenar en variable A: ".7 El siguiente es un ejemplo en el cual un puntero "apunta" a un registro(struct).h> IntercambioEnMemoria(int *a. cin >> p->edad. 194 . A ahora es igual a "<<a. } cin >> a. cout << "Nombre: ". } 15. p = &amigo. cin >> b. } main(){ int a.CPP #include <iostream. *p. &b). int *b){ int *aux. clrscr(). cout <<"\nDespués de intercambiadas. int edad. IntercambioEnMemoria(&a. struct persona{ char nombre[20].15. gets(p->nombre).h> #include <stdio. h> #include <conio. while(c){ r = c % 2. } } main(){ int decimal. //invocación por referencia CalcularBinario(decimal). y no en C++ int aux. // divide entre dos r = N % 2. leer(decimal). r. c >>= 1. cout << "Digite un real para almacenar en variable B: ". cout <<"\nAhora A = " <<a << " y B = " << b << " después del intercambio". cin >> b. cout << "Digite un real para almacenar en variable A: ". } void main(){ int a.h> #include <conio. } CalcularBinario(int &N){ int c. //variable local aux = a. c = N >> 1. b).CPP #include <iostream. a = b. //FUNCION9. Convierte un número en base 10 a base binaria #include <iostream. por medio de una invocación de una función con parámetros por referencia.CPP leer(int &N){ cout << "Digite: ". IntercambioEnMemoria(a. //invocación por valor } 15. cout << "\n" << r.15.9 Ejemplo de paso de parámetro por referencia al nuevo estilo del C++.h> //REFEREN2. } //observe que N al ser puntero se coloca sin & 195 . int &b){ //Esto daría error en C.10 El siguiente algoritmo presenta el intercambio del valor de dos variables en la memoria RAM del computador. b = aux. cout << "\n" << r << " Leer de abajo hacia arriba". cin >> a.b. cin >> N.h> IntercambioEnMemoria(int &a. decimal = leer(). //PUNTERO6. } // busca el final de la cadena // escribe el binario adecuadamente 196 . cin >> N. *r = 2. binario[20]. j.CPP #include <iostream. return (N). cout << "Digite un entero para convertirlo a binario: ". int *r){ int c. decimal. clrscr(). for(j=b-1. j--) cout << binario[j]. c >>= 1. binario). *r = N % 2. } void CalcularBinario(int N.12 Este programa convierte un decimal a binario. *r = c % 2.h> int leer(){ int N. j>=0. cout << "\n\nbinario = " . while(c){ r++. while(binario[b]==1 || binario[b]==0) b++.15. } r++. c = N >> 1.h> #include <conio. CalcularBinario(decimal. //se utiliza el dos como terminador } void main(){ int b=0. clrscr(). } 15.h> #include <stdio. Col++){ Matriz[Fila][Col]= Fila*Col+1. j++) if(cadena[i] > cadena[j]){ aux = cadena[i]. for ( Fila = 0. j<strlen(cadena). gets(cadena). Fila.h> const int MaxFila=5. Col. Col++) cout << setw(10) << *( *(Matriz+Fila) + Col) .h> #include <string. cadena de caracteres.h> void main(){ char *cadena. aux. int i.h> #include <conio. } getch(). void main(){ int Matriz[MaxFila][MaxCol]. Col < MaxCol. for ( Fila = 0. Fila++){ for ( Col = 0. i<strlen(cadena). } cout << endl.15. Recuerde que un arreglo bidimensional es solamente un arreglo de arreglos. } cout << "\"frase ordenada alfabéticamente\": \n" . //MATRIZ10. } } 197 . i++) for(j = i+1. cout << "Longitud cadena = " << strlen(cadena) << "\n\n".14 A continuación se presenta una demostración de como el lenguaje C maneja cada posición de un arreglo bidimensional por medio de punteros. cout << "Digite una frase: ". cout << endl. cadena[j] = aux.h> #include <conio.CPP #include <iostream. MaxCol=4. cadena[i] = cadena[j]. for(i=0.h> #include <iomanip. cout << setw(10) << Matriz[Fila][Col]. j. Col < MaxCol. //PUNTERO7.CPP #include <iostream. Fila++) { for ( Col = 0. Fila < MaxFila. puts(cadena).13 El siguiente algoritmo en lenguaje C ordena alfabéticamente. Fila < MaxFila. en forma ascendente. Escribir(vector). El profesor efectuará taller de lectura con este algoritmo. cin >> v[i]. } p++. while (i < N) { gotoxy(10. } q++. aux.2). //PUNTERO8. *q = aux.15 Se digitan N números se almacenan en vector y luego se ordenan. terminando el ciclo repetitivo. } } Ordenar(int *p){ int *q.width(4). Leer(vector). Este programa no funciona si se le da a alguna posición del vector el valor de cero. i++.15. *p = *q. } 198 . Ordenar(vector). while(*p){ q = p+1.4+i).h> #include <conio. while(*q){ if (*p > *q){ aux = *p. gotoxy(10. Leer(int *v){ int i=0. cout << "Digite " << N << " números".h> const int N=5. p++. } } Escribir(int *p){ cout <<"\n\tLos números ordenados son:\n\n". cout << *p. while(*p){ cout. debido a que la instrucción while lo evaluará como falso. } } void main(){ int vector[N].CPP #include <iostream. } 199 . cout << "Digite " << " números". num. j++) if (v[i] > v[j]){ aux = v[j]. j < N. Ordenar(numeros). i < N. gotoxy(10. Escribir(numeros). } } Ordenar(int *v){ int i. clrscr(). cout << "\n\tLos números ordenados son:\n\n".15. cin >> v[i++].h> #include <conio. Leer(numeros).4+i).width(5). } } main(){ int numeros[N].2).16 Se digitan N números se almacenan en vector y luego se ordenan.h> #define N 10 Leer(int *v){ int i=0. cout << v[i]. for (i = 0. while (!kbhit()). for (i = 0. i++){ cout.CPP #include <iostream. v[j]= v[i]. i++) for (j = i+1. i < N. while (i < N){ gotoxy(10. } } Escribir(int *v){ int i. v[i] = aux. //PUNTERO9.aux .j. h> <ctype.. med /= N.1. gotoxy(38.h> <math. window(2.. for(t = 0.7. int intro_datos(float *datos) { int t. } gotoxy(40.23).h> <graphics. cout << "Digite número de ítems?: ".h> const int MaxArreglo = 20. cout<<"╚═════════════════════════════════════════════════════════════════╝". return max. cin >> max.h> <stdlib. cout<<"╔═════════════════════════════════════════════════════════════════╗". char *s){ while(*s) { if(ch == *s) return ch. int N){ register int t. } float CalcularPromedio(float *datos. cout<<"║ EJEMPLO DE ESTADÍSTICA BÁSICA ║". cout << "Cualquier tecla y seguir.25). cout << "Introduzca Item " << t+1 << ": ".CPP #include #include #include #include #include #include #include #include <iostream.h> <iomanip. } void marco(){ int indice." .17 Programa de estadística básica //ESTADIST. float med=0. cout<<"╠═════════════════════════════════════════════════════════════════╣". for(indice = 5. for(t=0.1). return med. gotoxy(63. ++indice) cout<<"║ ║". } char CaracterEstaEn(char ch. t<max. ++t) { gotoxy(40. max. ++t) med += datos[t]. 2+t). indice < 25. window(1. } return 0.80.70.1). clrscr(). getch(). } 200 .15. cin >> datos[t]. 3+t).h> <fstream. t < N.h> <conio. else s++. ++w) if(md == datos[w]) cont++. } } return AnteriorModa. N). float aux. ++t) if(datos[t] < minimo) minimo = datos[t]. float temporal[MaxArreglo]. float minimo. } } float CalcularMediana(float *datos. for (t=0. for (t=0. i++) for (j = i. int N){ register int t. for(minimo = datos[0].void Clasificar(float *datos.j. unsigned int N){ register int t. antcont=0. ++t) { md = datos[t]. i < N. float md. t<N. } float BuscarMenor(float *datos. datos[j]= datos[i]. w. j < N. } float BuscarMayor(float *datos. cont = 1. return (temporal[(N-1)/2]). int N){ register int t. int cont. datos[i] = aux. for(w=t+1. if(cont > antcont) { AnteriorModa = md. t< N. t < N. antcont. AnteriorModa=0. j++) if (datos[i] > datos[j]){ aux = datos[j]. 201 . for (i = 0. int N){ register int t. } float EncontrarModa(float *datos. AnteriorModa. w < N. unsigned int N){ register int i. antcont = cont. /* copiar datos*/ Clasificar(temporal. ++t) temporal[t] = datos[t]. t=1. return minimo. Promedio)). ancho. t < max. float total=0. porcentajes[MaxArreglo]. float porcentajes[MaxArreglo]. t < N. cout << setfill('. } void mostrar(float *datos.max). int max){ int ManejadorGrafico. for(t = 0. } gotoxy(35.4+t). float total=0. ". for(max = datos[0]. t < max. detectgraph(&ManejadorGrafico. Promedio = CalcularPromedio(datos. double aux. for (i = 0. t++) porcentajes[t] = datos[t] / total. i++) porcentajes[i] = ((float) datos[i]) / total. abajo = getmaxy() . } void GraficarPorcentajes(float *datos. "c:\\tc\\bgi"). ++t) { gotoxy(32. arriba. ModoGrafico. ++t) if(datos[t] > max) max = datos[t]. cout <<"Cualquier tecla y seguir. DesvStd = sqrt(DesvStd). if (max){ for (i = 0. profundidad = (int) (ancho / 4). for (t = 0. abajo. return DesvStd..1+t).. for(t = 0. t = 1. izquierda. for (t = 0. } float DesviacionEstandard(float *datos. &ModoGrafico).Promedio) * (datos[t] . initgraph(&ManejadorGrafico. 202 .') << setw(2) << t+1 << setiosflags(ios::fixed) << setiosflags(ios::showpoint) << setiosflags(ios::right) << setprecision(2) << setw(10) << datos[t] << setw(10) << porcentajes[t]*100 << "%". if(max) DesvStd /= max. int max){ register int t. izquierda = ancho.10.float max. float DesvStd=0. t < max. &ModoGrafico. getch(). i++) total += datos[i]. t < max. t++) total += datos[t]. Promedio. return max. i < max. ancho = (int)( (getmaxx()) / ((max * 2 ) + 1) ). int i. profundidad. int max){ register int t. i < max. ++t) DesvStd += ((datos[t] . setcolor(RED). izquierda += (ancho * 2). int max){ register int t.1). int &N){ int IDArchivo.profundidad. closegraph(). } Imprimir << "\f". i < max. int N){ int i.') <<setw(5) << t+1 << setiosflags(ios::fixed) << setiosflags(ios::showpoint) << setiosflags(ios::right) << setprecision(2) << setw(15) << datos[t] << setw(15) << porcentajes[t]*100 << "%" << endl.open("Estadist.setbkcolor(WHITE). ios::out|ios::binary|ios::trunc). } else cout << "Archivo no existe". gotoxy(35. Archivo.ica". Imprimir<<"\n Registro Datos Porcentajes \n\n". t < max.close().(izquierda+ancho). mostrar(datos. ofstream Imprimir("PRN"). Archivo.open("Estadist.25))). fstream Archivo.4). sizeof(float) ) ) N++. t < max. cout <<"Imprimiendo. ios::in | ios::binary). N). for(t = 0.arriba. } void GrabarDatosEnArchivo(float *datos. N=0. t++) total += datos[t]. Archivo. i++) { arriba=(abajo) . fstream Archivo. t++) porcentajes[t] = datos[t] / total. for (t = 0.ica". for (i = 0. //borra archivo si existe if (!Archivo) 203 . } void LeerArchivoYCargarEnDatos(float *datos. //color de las líneas de cada barra setfillstyle(i+1..((int)(porcentajes[i] * (getmaxy() . ". bar3d(izquierda.read( (char *)&datos[N]. marco(). for (t = 0. porcentajes[MaxArreglo].. } getch(). float total=0. if(Archivo){ while( Archivo. cout << "Leídos desde disco: " . } } void Impresora(float *datos.abajo. t < max. ++t) { Imprimir << setfill('. i+1). 2). Archivo. cout << "Ordenar de menor a mayor". 204 .close(). N). cout << "MENÚ PRINCIPAL". cout << "Varianza : " << << << << Promedio. //Número verdadero de elementos float Promedio=0. gotoxy( 3. getch(). 9). N). // almacena valores de la muestra int N=0. marco(). Varianza. N). N). gotoxy( 3. 1). return entrada. Mediana. cout << "Estadísticas básicas". cout << "Capturar datos". DesvStd = DesviacionEstandard(datos. 7). 1). 4). N). for(.13). 6). Moda = EncontrarModa(datos. Menor = BuscarMenor(datos. entrada = toupper(getch()). cout << "TAREA: IMPLEMENTE ESTE MODULO. N). 3). i<N. Mayor=0.13). gotoxy( 3. } char OpcionMenu(){ char entrada. int max){ clrscr(). "CEOMGIT")). Varianza = DesvStd*DesvStd.cout << "Error en la apertura del archivo \a". } while (!CaracterEstaEn(entrada.. case 'E':Promedio = CalcularPromedio(datos. Menor=0. else{ for(i=0. Moda=0.Mediana=0. N). cout << "Mediana : " gotoxy(30. Varianza=0. gotoxy(39. gotoxy( 3. cout << "Imprimir en papel". gotoxy( 3. 5). i++) Archivo. clrscr(). gotoxy( 3. Mayor = BuscarMayor(datos. 4). break. Mediana = CalcularMediana(datos.write((char *)&datos[i]. } void main(){ //ESTADÍSTICA BÁSICA FUNCIÓN PRINCIPAL float datos[MaxArreglo]. cout << "Terminar". cout << "Mostrar datos". do { gotoxy( 3. LeerArchivoYCargarEnDatos(datos.DesvStd=0. 3). cout << "==============". gotoxy(30. cout << "Graficar en barras". sizeof(float)). DesvStd. cout << "Desviación Std : " gotoxy(30. cout<<"Elija letra inicial (C E O M G I T): ". gotoxy( 3. 2). DIGITE TECLA ". 8). gotoxy( 3. gotoxy( 3.) { switch( OpcionMenu() ) { case 'C':N = intro_datos(datos). cout << "Promedio : " gotoxy(30. } } void Regresion(float *datos. ". 5). 7). cout << "Máximo : " << Mayor. 9). break. break. 205 . exit(0). gotoxy(30. break. gotoxy(30..case case case case case } } } gotoxy(30. 'G':GraficarPorcentajes(datos.. 'O':Clasificar(datos. 'M':mostrar(datos. 'T':GrabarDatosEnArchivo(datos. N). cout << "Moda : " << Moda. N). cout << "Mínimo : " << Menor. 'I':Impresora(datos. gotoxy(30. N). break. N). mostrar(datos. getch(). N). 6). cout << "Cualquier tecla y seguir. N). break. . int Color.y1). void RealzaCuadro(int x1. int Oprimido).int color1. line(x1. y no en C++.C. observe que tiene extensión *. 1). el cual significa */ /* una de las opciones del menú */ /*******************************************************************/ void RealzaCuadro(int x1.Fila.int y1. Adicionalmente compile y ejecute el programa de demostración de la Borland.int color1. el cual está en el directorio \tc\bgi. BGIDEMO.int y1.h> #include <dos. char *Cad).CAPÍTULO 16.int color2).y1). line(x2.int x2.int Y.int color2){ setcolor(color1).h> #include <stdlib.x2. //Definición de algunos prototipos de funciones: void CentrarXCad(int Fila.y1. 207 . } /*******************************************************************/ /* Función : RealzaCuadro */ /* Objetivo : Muestra un rectangulo en pantalla.x2.x2.y2. line(x1. setcolor(color2).char *Cad. settextstyle(DEFAULT_FONT.h> //Definición de constantes globales: const DesActivo=0.y2.int y2. /************************************************************************/ /* Función : CentrarxCad */ /* Objetivo : Esta función se encarga de escribir una cadena */ /* centrada en la pantalla en modo gráfico */ /************************************************************************/ void CentrarXCad(int Fila.int y2. LargoCuadro.y2).CPP #include <graphics.int Color). char *Cad.C.x1. line(x1. char *Cad) { int largo = textwidth(Cad).y1. El profesor en clase magistral explicará paso a paso la construcción de un programa como este. int Y. } /*************************************************************************/ /* Función : ReCuadro */ /* Objetivo : Realiza recuadro. void Presentacion0().y2). */ /* da a significar una de las opciones de un menú */ /*************************************************************************/ void ReCuadro(int X. void PulsadoCuadro(int X.h> #include <ctype.h> #include <stdio. char c[2]. es decir está escrito en lenguaje C. void ReCuadro(int X. MENÚ DE CONMUTADORES EN MODO GRÁFICO El siguiente programa es una demostración de un menú de conmutadores horizontales y de varias primitivas de dibujo en modo gráfico. HORIZ_DIR. char *Cad. void Presentación(). int Y. outtextxy((getmaxx() -largo)/2. int Oprimido) { register int AltoCuadro.int x2. Activo=1.Cad).h> #include <conio.h> #include <bios. con una cadena centrada en su interior. \\MENU_HV. int Color. outtextxy(100.520. X+LargoCuadro. Y+AltoCuadro-1). Y+1). delay(100).DARKGRAY). line(X+1.Y. setcolor(YELLOW).char *Cad.Color. Y+1). Y+5.Color. Cad).Cad. MaxOp=8. Y+1. line(X+1.Color. setcolor(RED).0. 4. getmaxy()).Y. 1).50.10. DeltaY=25. outtextxy(X+5. Y+1.DesActivo). Y+AltoCuadro-1. Y+1. Col=550. char *Opcion[MaxOp] = { "Listar ". settextstyle(DEFAULT_FONT. Y+AltoCuadro-1). bar3d(X. Y+1. */ /************************************************************************* */ void SubMenu(char *SubtituloMenu) { const int Arb =72.AltoCuadro = textheight("H") + 7. c[1] = '\0'. outtextxy(100. } /*************************************************************************/ /* Función : Presentación */ /* Objetivo : presentar el nombre de la función y logo del estudiante */ /*************************************************************************/ void PresentacionSubMenu(char *SubtituloMenu) { clearviewport(). Yo=20. LargoCuadro = textwidth(Cad) + 7. 250. HORIZ_DIR.int Y.Y+AltoCuadro.int Color) { ReCuadro(X.Cad. 1). rectangle(0.Y+5. X+LargoCuadro-1. Y+AltoCuadro-1). Y. Color).Activo). X+1. outtextxy(X+5. pos = 0. "PROYECTO").4).WHITE).437. if (Oprimido) { setcolor(DARKGRAY). SubtituloMenu).Y.DesActivo). Y+AltoCuadro-1). Abj =80. setcolor(WHITE). c[0] = Cad[0]. 140. X+1. 208 . setcolor(13). "SUBMENÚ").Cad. X+LargoCuadro-1. ReCuadro(X. RealzaCuadro(10. RealzaCuadro(20. setcolor(DARKGRAY). settextstyle(TRIPLEX_FONT. X+LargoCuadro-1. Invocar=1. line(X+1. setcolor(14). setfillstyle(SOLID_FILL. } else { setcolor(WHITE). settextstyle(TRIPLEX_FONT. X+LargoCuadro-1. c. getmaxx(). line(X+1.c). } /****************************************************************/ /* Función : PulsadoCuadro */ /* Objetivo : Realiza ReCuadro con una cadena centrada en su */ /* interior y da la sensación de que se oprime */ /****************************************************************/ void PulsadoCuadro(int X. Y+1. Entrar =13. } line(X+LargoCuadro-1. } /************************************************************************* */ /* Función : subMenu */ /* Objetivo : Implementar menú para el manejo de funciones en la lista. delay(100). line(X+1. ReCuadro(X. setcolor(MAGENTA). HORIZ_DIR. outtextxy(100.430.WHITE.20.DARKGRAY.5). int i. HORIZ_DIR. setcolor(DARKGRAY)..510. else Invocar = 0. Opcion[i]. break. if(pos==MaxOp) pos=0.Opcion[pos]. "Imprimir ". "Salir " }.Yo+DeltaY*pos.Opcion[pos]. ReCuadro(Col. "Graficar ".//Alt-X case 59: break. break. Activo)..Yo+DeltaY*pos. } if (c==27) return. while (c==0) { c = getch(). while( c!=Opcion[i][0] && i<MaxOp) i++.LIGHTGRAY. case 2 : break. } } else if (c==Entrar) Invocar=1.LIGHTGRAY. switch (c) { case Abj: ReCuadro(Col. case 3 : break.LIGHTGRAY. } c = getch(). Yo+DeltaY*pos. switch(pos) { case 0 : break. case Arb: ReCuadro(Col.// F1 } c = getch().Opcion[pos]. Yo+DeltaY*i."Capturar ". DesActivo). for(i=0.Opcion[pos]. "Eliminar ".DesActivo). case 45: exit(0). i=0. if(Invocar){ PulsadoCuadro(Col. case 1 : break. pos++. for(.LIGHTGRAY. "Buscar ". if( isalpha(c) ){//Se digitó letra inicial? c=toupper(c).) { if(Invocar){ PresentacionSubMenu(SubtituloMenu).Activo). ReCuadro(Col. 209 .Yo+DeltaY*pos.Opcion[pos]. Opcion[pos]. pos--. Invocar=0. i++) { ReCuadro(Col.Yo+DeltaY*pos. } ReCuadro(Col.Activo). Invocar=1. LIGHTGRAY.Yo+DeltaY*pos. LIGHTGRAY. "Recursión". if(i<MaxOp){// Se digitó letra inicial de opción pos = i. i<MaxOp.LIGHTGRAY).DesActivo). if(pos== -1) pos= MaxOp -1. getmaxy()).DARKGRAY.WHITE). HORIZ_DIR. */ /************************************************************************ */ void main() { const Der =77. rectangle(0. i<MaxOp.. "Plantilla Proyecto"). i++) { ReCuadro(PosX[i]. setcolor(WHITE). "Profesor").fila."Usuarios".case case case case } } } } 4 5 6 7 : : : : break."Balance" . char *Opcion[MaxOp]={"Películas". setcolor(GREEN). for(i=1.470. } /************************************************************************ */ /* Función : Principal */ /* Objetivo :Menú para el manejo de funciones.fila.LIGHTGRAY.620. modo. "Humberto Mazuera Párraga"). &modo. fila =10.Opcion[pos]. return. Ancho=0. break.A."Alquiler". "Graficación en Lenguaje C"). i<MaxOp. Izq =75.610. RealzaCuadro(20. setcolor(WHITE). pos++. i++) Ancho= Ancho+textwidth(Opcion[i])+Margen. } ReCuadro(PosX[pos].DARKGRAY).LIGHTGRAY.Opcion[pos]. setcolor(LIGHTRED).Opcion[i]. while (c==0) { c = getch(). for(i=0.DesActivo). CentrarXCad(350. void PresentacionMain() { clearviewport().DesActivo). RealzaCuadro(10. CentrarXCad(60. HORIZ_DIR. switch (c) { case Der: ReCuadro(PosX[pos]. CentrarXCad(300.) { if (Invocar){ PresentacionMain(). int PosX[MaxOp]. getmaxx(). int Manejador=DETECT.U. i++) PosX[i]= PosX[i-1]+textwidth(Opcion[i-1])+Margen.50.40.WHITE. PosX[0]= (getmaxx()-Ancho)/2. } c = getch(). initgraph(&Manejador. i<MaxOp.O"). CentrarXCad(200.fila. int i. settextstyle(DEFAULT_FONT. CentrarXCad(100. setcolor(DARKGRAY).6). for(.0. settextstyle(DEFAULT_FONT. Entrar =13.3). Invocar=1. setcolor(YELLOW).Activo)."Salir"}.460. 210 . MaxOp =5.LIGHTGRAY. for(i=0. "c:\\tc\\bgi"). break. pos = 0. Invocar = 0. c. Margen=14. "C. ReCuadro(PosX[pos].fila. break.Opcion[pos].LIGHTGRAY). ReCuadro(PosX[pos]. break. if(pos== -1) pos= MaxOp -1.fila.//Alt-X case 59: break.Opcion[pos]. else if( isalpha(c) ){//Se digitó letra inicial? c=toupper(c). } } if(Invocar){ PulsadoCuadro(PosX[pos].LIGHTGRAY. break. return. case Izq: ReCuadro(PosX[pos]. break. case 1 : SubMenu("Usuarios"). break. case 2 : SubMenu("Alquiler"). if (c== Entrar) Invocar = 1. break.Opcion[pos].Activo). case 45: exit(0). }//while if (c==27) return.Opcion[pos]. Invocar=1.LIGHTGRAY.DesActivo). } } } } 211 .if(pos==MaxOp) pos=0. while( c!=Opcion[i][0] && i<MaxOp) i++.LIGHTGRAY. i=0. case 3 : SubMenu("Balance"). switch(pos) { case 0 : SubMenu("Películas"). if(i<MaxOp){// Se digitó letra inicial de opción pos = i.fila. case 4 : closegraph().Activo). pos--.// F1 } c = getch().fila. . . En los casos en que se pretendan definir todas las variables de tipo. posteriormente en el programa. que el recién iniciado. utilizando el siguiente formato: struct { TipoDeDatos NombreCampo1. La sintaxis general de este tipo de datos cumple con el siguiente formato: struct NombreDeRegistro{ TipoDeDatos NombreCampo1. en caso de omitirlo se presentan una serie de errores.. . atribuirá a otras cosas. NombreVariable2.. De esta forma una estructura es un conjunto de campos(fields) o miembros que se citan y manejan con el mismo nombre y que permite además la utilización individual de sus elementos.. se podrán definir variables. }. NombreVariableN. } NombreVariable1. TipoDeDatos NombreCampoN. NombreVariableN.. . o también: struct NombreDeRegistro{ TipoDeDatos NombreCampo1.... TipoDeDatos NombreCampo2. Los tipos de datos de cada uno de los campos pueden ser de cualquiera de los tipos primitivos o estructurados. se puede omitir el nombre de el registro. en la misma instrucción. . es probable. ESTRUCTURA DE DATOS REGISTRO 17. } NombreVariable1. NombreVariableN... 213 . según la siguiente sintaxis: struct NombreDeRegistro NombreVariable1.. TipoDeDatos NombreCampo2. En cualquiera de las dos formas.. y que pueden ser declarados en forma global o local. .CAPÍTULO 17..1 ESTRUCTURA DE DATOS REGISTROS(STRUCT) En C/C++ un registro se representa por medio de el identificador struct. se debe tener mucho cuidado en no omitir el punto y coma como terminador. . NombreVariable2... TipoDeDatos NombreCampo2. incluyéndose al mismo tipo struct.. TipoDeDatos NombreCampoN. quedará claro que posteriormente no se podrán definir variables de este mismo tipo. struct.. En la primera forma presentada. NombreVariable2. .. TipoDeDatos NombreCampoN. edad..salario Vector[.salario . escritura.salario Vector[1].nombre. Atributo. Vector[N-1].. Pais. Vector[0]. Pais. X VARIABLE Pais: ¡Error! Marcador no definido.Lenguaje. Y. Vector[1].Color.salario Vector[1]. asignación y formar parte de expresiones al lado derecho de asignaciones. float Población. Pais. Pais.y. Nombre Capital KilometrosCuadrados Poblacion Lenguaje Y Color Atributo VARIABLE: Vector: Vector[0] Vector[1] ¡Error! Marcador no definido. MiPuntico.nombre Vector[1]. las anteriores definiciones de variables debemos abstraerlas de la siguiente forma: VARIABLE MiPuntico: ¡Error! Marcador no definido. char Lenguaje[15]..Poblacion.. } MiPuntico. Vector[0]. float KilómetrosCuadrados.edad Vector[N-1]. } Vector[N].nombre. Vector[1]... float salario. La utilización de cada uno de los miembros dentro de las estructuras anteriores se efectuará de las siguientes y respectivas formas: MiPuntico. } Pais. char Capital[25].salario En las anteriores tablas se muestra el nombre de cada campo correspondiente a las tres variables. Vector[N-1].nombre.Ejemplos de definición de tipos de datos "estructura" son los siguientes: struct Punto{ int X. 214 ..salario Las expresiones anteriores se utilizarán como cualquier otro identificador de variable de las vistas hasta ahora. MiPuntico.edad Vector[1].Capital.].edad. struct Registro{ char Nombre[Max].edad Vector[0]. se sobreentiende que en su lugar irán datos en la memoria RAM. referente a las operaciones de lectura. nombre Vector[0].edad.edad Vector[.Atributo.] Vector[. Vector[N-1]. struct Nacion{ char Nombre[20].X. Vector[1].Nombre. MiPuntico. Color.].Vector[0].KilometrosCuadrados. En la memoria RAM. Pais. int edad.salario Vector[N-1].nombre Vector[N-1] Vector[N-1]...]. como pueden observar en los programas que se muestran a continuación en este y siguientes capítulos.nombre Vector[.. nombre. Se efectúa ejemplo de lectura y escritura de un registro. << "\n\nNombre: " << amigo. cin >> amigo.3 Se utiliza la estructura de datos incorporada registro del C: struct. for (i=0.++i) { cout << "Registro : " << i << "\n". } << "Digite su nombre: ". //STRUCT1. cin >> num_reg. } clrscr(). cin >> amigos[i]. cout << " Nombre : ".edad << " " << amigos[i].salario. cout cout cout cout } 17. cout << "-----------------------------------------------------\n". int edad. ++i) cout << i+1 << " " << amigos[i]. cin >> amigo.h> const int Max=20. cout <<"Cuántos amigos desea introducir? (máximo " <<Max <<") ". struct registro { char nombre[Max]. } amigo. main(){ int num_reg = 0. i<num_reg. cout << " Salario: ".salario. cout << "-----------------------------------------------------\n".nombre.edad.CPP main(){ const int Max=20. 215 . << "Digite su salario: ".nombre << " " << amigos[i].salario << endl.17. << "Digite su edad: ". #include <iostream. float salario.h> #include <conio.h> //STRUCT0. Se muestra ejemplo de utilización de vector de registros. cin >> amigos[i].edad << " años". cout << " Edad : ". #include <iostream.salario << "\nedad: " << amigo. for (i=0. i.nombre << "\nSalario: $ " << amigo. float salario.CPP struct registro { char nombre[20].i<num_reg. } amigos[Max].edad. cin >> amigo. cin >> amigos[i]. int edad.2 Se utiliza la estructura de datos incorporada registro del C: struct. H> ifstream LecturaArchivo. ESTRUCTURA DE DATOS ARCHIVO 18. Si un archivo contiene la información de un conjunto de individuos u objetos.h. en el archivo de personal de una Empresa. por ejemplo con la función open(). 216 . del archivo a incluir fstream.1 ARCHIVOS Y REGISTROS Un archivo o fichero es una estructura de datos que reside en memoria auxiliar. Adicionalmente la función open(). Cada uno de estos registros está constituido por uno o más elementos denominados campos o miembros. todas del mismo tipo y en número limitado solo por la capacidad del medio de almacenamiento. y para uno de entrada/salida se declarara una variable de la clase fstream. la cual es miembro de cada una de las tres clases señaladas antes en el párrafo anterior.Gran capacidad de almacenamiento. también denominados memorias secundarias o auxiliares. cada registro contiene la información de un empleado y los campos contienen su número de cédula. fecha de ingreso. dependiendo solo del tamaño del disco.Independencia respecto de los programas. nombre. Para uno de salida está la clase ofstream.CAPÍTULO 18. En C++ para abrir un archivo. y también que en diferentes momentos pueden utilizar el mismo archivo diferentes programas. Un registro lógico. Habiendo tres clases de flujos: de entrada. ella lo creará. //Define un buffer para operaciones de salida (out) fstream LectoEscrituraArchivo. este debe asociarse con un archivo físico (recuerde las reglas de nombres de archivo del DOS). . Por ejemplo. dirección. por ejemplo en disco duro. en caso de no existir el archivo con el cual se está asociando. //Define un buffer para operaciones de entrada (in) ofstream EscrituraArchivo. Para abrir un flujo de entrada utilizaremos. no siendo necesario crearlo expresamente. que pueden ser de diferentes tipos. El nombre será un campo y el campo clave puede ser el número de Cédula. y los campos los diferentes datos que componen a cada registro. en la sección anterior de este capítulo. como ocurre con otras familias de funciones del C o de otros lenguajes. //Define un buffer para operaciones de entrada/salida (in/out) A continuación de ser declarada una variable que maneja un flujo. se debe enlazar con un flujo(stream). consistente en un conjunto de información estructurada en unidades de acceso denominadas registros. . Las principales características que diferencian esta estructura de datos de las restantes son las siguientes: . debe inicialmente ser abierto. etc. Recordar que todo archivo para su correcto procesamiento. la clase ifstream. de salida y de entrada/salida.¡Error! Marcador no definido. individuo u objeto. sus registros contienen la información de cada uno de ellos. según ya vimos. Por ejemplo las siguientes serían declaraciones válidas para flujos(stream): #include <FStream. artículo o simplemente registro es cada una de las componentes del archivo. Significa que la vida del archivo no está limitada por la vida del programa que lo creó. como son las cintas y discos.Residencia en soportes de información externos. Para hacer desaparecer un archivo será necesario realizar explícitamente una operación de borrado. maneja dos apuntadores al inicio del archivo.close(). El valor de modo trunc hará que si existe el archivo con anterioridad. es decir al primer registro de el mismo. Para finalizar. para solo lectura. están sobre-simplificadas. El formato binario no puede ser leído fácilmente desde cualquier programa de editor. por medio del flujo EscrituraArchivo. EscrituraArchivo. todo archivo que ha sido abierto. NombreAr. variable NombreArchivo //Cierra el archivo NombreAr. por defecto. Este archivo. Por ejemplo los tres flujos definidos antes por medio de sendas variables.COD y será grabado en la trayectoria actual del disco actual. entre comillas debido a que usted aún lo podría recuperar con el comando undelete del sistema operativo DOS si no realiza ninguna otra operación sobre él. debe ser cerrado por disciplina del programador. pudiendo incluir trayectoria.COD //Cierra el archivo cuyo nombre esta en la Las explicaciones anteriores. Para efectos prácticos del usuario.open("ASCII.Ext //Cierra el archivo ASCII. para un mayor aprovechamiento de la potencia del manejo de la biblioteca de E/S del C++.close(). será irremediablemente "borrado".open("c:\directorio\NombreAr. digamos que trunc produce el borrado del correspondiente archivo físico al cual está asociado el flujo. cuyo nombre. pero tiene la ventaja de que es más compacto que el de texto.Ext. este operador es propio de la programación orientada a objetos. uno de ellos para operaciones de lectura y otro para operaciones de escritura. la cual lo pueda borrar en parte o totalmente.Al efectuarse la apertura del archivo. está almacenado en la variable de cadena NombreArchivo. y en este caso permite definir los diferentes modos que nos son posibles para la apertura de un archivo. En el segundo ejemplo se abre un archivo para solo escritura.Ext el cual está en la trayectoria c:\directorio\ del disco duro C:.open(NombreArchivo. LectoEscrituraArchivo. debe tener formato binario para poder ser realizada la operación con satisfacción. el tercer ejemplo. En el primer ejemplo se abre un archivo físico llamado NombreAr. ios::binary|ios::trunc). referirse a la bibliografía. esto se explica en las dos siguientes secciones. A continuación se puede proceder a efectuar operaciones de lectura con las instrucciones adecuadas. 217 . internamente el C++. según los siguientes ejemplos de los flujos que venimos estudiando: LecturaArchivo. este tipo de archivos puede ser leído con facilidad por cualquier editor o procesador de texto. pueden ser abiertos de la siguiente forma: LecturaArchivo.close(). empero son suficientes para el presente curso. Finalmente. A continuación y dependiendo si es un archivo de texto o binario se realizarán las operaciones de lectura y escritura correspondientes. El archivo será de formato binario. ios::binary).COD"). en formato de tipo texto. sobre esto de los punteros consultar la bibliografía o consultar con el profesor si cree necesario. El archivo se llama ASCII. LectoEscrituraArchivo. EscrituraArchivo.Ext". El operador :: es llamado el operador de resolución de ámbito. abre un archivo para lectura y escritura. >>. y de inserción. <<. ya vistos desde los dos primeros capítulos.18. y de forma enteramente similar a como se utilizan con cin >> y con cout <<.2 ARCHIVOS DE DATOS DE TEXTO Para este tipo de archivos utilizaremos los operadores de extracción. Veamos a continuación algunos ejemplos: 218 . open("MiArch. //Observe que la lectura de la cadena quedó truncada en el espacio //en blanco anterior a C++. cout << "Se leyó del disco el valor de las variables.CPP #include <iostream.h> void main(){ int n=13.ivo"). Escribir << "Entero= " << n << "\nReal= " << X << "\nCaracter= " << c << "\nCadena= " << cadena. así: \n\n". el valor de varias variables de diversos tipos de datos. } 18. cin.h> #include <fstream. float X.3 El siguiente programa graba en disco en el archivo MiArch. //ARCTXT_I.ivo"). X. cout << "Entero= " << n << "\nReal= " << X << "\nCaracter= " << c << "\nCadena= " << cadena. en formato de texto.18. Escribir. float X= 123.45e-23.4 El siguiente programa lee de disco.get(). Escribir.h> #include <fstream.get(). //ARCTXT_O. c. cadena[15]. Leer. en formato de texto. cin. Leer Leer Leer Leer >> >> >> >> n.CPP #include <iostream.h> void main(){ int n.close(). omitiéndola. cout << "Se grabó en disco el siguiente mensaje: \n\n". el valor de varias variables. Leer. char c = ' '.close(). cadena[15]={"LENGUAJE C++"}.ivo. cadena. cout << "Entero= " << n << "\nReal= " << X << "\nCaracter= " << c << "\nCadena= " << cadena.open("MiArch. } 219 . ifstream Leer. ofstream Escribir. char c. con la que trabajaremos es la siguiente y suponiendo que Archivo es una variable válida definida como un flujo: ARCHIVO. 220 . este reforzador es obligatorio colocarlo para un correcto funcionamiento. cout << endl. simplificada. las funciones miembro read() y write(). ios::out | ios::trunc). de un la cantidad de bytes especificados por el operador sizeof.read( (char *)&VariableALeer.h> #include <fstream. vía buffer.write( (char *)&VariableAEscribir. lo leído a la variable VariableALeer.close().5 Este programa escribe el código ASCII en un archivo de texto en disco y simultáneamente lo presenta en pantalla. del archivo al cual esté asociado la variable ARCHIVO. for (ascii = 32.open("ASCII. bloques de datos binarios. y en una cantidad de bytes especificados por el operador sizeof. vía buffer. debido al reforzador de tipo de puntero a caracter: (char*). // cierra el archivo } 18. if(ascii % 10 == 1){ archivo << "\n\n". //Define un buffer para operaciones de salida (out) int ascii. } } archivo. de lo contenido en la dirección(&) de la variable VariableAEscribir.CPP. utilizaremos. El archivo producido ASCII.6 ARCHIVOS DE DATOS BINARIO De entre las varias posibilidades que tiene el C/C++ para manejo de archivo binarios. ". es decir el tamaño de la variable en RAM. En el segundo se efectuará escritura. sizeof(VariableALeer) ). sizeof(VariableAEscribir) ).h> void main(void){ ofstream archivo. respectivamente. La sintaxis. ARCHIVO. La anterior asignación se efectúa byte tras byte a la dirección(&) de la variable VariableAEscribir. para este curso. En el primer ejemplo se efectuará lectura. Estas funciones permiten leer y escribir. siendo obligatorio colocar el reforzador de tipo de puntero a caracter: (char*). archivo. //ARCASCII. es el utilizado en este manual para mostrar la tabla del código ASCII en el Apéndice al final de este manual.COD". ascii++){ archivo << setw(3) << ascii << " " << (char) ascii << " cout << setw(3) << ascii << " " << (char)ascii << " ". ascii < 256. La anterior escritura se efectúa byte tras byte.CPP #include <iostream. y colocándose o mejor asignando.h> #include <conio.18.h> #include <iomanip. clrscr(). y en el primer capítulo. da_mon << " Año: " << Amigo[NumReg]. int NumReg=0. cout <<"Nombre: ". cout <<"Edad: ".Hora.Hora. struct PERSONA{ char Nombre[Completo]. cout <<"Estatura(metros): ".7 En siguiente programa le servirá de plantilla para realizar su proyecto final. typedef struct PERSONA PERSONA. cout << " HORA: " << (int) Amigo[NumReg]. en un vector.da_day << " Mes: " << (int) Amigo[NumReg].Edad. Es el programa que deberá utilizar como plantilla para poder desarrollar su proyecto final.h> #include <DOS.Dia. gettime(&Amigo[NumReg]. //VECTORST.h> #include <Graphics. observe que incluye gran mayoría del tema estudiado en todo el curso. getdate(&Amigo[NumReg]. gets(Amigo[NumReg]. struct date Dia.Dia.da_year. } 221 . cin >> Amigo[NumReg].h> #include <FStream.h> #include <String. NumReg++.Dia).h> #include <ConIO. const char *NombreArchivo = "AMIGO.h> #include <CType.ti_sec << endl. //años float Alto. en memoria RAM.Alto.Hora).CPP en todos sus detalles. //Nombre y apellido int Edad.ti_hour << ":" << (int) Amigo[NumReg].Nombre).18. Este programa maneja registros. Estudie en detalle cada uno de los algoritmos presentados.Hora.Dia.h> const int Completo=25.h> #include <ProceS.h> #include <StdIO. cin >> Amigo[NumReg]. const int Max=100.ti_min << ":" << (int) Amigo[NumReg]. el profesor en clase magistral y en el laboratorio de computadores explicará lo más relevante. //Contador para el número de registros void Captura(){ if(NumReg < Max){ cout <<"\n\nReg: " << NumReg.h> #include <IOManip. Estudie este programa VECTORST. cout << " Dia: " << (int) Amigo[NumReg]. } else cout << "Vector de registros está lleno\a\a". } Amigo[Max].PER". struct. //metros struct time Hora.CPP #include <IOStream. Amigo[i] = Amigo[j]. i++) for (j = i+1. } } else cout << "No hay registros en memoria". if(NumReg){ for (i = 0. } void EliminarRegistro(){ char Clave[Completo]="". j. Amigo[j] = aux. pos. pos = 0.Nombre.Edad > Amigo[j].Edad){ aux = Amigo[i]. if(NumReg){ cout <<"Registro Nombre Edad estatura\n". NumReg--. } } } void OrdenarRegistros(){ register int i. PERSONA aux. } } else cout << "No hay registros en memoria \a\a". j < NumReg.Clave) != 0) pos++. int i. gets(Clave). if(NumReg){ cout <<"\nDigite Nombre de Amigo a BORRAR: ". delay(1000). i < NumReg-1. for(int i=0. } 222 . i++){ cout << setiosflags(ios::right) << setw(8) << i << " " << setiosflags(ios::left) << setw(Completo) << Amigo[i]. j++) if (Amigo[i]. pos++) Amigo[pos] = Amigo[pos+1]. while(pos<NumReg && strcmp(Amigo[pos]. } else { for( .Alto << endl. i < NumReg.Edad << setiosflags(ios::right | ios::showpoint | ios::fixed) << setprecision(2) << setw(15) << Amigo[i].Nombre << setiosflags(ios::right) << setw(3) << Amigo[i].void ListarVector(){ clrscr(). pos<NumReg-1. if (pos==NumReg){ cout << "Clave no encontrada". Nombre). cin >> registro. int i=0. cout <<"\nNombre: ". while( Archivo. if (i<NumReg){ cout <<"\n\nRegistro Nombre Edad estatura\n".Edad. if(NumReg){ cout <<"\nDigite Nombre de Amigo a encontrar: ". cin >> Amigo[registro]. } 223 . clrscr(). cout <<"Edad: ". if(Archivo){ NumReg=0. } else cout <<"\n\n NO Encontrado \a".open(NombreArchivo. gets(Clave).. if (!NumReg){ cout <<"\n\nNo existen registros en memoria \a". delay(1000).Nombre << setiosflags(ios::right) << setw(2) << Amigo[i].read( (char *)&Amigo[NumReg]. } else { cout <<"\nDigite número de registro a modificar: ".Nombre) ) i++.Alto. } else cout << "No hay registros en memoria". gets(Amigo[registro].Amigo[i]. cout <<"Estatura(metros): ". } } } void LeerArchivoYCargarEnVector(){ fstream Archivo.close(). while( i<NumReg && strcmp(Clave. cin >> Amigo[registro].void EncontrarRegistro() { char Clave[Completo]="".Edad << setiosflags(ios::right | ios::showpoint | ios::fixed) << setprecision(2) << setw(7) << Amigo[i].Alto << endl. } void ModificarRegistro(){ int registro. getch(). Archivo. cout << setiosflags(ios::right) << setw(6) << i << " " << setiosflags(ios::left) << setw(Completo) << Amigo[i]. sizeof(Amigo[NumReg]) ) ) NumReg++. if( registro >= 0 && registro < NumReg) { cout <<"\nDigite nueva información para Registro: " << registro.ios::in|ios::binary). } else cout << "No se pudo abrir el archivo". Archivo. if (!Archivo) cout << "Error en la apertura del archivo \a". PERSONA registro. #define Condensado(f) f<<(char)15.write((char *)&Amigo[i]. i++){ Impresora << setiosflags(ios::right) << setw(20) << ++Linea << " << setiosflags(ios::left) << setw(25) << Amigo[i]. CancelaDobleAncho(Impresora) Condensado(Impresora) for(int i=0. void ImprimirEnPapelRegistros(){ int Linea=0. #define CPI12(f) f<<(char)0x27<<(char)0x4d. // LPT1 es igual a PRN cout << "\n\nIMPRIMIENDO. else{ for(int i=0. #define CancelaDobleAncho(f) f<<(char)27<<(char)0x57<<(char)0.. #define EspacioEntreLineas1_6pulgadas(f) f<<(char)27<<(char)0x32<<(char)2. if(NumReg==0) cout << "No hay registros en memoria \a\a". #define DobleAlto(f) f<<(char)27<<(char)0x77<<(char)1. Archivo.Alto << endl.close(). ios::out|ios::binary|ios::trunc). ios::out). Consulte el manual de su impresora en otros casos. sizeof(Amigo[i])). Archivo. Impresora.open("LPT1". i<NumReg. #define EspacioEntreLineas1_8pulgadas(f) f<<(char)27<<(char)0x30<<(char)0. i++) Archivo.Nombre << setiosflags(ios::right) << setw(15) << Amigo[i]. } CancelaCondensado(Impresora) SaltaPagina(Impresora). else{ Impresora. i<NumReg. } } " 224 .close().". DobleAncho(Impresora) Impresora <<"\n\nRegistro Nombre Edad Estatura\n\n".void GrabarVectorEnArchivo(){ fstream Archivo. #define CPI10(f) f<<(char)0x27<<(char)0x50. #define CancelaDobleAlto(f) f<<(char)27<<(char)0x77<<(char)0. fstream Impresora.open(NombreArchivo. } } //A continuación algunas macros que le servirán para cambiar el tipo de letra en impresora Epson de matriz //de punto.. #define SaltaPagina(f) f<<"\f".Edad << setiosflags(ios::right | ios::showpoint | ios::fixed) << setprecision(2) << setw(25) << Amigo[i]. #define CancelaCondensado(f) f<<(char)0x12. #define EspacioEntreLineas7_72pulgadas(f) f<<(char)27<<(char)0x31<<(char)1. #define DobleAncho(f) f<<(char)27<<(char)0x57<<(char)1. arribabar = (int)(abajo . (int)rayita). } getch(). i<NumReg.Nombre). ancho. 0). } } else{ setcolor(RED). abajo). direccion. int izquierda. abajo = getmaxy() . &ModoGrafico. Delta. izquierda += (ancho * 2). line(eje/2.Edad. float fraccion. 7. "EDADES"). rayita-=Delta) line(3. arriba=20. settextstyle(SMALL_FONT.HORIZ_DIR. profundidad.Edad / MayorEdad.(izquierda+ancho). getmaxy()). outtextxy(5. setfillstyle(SOLID_FILL. setcolor(CYAN). 2).Edad>MayorEdad) MayorEdad = Amigo[i]. tamaño ) outtextxy(izquierda+ancho/3.void Graficarbarras(){ int ManejadorGrafico = DETECT. initgraph( &ManejadorGrafico. getmaxx(). closegraph(). rectangle(0. arriba. arribabar. 0. VERT_DIR. arribabar. 1). for( i=0. abajo. abajo. setcolor(YELLOW). bar3d(izquierda. settextstyle(TRIPLEX_FONT. settextstyle(DEFAULT_FONT. MayorEdad=0. profundidad. HORIZ_DIR. setcolor(YELLOW). setcolor(RED). profundidad = (int)(ancho / 8). (int)rayita. 10. 7). Amigo[i]. rayita>=arriba-Delta.30. "c:\\tc\\bgi" ). //eje y for(float rayita=abajo.fraccion * (abajo-arriba) ).arribabar. Delta= (float)(abajo-arriba+1)/MayorEdad.Edad. outtextxy(getmaxx()/2-10. ModoGrafico. i<NumReg. abajo+10 . izquierda = ancho+eje.//(tipo letra. eje/2. eje=10. i++){ fraccion = (float) Amigo[i]. i++) if(Amigo[i]. for(int i=1. setbkcolor(BLUE). if( NumReg ){ MayorEdad=Amigo[0]. MAGENTA). } 225 . ancho = (int)( (getmaxx()-eje) / ((NumReg * 2 ) + 1) ). "NO HAY DATOS"). break.void main(){ LeerArchivoYCargarEnVector(). break. cout <<"\n\nCaptura Imprimir Ordenar eNcontrar Eliminar Modificar Graficas Borrar Salir: ". for(. case 'G': Graficarbarras(). case 'E': EliminarRegistro(). break. switch ( toupper( getch() ) ){ case 'C': Captura(). NumReg=0. break. case 'N': EncontrarRegistro(). break. break. } } } // main() 226 . case 'B': unlink(NombreArchivo).) { ListarVector(). break. return. case 'S': GrabarVectorEnArchivo(). case 'I': ImprimirEnPapelRegistros(). case 'M': ModificarRegistro(). break. case 'O': OrdenarRegistros().. Se debe utilizar un registro(struct) para conservar la información de cada empleado en memoria (No utilizar vectores) y con los siguientes campos: Nombre. por la clave Apellido. y colocarle a cada una de ellas su objetivo. leerlo e ir presentando los campos en pantalla. NOMINA: La impresora debe listar comprobantes de pago para cada uno de los empleados y la nómina mensual. 18. LISTAR: Abrir el archivo en el cual están los registros. Presentar estadísticas adecuadas con la ayuda del programa estadist. y con los colores que crea más agradables. Presentar la información adecuadamente tabulada en pantalla. donde crea necesario. Si no se encuentra la cédula debe mostrar aviso que entere de esta situación. defínalos autodocumentados. en orden ascendente. para todos los grupos. invocación de las siguientes funciones: CAPTURA: Se debe leer en esta función la información básica de cada uno de los empleados(campos). en ningún momento en clave o abreviaturas que no se entiendan rápidamente. No utilizar la librería string. porcentaje de retención en la fuente y porcentaje de retención del Seguro Social. Utilizar menú de conmutadores horizontal en el principal y verticales en los submenús. Utilizar en algunas funciones paso de parámetros por valor y por referencia. los pagos se efectúan mensualmente.1 El proyecto debe. Dejar separación adecuada entre funciones. Presentar los registros clasificados por más de una clave en pantalla y/o papel.2 Suponga va a elaborar un programa para calcular la nómina de empleados de una compañía.h. Apellidos. iterativamente.cpp. en vez de ella construir una librería que incluya las funciones para manejo de cadenas necesarias.8 ACTIVIDADES PARA RESOLVER POR GRUPOS COMO PROYECTO FINAL.8. Escribir función principal(main) la cual permita presentar en pantalla un menú y efectuar. Se debe a continuación proceder a grabarlo en disco. incluir al menos lo siguiente: Rehacer enunciado entregado de forma resumida y clara. BUSCAR: a partir de digitar la cédula de un empleado se debe proceder a la búsqueda de su registro en el archivo en disco. Utilizar operaciones de archivo tanto de lectura como de escritura. recuerde que como es cadena de caracteres debe utilizar strcmp. con los registros con los que se trabaje. 18. apellido. 227 . Solo un registro cada vez que se invoque. Presentar pulcramente el sangrado de todo el código fuente. CLASIFICAR: Se deberá efectuar un ordenamiento. Si se encuentra debe mostrarse en pantalla el nombre. Presentar logotipo adecuado al tema escogido. Presentar niveles de ayuda con la tecla F1 en varias partes del programa. y salario básico del mismo. los identificadores que utilice.8. Cédula de identidad.18. directamente sobre el disco. salario mensual básico. 3 En un juego del popular "Concéntrese". el cual permita invocar funciones que hagan lo siguiente: CAPTURAR: Leer los campos de cada registro de estudiante por teclado. es decir se debe grabar en disco el estado del juego. Digitar el nombre de un estudiante y a continuación. Pica char color. // La inicial de: Diamante. Los Cargos fijos son de $100. // del 1 al 13 char tapada. debe aparecer en pantalla toda su información sobre la matrícula. El listado debe obtener una impresión por impresora de código. Negro int numero.Digitar el código del estudiante y a continuación. y si existe. los cargos variables y el total a cancelar por concepto de matrícula. Calcular el promedio de toneladas exportadas para cada uno de los años. renta. cargos fijos. El programa debe permitir suspender la partida y poderla recuperar posteriormente en otro momento.18. LISTAR: presentar en pantalla un submenú el cual permita listar la información clasificada por las claves: código del estudiantes. y si existe. Los Cargos Variables se calculan como un 0. patrimonio. En cada registro. debe aparecer 228 . nombre. Calcular el promedio de producción de café para cada uno de los años. utilizando el modo de texto del vídeo. Corazón.1 del patrimonio + 0. tomados estos datos de la correspondiente declaración de renta de los acudientes del estudiante. BUSCAR: se debe presentar un submenú el cual permita invocar sendas funciones las cuales permitan:.4 Se tienen en unos registros los siguientes datos: Año de producción (desde 1970 a 1995). por apellido.//Si esta Tapada o si ya se Retiró del juego } Baraja[52]. cada vez la correspondiente variable global debe incrementarse en uno.8. estudiante. El programa presentará inicialmente un menú principal de conmutadores. Construir el juego del concéntrese.15% de la renta gravable. toneladas producidas de café para cada año. toneladas exportadas. para luego poder ser recuperados del mismo y de esta forma estar disponibles en cualquier momento. encontraremos al menos los siguientes campos: código del estudiante. Trébol. se tendrán 52 cartas de la baraja francesa representadas en memoria de la siguiente forma: struct carta{ char pinta. patrimonio y renta Representar globalmente el vector de registros que pueda representar la información del estudiante. apellido. valor promedio($) en el año por libra vendida en el exterior.000. cargos variable y total de matrícula.8. Calcular la cantidad a pagar de matrícula por cada estudiante de la siguiente forma: El total a pagar es igual a los cargos fijos más los cargos variables. Considerar el máximo de estudiantes que manejará el programa como una constante y una variable global que manipulará la cantidad de estudiantes inscritos para efectuar matrícula en un momento dado. Se debe calcular el valor de los cargos fijos. Para cada año calcular los dólares en exportación y efectuar un gráfico de barras. // Rojo. 18. a leer inicialmente desde teclado y posteriormente grabar en disco. el precio se incrementará $8.en pantalla toda su información sobre la matrícula.CPP. Debe utilizar adecuadas operaciones de archivo. ESTADÍSTICA: Presente submenú con las cuatro opciones siguientes: presentar estadísticas sobre los ingresos mensuales y sobre el pago de renta y el número de hijos. título de la obra. LISTADOS: En submenús presente listados clasificados por salario. PRECIO UNITARIO: A partir de digitar el código de un libro. del inventario de libros. si el número de páginas excede de 550. nombre completo del autor. CAPTURA: leer los campos Cédula jefe de hogar. si el número de páginas excede de 300. Una editorial tiene un conjunto de registros para cada uno de los títulos de libros existentes. para finalmente asignar a campo de edad promedio su respectivo valor. cuántos mayores o igual al mínimo y menores a tres salarios mínimos y cuántos tienen ingresos inferiores al mínimo. más 35 pesos por página. Digitar un valor de renta y mostrar todos los registros que cumplen con que la de ellos en mayo o igual. 229 . efectuar su búsqueda y mostrar su precio teniendo en cuanta lo siguiente: El precio básico de un libro es de $2. a partir de una cédula mostrar los datos de la correspondiente persona. número de páginas. el precio sufrirá un recargo adicional de $10.8. acumularlas. y esto debido al mayor costo de la compaginación y empastado. empero. TOTAL MATRICULA: submenú que permita presentar en pantalla o escrito en papel. Se debe permitir tener la opción de escoger varios tipos de letra para imprimir en papel. se les pregunta a cada uno ¿Cuál es su ingreso mensual? ¿Cuál es la renta que paga por su casa de habitación?. cada uno de los cuales contiene: código del libro. LISTAR: Por medio de un submenú mostrar en pantalla o en papel lo siguiente. clasificados por el código del libro.5 En una encuesta de un indeterminado número de jefes de hogar. y cuarta opción que permita calcular y mostrar el salario promedio por hogar. Calcular e imprimir el código y el precio para cada uno de los libros. Imprimir el total. ESTADÍSTICA: presentar estadísticas de el total de matrícula. Mostrar también clasificado por título. renta. salario. en pesos. Presentar algoritmo pulcramente con sangrado adecuado en lenguaje C++. renta. Mostrar el mismo inventario de libros clasificados por autor. totalizando al final. 18. Efectuar funciones que permitan: CAPTURAR: la captura de estos registros y mantenerlos en memoria en un vector de registros. dividiendo la sumatoria de los ingresos mensuales entre el número de jefes de hogar. existencia en bodega de cada título.000. número de hijos y efectuando ciclo repetitivo capturar la edad de cada uno de sus hijos. con la ayuda del programa ESTADIST. Digitar un apellido o nombre y a continuación presentar todos los nombres completos de estudiantes que lo contengan. BUSCAR: Submenús que permitan encontrar los ciudadanos que están en cada uno de los rangos de salario mínimo señalados anteriormente. Se debe calcular cúantos hogares tienen ingresos superiores a tres salarios mínimos. promedio de hijos y cédula de identificación. Presentar listado de el total de matrículas. y por esto le entregó unos registros con los siguientes datos.CPP 18. Permitir la impresión en cada oportunidad en papel.Código del artículo (clave). en unidades. código y número de plan. Mostrar el total del inventario representado en pesos($). BUSCAR: Se digita un código y a continuación se muestra la nota de el estudiante correspondiente. LISTAR: Debe producir un informe de los artículos que hay que comprar de acuerdo a las siguientes condiciones: .Listado de artículos con existencia superior a un 50% de la existencia mínima. en matemática.8.Existencia mínima en unidades..Listado de artículos sin existencia en inventario. Digitar un valor de libro y listar a continuación todos los libros que tienen igual o mayor precio.(Cantidad de reorden). por plan y en total. como clave secundaria. ESTADÍSTICA: presente estadísticas de las calificaciones de matemática. Cantidad en pesos($) del total de artículos a comprar. los cuales debe capturar por teclado y posteriormente mantener en disco:. Desea saber también el número total de estudiantes y el número de estudiantes reprobados. con la ayuda del programa ESTADIST. GRABAR Y CARGAR: Todos los registros deben estar en disco.BUSCAR: Por medio de submenús conteste cada uno de los siguientes interrogantes: Se debe digitar un código de libro y si existe en el inventario decir su precio.6 Una compañía le encarga un informe para comprar mercancía. información clasificada por plan de estudios. Escoja al gusto si prefiere ordenes descendentes o ascendentes. LISTAR y CLASIFICAR: Listar por medio de submenús. con la ayuda del programa ESTADIST. 230 .. titulo y autor.Valor unitario.Existencia actual en inventario.. CLASIFICAR: Por medio de submenús clasificar por: código. de todos los estudiantes que cursaron matemática.Listado de artículos con existencia menor a la existencia mínima.6 Cierta Universidad está interesada en saber estadísticamente la calificación promedio de los estudiantes que recibieron matemática durante un semestre. CAPTURAR: Calcular lo anterior teniendo en cuenta que se leen: la calificación definitiva de matemáticas. ESTADÍSTICA: presente estadísticas de el valor de los libros..Nombre del artículo. valor de cada libro. Digitar un título de un libro y a continuación decir cuantos ejemplares de ese título hay en existencia en el momento. Se digita un plan de estudios y a continuación se muestran todos los estudiantes que corresponden a ese plan y su promedio de nota en matemática. La información de los registros debe permanentemente estar clasificada por el número del código de cada uno de los estudiantes.. y dentro de cada plan de estudios listar clasificado por código de cada estudiante. Digitar una palabra y mostrar en pantalla todos los títulos que la contengan.8. Digitar un apellido o nombre y a continuación presentar todos los nombres completos de autores que lo contengan.CPP 18. Digitar el nombre de un autor y a continuación mostrar todos los libros que le pertenezcan de entre el inventario. y con la ayuda del programa ESTADIST. Velocidad del vehículo infractor. Mantener clasificado por la clave Código de artículo. si es que existe. Presentar tanto en papel como en pantalla. Digitar una palabra y a continuación mostrar todos los nombres de productos que la contienen. Clasificar por medio de la clave nombre de el artículo. si es que existe.000 adicionales. Se deben tener en disco actualizados los registros. con la ayuda del programa ESTADIST. Digitar un número de factura y mostrar toda la información disponible y por calcular de la misma.CPP 18. así: Límite de velocidad de 60 kph en avenidas. ESTADÍSTICA: presente estadísticas de el existencias multiplicadas por el valor unitario de cada artículo. Digitar el nombre de un cliente y a continuación mostrar todas las facturas que tiene pendientes de pago. nombre del cliente. Digitar un nombre de artículo y contestar con su cantidad en inventario. si el plazo esta entre 30 y entre 60 y 120 días se liquida un liquida un 3%. CLASIFICAR: Por medio de submenús.7 Se debe elaborar un informe de cartera con base a una serie de registros con los datos de: código. si el plazo está 2. y los cuales hay que capturar por teclado. y mantener adecuadamente actualizados en disco. BUSCAR: Utilizar submenús para contestar lo siguiente: Se debe elaborar un informe a nivel de plazo es hasta de 30 días se liquida 1% de 60 días se liquida un 2%.8. Se desea saber cuántos autos han sobrepasado cada límite en un determinado tiempo de muestreo y cuánto pagan de multa en total.000 adicionales.000 adicionales. LISTAR: Utilizando submenú listar en pantalla adecuadamente y por impresora en papel utilizando diversas claves de ordenamiento. CAPTURAR: Se deben leer los siguientes campos por cada registro de vehículo infractor: Placa del carro. Número de factura. Por cada kilómetro de exceso se le cobran $4.8.8 La Secretaría de Tránsito decidió cobrar multas por exceso del límite de velocidad así: Una cantidad de dinero llamada "Multa básica" más la multiplicación del número de kph en exceso sobre el límite de velocidad por un factor dado en la siguiente tabla de tarifas. valor original de la factura.BUSCAR: por medio de submenús contestar lo siguiente: Digitar un código de artículo y mostrar la información correspondiente a él. El límite de velocidad en autopista es de 80 kph. Por cada kilómetro de exceso se le cobran $3. plazo del crédito para cancelar la obligación. ESTADÍSTICA: presente estadísticas de el total de las facturas.5%. El límite de velocidad en calles es de 40 kph. y para plazos mayores de 120 días se cliente teniendo en cuenta que si el interés. Por cada kilómetro de exceso se le cobran $2. y clasificada por el número de placa. tipo de vía. 231 . LISTAR: Presentar por medio de submenú las multas de todos los infractores. con el plazo correspondiente en días.CPP 18. Se deben capturar los anteriores datos y mantenerlos tanto en RAM como en disco. valor prestamos. CLASIFICAR: utilizando submenú presente listados clasificados por edad. sexo y de facultad. nombre cliente.día del préstamo)/360. Comercio). Digitar un nombre o apellido y mostrar en pantalla todos los nombres completos de clientes que lo contienen. Digitar cédula y de igual forma aparecer en pantalla toda la información del cliente correspondiente. Digitar dos edades y a continuación mostrar todos los registros que están en el correspondiente intervalo de edades. con la ayuda del programa ESTADIST. CLASIFICAR: utilizando submenús mostrar en pantalla clasificaciones ascendentes y descendentes por las claves: cédula. con la ayuda del programa ESTADIST. Digitar un sexo y mostrar todos los registros que coinciden con él. y Facultad (Psicología.CPP 18.CPP 232 . Tasa de interés convenida en %.10 Se requiere condensar algunas estadísticas sobre los estudiantes de la Universidad. LISTAR: Se debe calcular e imprimir en pantalla y en papel: Promedio de edad de los estudiantes. Digitar un nombre de facultad y a continuación digitar todos los registros que la contengan. los cuales deben capturar y mantener almacenados en disco. Ingeniería. Valor del préstamo. BUSCAR: Por medio de submenú mostrar lo siguiente: Digitando un nombre de cliente debe aparecer el registro correspondiente con la cantidad de intereses a cancelar.CPP 18. Este listado debe aparecer clasificado por la clave Cédula. CLASIFICAR: Presentar listados en pantalla y en papel clasificados por tipo de vía. Para el cálculo de los intereses a cancelar al final del año se aplica la siguiente fórmula: Valor intereses es igual al valor préstamo * (interés/100) * (360 .BUSCAR: Por medio de submenú. Femenino). en forma ascendente y descendente. y de velocidad de infracción. Digitar un real que representará kph y a continuación mostrar todos los registros que tengan infracción por este kilometraje y mayor. ESTADÍSTICA: presente estadísticas de el total de intereses a cancelar. ESTADÍSTICA: presente estadísticas respecto a la edades.8. Se debe imprimir el valor del interés pagado por cada cliente y el total para todos ellos.8.9 Un banco quiere calcular los intereses que tiene que cobrar al final del año a sus clientes con base a los datos de: Cédula y Nombre del cliente. si es que existe. Edad. porcentaje de hombres y mujeres por cada facultad y en la Universidad. Sexo(Masculino. Mantener clasificado por Código de estudiante. número del día del año en que fue hecho el préstamo(del 1 al 365). Digitar un tipo de vía y mostrar a continuación todos los registros de multa que coincida con él. tasas de interés. con la ayuda del programa ESTADIST. placa de carro. si es que existe. ESTADÍSTICA: presente estadísticas de el total de multas cobradas. Digitar un número de placa y mostrar en pantalla el registro de multa correspondiente. Para cada registro se tiene: Código. BUSCAR: Digitar un código y a continuación debe aparecer el registro correspondiente de es estudiante. y finalmente igual para el código de artículo. situación laboral (trabaja.CPP 18. Digitar dos enteros que representarán meses y a continuación mostrar todos los registros que están en el correspondiente intervalo de meses.8. con la ayuda del programa ESTADIST. ESTADÍSTICA: presente estadísticas de el total pagado a cada empleado. cuando el saldo actual sea inferior al stock mínimo y un aviso de "alerta" cuando el saldo varíe en un 40% por encima del stock mínimo. código del departamento. edad. de tres a cinco años. Se desea saber si los nuevos empleados(menos de un año) tienden a trabajar más horas extras que los antiguos. su total está dado por el saldo anterior más las entradas. edad. los cuales se debe capturar por teclado y mantener adicionalmente en disco. cantidad en dinero a cancelar por hora trabajada. código del artículo. Facultad. Lo mismo para el código del departamento. los cuales debe capturar y mantener en disco. incluyendo la cantidad total que hay que cancelar a este empleado. Se tienen registros con datos de la ciudad. con la ayuda del programa ESTADIST. civil(casado. CLASIFICAR: Mostrar en pantalla clasificado por cédula de identidad. no trabaja). salidas. LISTAR: Se debe imprimir un informe en donde se muestre por cada registro el valor y cantidad del saldo actual con su stock mínimo y un aviso de "Compra". Universidad. de almacén y de artículo en forma ascendente y descendente. Se desea saber qué cantidad de empleados tienen menos de un año en la compañía.18. Digitar dos edades y a continuación mostrar todos los registros que están en el correspondiente intervalo de edades. CLASIFICAR: Por las claves código de departamento. relación los estado estos 233 . edad.11 La Compañía AXZ tiene un registro por cada empleado con: Cédula de identificación. Mantener clasificado por el número de cédula al mostrar lo anterior. teniendo en cuenta que para cada ítem de inventario.8.8. Se digita cédula y de debe mostrar el registro correspondiente si es que existe. LISTAR: Por medio de submenú. BUSCAR: digite un código de almacén y a continuación mostrar todos los registros que lo contengan. horas regulares trabajadas. soltero). ESTADÍSTICA: presente estadísticas de el valor de las mercancías en inventario. meses de antigüedad en la compañía en ordenes ascendentes y descendentes.12 En un almacén de cadena se tienen unos registros de inventario con los siguientes datos: código del almacén. saldo anterior.CPP 18. de uno a menos de tres años. multiplicado por el costo unitario. menos las salidas y. BUSCAR: Utilizando submenú.13 Una asociación de universidades está interesada en elaborar una de estudiantes que sean casados y que trabajen. nombre del estudiante. Deben darse totales de los valores por cada departamento de almacén. este guarismo resultante. horas extras(se cancela 50 adicional sobre el valor regular). stock mínimo y costo unitario. campos que deben ser capturados y mantenidos en disco. Mostrar la cantidad a cancelar a cada uno de los empleados. entradas. Por cada grupo se desea saber el promedio de horas trabajadas por empleado. de cinco a diez años y más de diez años. por cada almacén y para toda la cadena. meses trabajados en la compañía. y Facultad como tercera clave. BUSCAR: Digitar nombre de estudiante y a continuación mostrar los correspondientes campos del registro correspondiente. Ocupada) Representar globalmente el vector de registros y variable que cuente las reservas efectuadas. edad. producir un listado con la siguiente estadística: 234 . En caso de haber disponibilidad se le asigna el número de silla marcando como "Reservada" en el campo "Estado de la silla". Digitar nombre de ciudad y a continuación mostrar todos los registros correspondiente. A continuación. habrá un número prefijado de sillas. De esta forma el número de reservas aumentará en una cada vez que sea invocada esta función. enlazada. De esta forma el número de reservas se decrementará en una. Cada registro en la lista representa una silla. CLASIFICAR: Mostrar listados por separado clasificados por edad. y otro por apellido. ESTADÍSTICA: presente estadísticas de edades de los estudiantes de las universidades. el cual permita invocar funciones que hagan lo siguiente: RESERVAR CUPO: En caso de estar llenos los cupos que aparezca el aviso "CUPO COMPLETO. estado civil y situación laboral. POR FAVOR CIERRE EL VUELO". Universidad como segunda clave.LISTAR: Debe presentarse un listado clasificado por Ciudad como primera clave. y otra opción que permita imprimir en papel. 18. presentar un menú principal de conmutadores. Digitar nombre de universidad y mostrar a continuación todos los registros de estudiantes que la contienen. cédula. Cada registro debe tener al menos los siguientes campos: Nombre pasajero. con la ayuda del programa ESTADIST.14 PROGRAMA PARA UNA LÍNEA AÉREA: Una línea aérea desea controlar las reservas de vuelo de un avión. Representar en memoria por medio de un vector de registros. CERRAR EL VUELO(y terminar el programa): Cuando el avión vaya a despegar. LISTAR: presentar en pantalla un submenú el cual permita listar la información clasificada por: cédula.8. Reservada. teléfono. CANCELAR RESERVA: Se pide al pasajero el número de silla que tiene reservada. El número de cupos disponible para el vuelo es de MAX sillas. estado de la silla(Vacía. Al iniciar el programa debe inicializar los campos que corresponden al estado de la silla con vacío (podría ser un cero o una letra V). para lo cual los datos deben mantenerse clasificados de esta forma en memoria RAM. CONFIRMAR RESERVA: Cuando el pasajero se presenta al aeropuerto se le debe solicitar el número de silla(se supondrá que se la sabe) y marcarla como "ocupada".CPP. y se debe dejar marcada como "vacía" en el campo "Estado de la Silla" correspondiente. a) Números de sillas ocupadas y sillas vacías (las vacías son las marcadas como "vacías" más las reservadas que no viajó nadie en ellas). con la ayuda del programa ESTADIST. con su respectivo teléfono y cédula.CPP. c) Estadísticas de las edades de los pasajeros. b) Listado de todos los nombres de pasajeros clasificados en orden alfabético. 235 . . fruta2).APÉNDICE A. printf( "┌───────────────────────────────────────────────┐\n"). " %-10s %8d %15. c3. &c2). c2*p2). printf( printf( printf( printf( printf( printf( printf( "\n\n┌───────────────────────────────────────────────┐\n"). hasta el momento. scanf("%f".2f\n". p2. p3=4. c2. " %-10s %8d %15.2. printf( "\ndigite el precio(con centavos) de la fruta 2: $ ").2f\n". las cuales son reemplazadas. // precios de cada fruta char fruta1[10]="lulo".2f %10. con gran ventaja como ya vimos.2f %10. fruta3[10]="papaya". "│NOMBRE CANTIDAD PRECIO TOTAL │\n").C*/ #include <stdio.CPP. son scanf y printf respectivamente.2f %10. printf( "\ndigite la cantidad a comprar de la fruta 2: "). C_7. return 0. scanf("%d". } 237 . printf( "│ MERCADO DE FRUTAS │\n"). p1. p2. "────────────────────────────────────────────────\n\n"). LAS TRADICIONALES PRINTF Y SCANF DEL “VIEJO C” Las instrucciones de lectura y escritura más utilizadas en el lenguaje C. c3=20. fruta1. c1*p1). printf( "└───────────────────────────────────────────────┘\n"). // nombres clrscr(). en el Capítulo 2. fruta2[10]="".2f\n". c3*p3). A. " %-10s %8d %15. Así mismo presenta una introducción al formateo de números.h> #include <conio. c2. Ver programa COUTIN06. "└───────────────────────────────────────────────┘\n").1 El siguiente programa muestra la utilización de las instrucciones de lectura scanf y de escritura printf. por el cout y el cin en el C++. fruta3.h> main(){ int c1=10.5. el cual realiza lo mismo con las instrucciones cin >> y cout <<. fruta2. p3. // cantidades de cada fruta float p1=3. getch(). scanf("%s". &p2). printf( "Digite el nombre de la fruta 2: "). c1. j < n . n. s15). } printf("\n\nLA SUMA DE LOS %d PRIMEROS MÚLTIPLOS DE 11 ES :%d". } printf("\n\nLA SUMA DE LOS %d PRIMEROS MÚLTIPLOS DE 15 ES :%d". n. s15 += M_15. -i). i < n.2 SE ESCRIBEN LOS N PRIMEROS MÚLTIPLOS DE 11 Y 15 /*C_1. s11=0. i=1.&n). i.4).3 Se calcula la siguiente serie: S = 1 + 2 + 3 . &n).C*/ main(){ int n..A. scanf ("%d". i <= n . scanf("%d". suma=0. suma -= i.4 + 5 + 6 + 7 . j. } 238 . for( . printf("%5d". getch(). i). printf("%4d". gotoxy(1. } } printf("\n\nSumatoria = %d". j++ ){ M_15 = j * 15. M_15. getch(). clrscr(). printf ("%4d". s11).. printf("\n\n"). s15=0. printf ("Valor de n:"). M11.C*/ main(){ int n. printf("DIGITE UN VALOR PARA N:"). suma). i++){ M11 = i * 11. clrscr(). } A. i++){ if ( i % 4 == 0 ){ printf("%5d". /*C_3.8 +. s11 += M11. for (j = 1. M_15). printf("\n\n"). } else { suma += i. M11). for (i = 1. scanf("%c". } C_4. contador++) printf(". &Sexo). i < x.h> main(){ int Edad. } getch(). suma).4 Efectúe prueba de ejecución manual al siguiente algoritmo. printf("introducir un número: "). EstadoCivil = toupper(EstadoCivil). printf ("la suma del 0 al %2d es %4d\n". EstadoCivil. char Sexo. printf("Sexo (M/F): ").C*/ #include <stdio. fflush(stdin). scanf("%d". Otro): ").5 Se desarrolla un algoritmo el cual lee desde teclado los datos de una persona los cuales vienen en tarjetas: nombre. Sexo = toupper(Sexo). i++) { suma += i. printf("Digite el nombre del encuestado: "). &t). /* main(){ int t. } total(int x){ int suma = 0. scanf("%d". gets(Nombre). } A. &EstadoCivil). edad. char Nombre[20]. fflush(stdin). contador < 10. printf("Edad: "). for( i = 0. clrscr(). clrscr(). for(contador = 0 .A. Nombre). if ( ( Sexo=='M' && Edad<30 ) || ( Sexo=='F' && Edad<50 ) ) printf( "\n % s Cumple una de las condiciones". printf("Estado Civil (Casado. i. else printf( "\n\aNo cumple ninguna de las condiciones solicitadas"). fflush(stdin). total(t). i. sexo y estado civil.").C */ 239 . contador. fflush(stdin). Soltero. /* C_5. se imprime el nombre solo si corresponde a un hombre casado menor de 30 años o a una mujer soltera menor de 50 años. &Edad). scanf("%c". printf("-----------------------------------------\n"). *va = *vb. indice < Max. indice + 1). i. ++indice) printf("%30d%10d\n". printf("-----------------------------------------\n"). b[indice]). b[indice]). printf("-----------------------------------------\n"). } 240 . &b[indice]). for(indice = 0. b). clrscr(). Max). a[indice]. indice < Max. indice + 1). vb++. ++indice) printf("%30d%10d\n". indice < Max.6 Se digitan los valores de dos vectores del mismo tamaño y luego se produce su intercambio por medio de punteros. indice++){ printf("A[%2d] = ". printf("-----------------------------------------\n\n"). printf("Vectores originales A B \n"). scanf("%d". for(indice = 0. register int indice.*/ #define Max 10 intercambio(int *va. } clrscr(). b[Max]. for(indice = 0. int *vb){ int auxiliar. &a[indice]). auxiliar = *va. indice < Max. a[indice]. } } main(){ int a[Max]. for(indice = 0. Max). indice++){ printf("B[%2d] = ". scanf("%d". va++. printf("Vectores intercambiados A B \n"). /*PUNTERO2.A. while (i<Max) { i++. getch(). } printf("\n\nDigite %d valores para el vector B: \n". printf("Digite %d valores para el vector A: \n". intercambio(a. *vb = auxiliar. para ver qué quedó en la variable c: cout << " la variable c tiene el valor de " << c. por ejemplo al pulsar simultáneamente las teclas ALT y M se produce un código 0 el cual es leído inicialmente y el siguiente código 50 es dejado en el buffer de memoria del teclado. se presentará el valor de 0. supongamos el usuario hasta aquí digita ALT M. Para leer el código siguiente o código extendido: 241 . Las combinaciones de teclas las cuales tienen un 0 en primer lugar en realidad producen dos códigos los cuales deben ser leídos adecuadamente. veámoslo con un pequeño fragmento en C: cout << "digite Combinación de teclas: ". es decir ocho bit. 8 B L V ` j t ~ ê Æ £ ª ░ ║ ─ ╬ ╪ 37 47 57 67 77 87 97 107 117 127 137 147 157 167 177 187 197 207 217 227 237 247 % / 9 C M W a k u ë ô ¥ º ▒ ╗ ┼ ╧ ┘ 38 48 58 68 78 88 98 108 118 128 138 148 158 168 178 188 198 208 218 228 238 248 & 0 : D N X b l v Ç è ö _ ¿ ▓ ╝ ╞ ╨ ┌ 39 49 59 69 79 89 99 109 119 129 139 149 159 169 179 189 199 209 219 229 239 249 ' 1 . sino es leído con otra instrucción de lectura. 54 6 64 @ 74 J 84 T 94 ^ 104 h 114 r 124 | 134 å 144 É 154 Ü 164 ñ 174 « 184 ╕ 194 ┬ 204 ╠ 214 ╓ 224 234 244 254 35 45 55 65 75 85 95 105 115 125 135 145 155 165 175 185 195 205 215 225 235 245 255 # 7 A K U _ i s } ç æ ¢ Ñ » ╣ ├ ═ ╫ ß 36 46 56 66 76 86 96 106 116 126 136 146 156 166 176 186 196 206 216 226 236 246 $ . Ocupa cada uno de ellos un Byte de memoria. numerados del 0 al 255. él 50 se perderá. Se compone de un conjunto de caracteres de control. c = getch().APÉNDICE B. CÓDIGO ASCII Y SECUENCIAS DE ESC El código ASCII(American Standard Committed for Information Interchange). y caracteres imprimibles. Tabla de Caracteres ASCII imprimibles. es el código con el cual operan los microcomputadores que trabajan bajo el sistema operativo MS-DOS y Windows. 32 42 * 52 4 62 > 72 H 82 R 92 \ 102 f 112 p 122 z 132 ä 142 Ä 152 _ 162 ó 172 ¼ 182 ╢ 192 └ 202 ╩ 212 ╘ 222 ▐ 232 242 252 _ 33 43 53 63 73 83 93 103 113 123 133 143 153 163 173 183 193 203 213 223 233 243 253 ! + 5 ? I S ] g q { à Å Ö ú ¡ ╖ ┴ ╦ ╒ ▀ 34 " 44 . E O Y c m w ü ï ò _ │ ╜ ╟ ╤ █ 40 50 60 70 80 90 100 110 120 130 140 150 160 170 180 190 200 210 220 230 240 250 ( 2 < F P Z d n x é î û á ┤ ╛ ╚ ╥ ▄ 41 51 61 71 81 91 101 111 121 131 141 151 161 171 181 191 201 211 221 231 241 251 ) 3 = G Q [ e o y â ì ù í ½ ╡ ┐ ╔ ╙ ▌ ± ² A continuación se presentan los códigos de exploración de varias teclas y combinación de teclas. se coloca el reforzador de tipo. (int).c = getch(). cout << " el código extendido es " << (int) c. para evitar que nos escriba en pantalla el ASCII correspondiente al 50 Teclas que producen códigos extendidos al digitarlas solas: ╔══════════════════╤═══════════════╗ ║HOME │0 71 ║ ║FLECHA ARRIBA │0 72 ║ ║PAGE UP │0 73 ║ ║FLECHA IZQUIERDA │0 75 ║ ║FLECHA DERECHA │0 77 ║ ║END │0 79 ║ ║FLECHA ABAJO │0 80 ║ ║PAGE DOWN │0 81 ║ ║INSERT │0 82 ║ ║DELET │0 83 ║ ║F1 al F10 │0 59 al 0 68 ║ ║F11 │0 133 ║ ║F12 │0 134 ║ ╚══════════════════╧═══════════════╝ Códigos extendidos de teclas al pulsarlas simultáneamente con la tecla de cambio SHIFT: ╔══════════════════════╤═════════════════╗ ║ SHIFT A a la Z │ 65 al 90 ║ ║ F1 al F10 │ 0 84 al 0 93 ║ ║ F11 │ 0 135 ║ ║ F12 │ 0 136 ║ ╚══════════════════════╧═════════════════╝ 242 . F10 IZQUIERDA DERECHA END PAGE DOWN HOME PAGE UP F11 F12 ARRIBA + ABAJO INSERT DELETE / * 1 .. 0 103 0 0 0 0 0 115 116 117 118 119 ALT ESC RETROCESO Q W E R T Y U I O P ENTER A S D F G H J K L ... / F1..F10 1 2 3 4 5 6 7 8 9 0 = F11 F12 HOME FLECHA ARRIBA PAGE UP FLECHA IZQUIERDA FLECHA DERECHA END FLECHA ABAJO PAGE DOWN INSERT DELETE TAB ENTER 0 0 0 0 50 51 52 53 0 104-113 0 0 0 0 0 0 0 0 0 0 0 0 0 0 120 121 122 123 124 125 126 127 128 129 130 131 139 140 0 132 0 137 0 138 0 141 0 142 0 0 0 0 144 145 146 147 0 151 0 152 0 153 0 155 0 157 0 0 0 0 0 159 160 161 162 163 0 149 0 150 0 165 0 166 243 ..CTRL A .. . 25 0 94 .. ' ` \ Z X C V B N 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 16 17 18 19 20 21 22 23 24 25 28 30 31 32 33 34 35 36 37 38 39 40 41 43 44 45 46 47 48 49 ALT M . Y F1 ...A continuación los códigos extendidos de teclas al ser pulsadas simultáneamente con las teclas CTRL y ALT respectivamente: ¡Error! Marcador no definido..
Copyright © 2024 DOKUMEN.SITE Inc.