1

IINNTTRROODDUUCCCCIIÓÓNN AA LLOOSS

AALLGGOORRIITTMMOOSS EENN

LLEENNGGUUAAJJEE CC//CC++++

HHUUMMBBEERRTTOO MMAAZZUUEERRAA PPÁÁRRRRAAGGAA hhmmaazzuueerraa@@ccuuaaoo..eedduu..ccoo

wwwwww..ggeeoocciittiieess..ccoomm//hhuummbbeerrttoommaazzuueerraa

"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

CCAALLII,, ffeebbrreerroo DDEEll 22000011

2

TTAABBLLAA DDEE CCOONNTTEENNIIDDOO ¡¡EErrrroorr!! MMaarrccaaddoorr nnoo ddeeffiinniiddoo..

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

3

CAPÍTULO 1

CCOOMMPPOONNEENNTTEESS DDEE LLOOSS PPRROOGGRRAAMMAASS EENN CC++++ 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++.

4

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 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 26 27 28 _ 29 30 31 32 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 128 Ç 129 ü 130 é 131 â 132 ä 133 à 134 å 135 ç 136 ê 137 ë 138 è 139 ï 140 î 141 ì 142 Ä 143 Å 144 É 145 æ 146 Æ 147 ô 148 ö 149 ò 150 û 151 ù 152 _ 153 Ö 154 Ü 155 ¢ 156 £ 157 ¥ 158 _ 159 160 á 161 í 162 ó 163 ú 164 ñ 165 Ñ 166 ª 167 º 168 ¿ 169 _ 170 171 ½ 172 ¼ 173 ¡ 174 « 175 » 176 ░ 177 ▒ 178 ▓ 179 │ 180 ┤ 181 ╡ 182 ╢ 183 ╖ 184 ╕ 185 ╣ 186 ║ 187 ╗ 188 ╝ 189 ╜ 190 ╛ 191 ┐ 192 └ 193 ┴ 194 ┬ 195 ├ 196 ─ 197 ┼ 198 ╞ 199 ╟ 200 ╚ 201 ╔ 202 ╩ 203 ╦ 204 ╠ 205 ═ 206 ╬ 207 ╧ 208 ╨ 209 ╤ 210 ╥ 211 ╙ 212 ╘ 213 ╒ 214 ╓ 215 ╫ 216 ╪ 217 ┘ 218 ┌ 219 █ 220 ▄ 221 ▌ 222 ▐ 223 ▀ 224 225 ß 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 ± 242 243 244 245 246 247 248 249 250 251 252 _ 253 ² 254 255

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.

5

Tabla 1.2 Las 32 palabras reservadas del C.

auto break case* char* const* continue default do*

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.

Tabla 1.3 Las palabras reservadas ampliadas del C++

asm catch clas delete friend

inline new operator overload private

protected public template this throw

try virtual

NOTA: Ninguno de estos identificadores se utilizará en este curso. Solo debe tener la precaución, cuando defina un identificador, el de no utilizar ninguna de las palabras reservadas de las Tablas 1.2 y 1.3

1.7 LIBRERÍAS Para optimizar el código producido, los lenguajes en general y como parte de la máxima "Divide y Vencerás", colocan una serie de utilidades(funciones, tipos de datos, variables, etc.) en archivos separados, los cuales de pueden utilizar como si estuvieran en el programa que estamos diseñando. El C/C++ en particular trae una gran cantidad de archivos a incluir por medio de la directiva del compilador #include, la cual debe ser colocada preferiblemente al inicio del programa y siempre por fuera del ámbito de las funciones. Los archivos a incluir en el turbo C++ los puede encontrar en el nivel de ayuda del editor. Los siguientes serán los utilizados en el presente manual, y con esta sintaxis: #include <iostream.h> #include <conio.h> #include <string.h> #include <iomanip.h> #include <dos.h> #include <stdlib.h> #include <stdio.h> #include <math.h> #include <values.h> #include <ctype.h> #include <graphics.h> #include <fstream.h> 1.8 SEPARADORES DE INSTRUCCIONES Cada lenguaje utiliza alguna convención para separar las diferentes instrucciones del mismo; en el lenguaje C el separador es el símbolo de punto y coma ;. Se debe colocar el punto y coma al final de cada instrucción (statement). En C/C++ el punto y coma marca el fin de una instrucción, es decir es su terminador. Se exceptúan las instrucciones del preprocesador (define, include, etc.), las cuales no llevan punto y coma al final. En tiempo de compilación el "compilador" revisará la sintaxis de las diferentes instrucciones y en caso de encontrar alguna con terminador inadecuado, esto es sin punto y coma, dará un error de sintaxis: " ; expected", es decir que

6

esperaba un punto y coma y encontró otro caracter, en general este otro caracter lo encuentra en la instrucción siguiente, donde marcará el error y confundiendo al recién iniciado. Observe los punto y comas en los programas presentados en este capítulo. 1.9 COMENTARIOS En todo lenguaje hay la posibilidad de colocar comentarios, estos son líneas en el código fuente adicionales al algoritmo propio del programa; estos comentarios no se tendrán en cuenta en el momento en que el compilador produzca el código objeto(archivo *.obj), es decir no ocuparán espacio en él. Es buena práctica de programación colocar abundantes comentarios, y de esta forma guardar el programa adecuadamente documentado. En el lenguaje C se utilizan los caracteres /* y */ para el inicio y la terminación de comentarios, estos pueden ocupar una o tantas líneas como se desee, ejemplo: /* <---- aquí comienzan mis comentarios en esta línea también siguen .... aquí terminan los comentarios ----> */ Adicionalmente en C++ existe el comentario de línea, o más exactamente desde la columna donde se coloque hasta el fin de línea, este comentario inicia con una doble barra inclinada //, ejemplo: // este es un comentario de una sola línea. // este es otro comentario // etc. 1.10 OPERACIONES DE ENTRADA/SALIDA Un programa para que pueda trabajar, entre otras cosas, 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. 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.

Figura 1.1 instrucciones básicas de entrada/salida en C++.

┌─────────────────────┐ ┌────────────┐ │ ┌──────────────────┐│ │ PC │ │ │ PANTALLA ││ │ │ │ │ ││ cout << │ ┌───────┐ │ │ │ │├<<────────────────────────────┤ │ │ │ │ └──────────────────┘│ Inserción en Flujo de salida │ │MEMORIA│ │ └─────────────────────┘ │ │ RAM │ │ ┌───────────────────────────┐ │ │ │ │ │ ▄ ▄ ▄ TECLADO ▄ ▄ ▄ ▄ │ cin >> │ │ │ │ │ ▄▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ├─────────────────────────>>┤ │ │ │ │ ▄▄ ▄▄▄ ▄▄▄▄▄▄▄▄ ▄▄ ▄ ▄▄▄ │ Extracción en Flujo │ └───────┘ │ └───────────────────────────┘ de entrada └────────────┘

7

1.11 INSTRUCCIÓN DE ESCRITURA EN PANTALLA Para transferir valores de constantes, variables, expresiones algebraicas, o expresiones delimitadas como cadenas de caracteres de la memoria del computador a la pantalla, emplearemos la instrucción (en realidad es un objeto) del lenguaje C++: cout <<, en su forma por defecto, y la cual se encuentra en el archivo a incluir iostream.h. El operador << es llamado en este contexto un insertor, ya que inserta datos en el flujo de salida hacia la pantalla. Esta instrucción despliega o muestra los valores que se le indiquen en pantalla, teniendo la posibilidad de formatearlos. Figura 1.2 Fragmento de código en C++ y lo que aparecería en pantalla: clrscr(); //Borrar pantalla cout << "ESTO ES SOLO UNA PRUEBA...\n"; N = 0; cout << "El contador N = " << N << "\n"; cout << "\n\n\nArriba hay tres líneas en blanco\n"; cout << "\n1+ 2 + 3 = " << 1+2+3 << "\n"; N++; cout << "El contador N = " << N << "\n\n"; cout << "El cursor está aquí"; 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í_ ║ ║ ║ ╚═══════════════════════════════════════╝

8

1.12 El siguiente ejemplo presenta en pantalla un texto compuesto de varias líneas, cópielo, tal cual, compílelo y ejecútelo. Luego modifíquele los saltos de línea. Las tildes digítelas pulsando la tecla ALT y simultáneamente, en el teclado numérico, el código ASCII correspondiente. #include <iostream.h> // cout #include <conio.h> // clrscr() y getch() //COUT01.CPP main(){ clrscr(); cout << " ... Prevalece la superstición patética de que sabiendo más \n"; cout << "y más hechos es posible llegar a un conocimiento de la \n"; cout << "realidad. De este modo se descargan en la cabeza de los \n"; cout << "estudiantes centenares de hechos aislados e inconexos; todo \n"; cout << "su tiempo y toda su energía se pierden en aprender cada vez \n"; cout << "más hechos, de manera que les queda muy poco lugar para \n"; cout << "ejercitar el pensamiento. Es cierto que el pensar carente \n"; cout << "de un conocimiento adecuado de los hechos sería vacío y \n"; cout << "ficticio; pero la 'información' sin teoría puede representar \n"; cout << "un obstáculo para el pensamiento tanto como su carencia. ... \n"; cout << "\n\n"; cout << " ERICH FROMM \n"; cout << " \"EL MIEDO A LA LIBERTAD\""; getch(); } Figura 1.3 Efecto de la ejecución del Programa COUT01.CPP en pantalla

... Prevalece la superstición patética de que sabiendo más y más hechos es posible llegar a un conocimiento de la realidad. De este modo se descargan en la cabeza de los estudiantes centenares de hechos aislados e inconexos; todo su tiempo y toda su energía se pierden en aprender cada vez más hechos, de manera que les queda muy poco lugar para ejercitar el pensamiento. Es cierto que el pensar carente de un conocimiento adecuado de los hechos sería vacío y ficticio; pero la 'información' sin teoría puede representar un obstáculo para el pensamiento tanto como su carencia. ... ERICH FROMM "EL MIEDO A LA LIBERTAD"_

9

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, donde el profesor explicará los pasos para lograr editar, compilar, enlazar y ejecutar un programa en el Lenguaje C. Copie, en el editor, uno por uno todos los programas que se presentan en esta lección, compilándolos y ejecutándolos cada uno de ellos. Figura 1.4 Editor del Turbo C++ File Edit Search Run Compile Debug Project Options Window Help ┌─[_]──────────────────────────── NONAME00.CPP─────────────────────────────────┐ │ │ │ ┌──[_]──────────── Open a File ─────────────────┐ │ │ │ ┌──────────────────────────────┐ │ │ │ │ │Name │ ┌────────┐ │ │ │ │ │ C:\TC\ALGORIT.MOS\*.CPP │ │ Open │ │ │ │ │ ├──────────────────────────────┤ └────────┘ │ │ │ │ │Files ─────────┬───────────── │ ┌────────┐ │ │ │ │ │ COUT00.CPP │ COUTIN03.CPP │ │Replace │ │ │ │ │ │ COUT01.CPP │ COUTIN04.CPP │ └────────┘ │ │ │ │ │ COUT02.CPP │ COUTIN05.CPP │ │ │ │ │ │ COUT03.CPP │ COUTIN06.CPP │ │ │ │ │ │ COUT04.CPP │ COUTIN07.CPP │ ┌────────┐ │ │ │ │ │ COUTIN00.CPP │ COUTIN08.CPP │ │Cancel │ │ │ │ │ │ COUTIN01.CPP │ COUTIN09.CPP │ └────────┘ │ │ │ │ │ COUTIN02.CPP │ COUTIN10.CPP │ ┌────────┐ │ │ │ │ └───────────────┴──────────────┘ │ Help │ │ │ │ │ └────────┘ │ │ │ │ C:\TC\ALGORIT.MOS\*.CPP │ │ │ │ COUT00.CPP 630 Sep 17,1995 8:06am │ │ │ └───────────────────────────────────────────────┘ │ │ │ └────────1:1 ──────────────────────────────────────────────────────────────────┘ F1 Help Type for incremental search: lower for files, upper for directories 1.14 Para lograr ejecutar un programa se deberán utilizar varias secuencias de teclas, las principales a necesitar e ir "memorizando" son las contenidas en la siguiente Tabla:

10

Tabla 1.4 Secuencias de teclas más utilizadas.

TECLA ORDEN DEL MENU

F1 Ayuda del editor F2 Grabar en disco F3 Cargar desde disco F4 Ejecutar programa hasta el cursor F5 Hace zoom en la ventana activa F6 Cambia de ventana activa F7 Rastreo del programa con llamado de funciones F8 Rastreo del programa saltando funciones F9 Compila y enlaza el programa F10 Activa el menú principal F10 File New Comenzar un programa nuevo F10 File Change Dir Cambiar directorio actual F10 Window Close All Cerrar todas las ventanas F10 Help Index Índice alfabético de ayuda CTRL + F8 Marca punto en el cual detenerse ejecución CTRL + F9 Compilar y ejecutar(correr) CTRL + Y Borrar una línea CTRL + T Borrar una palabra o espacios Shift + Teclas Mover Marcar bloque Shift + Del Borrar bloque marcado Shift + Ins Restaurar bloque borrado CTRL + KV Mover bloque marcado CTRL + KC Copiar bloque marcado CTRL + KR Leer un archivo como bloque CTRL + KW Grabar un bloque como archivo CTRL + KP Imprimir bloque marcado ALT + 0 Lista ventanas abiertas ALT + 1 al 9 Activa ventana 1 al 9 ALT + F1 Pantalla ayuda anterior ALT + F3 Elimina ventana activa ALT + F4 Abre ventana de depuración ALT + F5 Cambia a ventana de ejecución del programa ALT + F7 Error anterior ALT + F8 Error siguiente ALT + F9 Compilar a archivo .OBJ ALT + X Salir(eXit) del editor del C++

11

Figura 1.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, tal cual, c │ Program reset Ctrl+F2 │ odifíquele los saltos de l │ │ │ Go to cursor F4 │ │ │#include <iostream.h> │ Trace into F7 │ │ │#include <conio.h> // │ Step over F8 │ │ │ │ Arguments... │ │ │main(){ └─────────────────────────┘ │ │ clrscr(); │ │ cout << " ... Prevalece la superstición patética de que sabiendo más \n";│ │ cout << "y más hechos es posible llegar a un conocimiento de la \n";│ │ cout << "realidad. De este modo se descargan en la cabeza de los \n";│ │ cout << "estudiantes centenares de hechos aislados e inconexos; todo \n";│ │ cout << "su tiempo y toda su energía se pierden en aprender cada vez \n";│ │ cout << "más hechos, de manera que les queda muy poco lugar para \n";│ │ cout << "ejercitar el pensamiento. Es cierto que el pensar carente \n";│ │ cout << "de un conocimiento adecuado de los hechos sería vacío y \n";│ │ cout << "ficticio; pero la 'información' sin teoría puede representar \n";│ │ cout << "un obstáculo para el pensamiento tanto como su carencia. ... \n";│ │ cout << "\n\n"; │ │ cout << " ERICH FROMM \n";│ │ cout << " \"EL MIEDO A LA LIBERTAD\"";│ └────── 1:1 ──────────────────────────────────────────────────────────────────┘ F1 Help │ Make and run the current program 1.15 CUERPO DEL PROGRAMA Los programas en C/C++ deberán estar compuestos de al menos una función, la función main(), sin esta el programa no trabajará por sí solo. Cada función del programa, consta de la secuencia de instrucciones o algoritmo que la computadora deberá realizar. El algoritmo debe incluir identificadores, operadores y palabras claves. Todo algoritmo se desarrollará con tres tipos de instrucciones: Secuenciales, Selectivas y Repetitivas; 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, en algún campo del saber, y que la computadora podrá ejecutar y de esta forma nosotros obtener los resultados deseados. El C++ es un lenguaje de formato libre. Los espacios en blanco adicionales y los caracteres de salto de línea no son relevantes para el compilador, excepto cuando se requieren para conservar identificadores y las palabras claves o dentro de variables de tipo de cadena. Las líneas del programa pueden tener una longitud máxima de hasta 127 caracteres, siendo preferible utilizar menos de los primeros 80 por motivos de presentación en las impresiones del código fuente. Recordar que la pantalla tiene en modo de texto 80 columnas.

12

Figura 1.6 Ejemplo de función main() en editor del Turbo C++ ┌─────┐ │ File│ Edit Search Run Compile Debug Project Options Window Help ├───┬─┴───────────────┬─── \TC\ALGORIT.MOS\COUT01.CPP ───────────────────1-[ ]─┐ │// │ New │ presenta en pantalla un texto compuesto de varias línea│ │// │ Open... F3 │ mpilelo y ejecútelo. Luego modifíquele los saltos de lí│ │ │ Save F2 │ //COUT01.CPP │ │#i │ Save as... │ // cout │ │#i │ Save all │ lrscr() y getch() │ │ │-----------------│ │ │ma │ Change dir... │ │ │ │ Print │ │ │ │DOS shell │alece la superstición patética de que sabiendo más \n";│ │ │-----------------│ hos es posible llegar a un conocimiento de la \n";│ │ │ Quit Alt+X │ De este modo se descargan en la cabeza de los \n";│ │ └─────────────────┘ s centenares de hechos aislados e inconexos; todo \n";│ │ cout << "su tiempo y toda su energía se pierden en aprender cada vez \n";│ │ cout << "más hechos, de manera que les queda muy poco lugar para \n";│ │ cout << "ejercitar el pensamiento. Es cierto que el pensar carente \n";│ │ cout << "de un conocimiento adecuado de los hechos sería vacío y \n";│ │ cout << "ficticio; pero la 'información' sin teoría puede representar \n";│ │ cout << "un obstáculo para el pensamiento tanto como su carencia. ... \n";│ │ cout << "\n\n"; │ │ cout << " ERICH FROMM \n";│ │ cout << " \"EL MIEDO A LA LIBERTAD\"";│ └─────── 1:1 ──────────────────────────────────────────────────────────────────┘ F1 Help │ Save the file in the active Edit window 1.16 EXPRESIONES Una expresión es un conjunto de datos compuesto de operandos unidos por operadores. Los operandos pueden ser constantes, variables o funciones. 1.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, los operadores también se dividen en: aritméticos, relacionales, lógicos, a nivel de bits, el operador sizeof, el operador coma. En la siguiente tabla de operadores, los operadores del Turbo C++ son divididos en 16 categorías. La categoría #1 tiene la más alta prioridad de precedencia; la categoría #2 (operadores unarios) tiene la segunda prelación, y así sucesivamente hasta el operador coma que tiene la más baja prelación. Operadores dentro de la misma categoría tienen la misma prelación. Los operadores unarios (categoría #2), los condicionales (categoría #14) y los de asignamiento (categoría #15) son asociados de derecha a izquierda, todos los demás son asociados de izquierda a derecha. De mayor precedencia quiere decir que se ejecuta primero.

13

Tabla 1.5 Operadores del C++ y Precedencia ╔═══════════════╤══════════╤═══════════════════════════════╗ ║ # Categoría │ Operador │ Qué es (o qué hace) ║ ╠═══════════════╪══════════╪═══════════════════════════════╣ ║ 1. Mayor │ () │ Invocación de función ║ ║ │ [] │ Suscritos de arreglos ║ ║ │ -> │ Selector de indirección ║ ║ │ :: │ Resolución de ámbito ║ ║ │ . │ Selector de componentes ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║ 2. 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. Multipli- │ * │ Multiplicación ║ ║ cativos │ / │ División ║ ║ │ % │ Resto en división entera ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║ 4. Acceso │ . │ Separador campo ║ ║ a miembros │ -> │ Separador campo ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║ 5. Aditivos │ + │ Más binario ║ ║ │ - │ Menos binario ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║ 6. Desplaza- │ << │ Izquierda ║ ║ miento bits│ >> │ Derecha ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║ 7. Relacional │ < │ Menor que ║ ║ │ <= │ Menor o igual que ║ ║ │ > │ Mayor que ║ ║ │ >= │ Mayor o igual que ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║ 8. Igualdad │ == │ Igual a ║ ║ │ != │ No igual a ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║ 9. y │ & │ AND para bits ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║10. o exclusivo│ ^ │ XOR para bits ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║11. o │ | │ OR para bits ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║12. y │ && │ AND lógico ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║Continúa...

14

Tabla 1.5 Operadores del C++ y Precedencia (Continuación) ╔═══════════════╤══════════╤═══════════════════════════════╗ ║ # Categoría │ Operador │ Que es (o que hace) ║ ╠═══════════════╪══════════╪═══════════════════════════════╣ ║13. o │ || │ OR lógico ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║14. Condicional│ ?: │ a ? x : ║ ║ │ │ significa: ║ ║ │ │ "Si a Entonces x, SI_NO y" ║ ╟───────────────┼──────────┼───────────────────────────────╢ ║15. 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. Coma │ , │ Separador de expresiones ║ ╚═══════════════╧══════════╧═══════════════════════════════╝ NOTA: muchos de estos operadores no serán utilizados en el presente manual. Las expresiones numéricas están formadas por operadores aritméticos y con operandos enteros o reales. Ejemplos de expresiones con operadores aritméticos válidas, dentro de un algoritmo, son las siguientes: Numero = 24 / 2 - 36 % 6; cout << "60 = " << 60 * 3.14159 / 180 << " radianes"; Valor = (123.54 - 544.1232/8 + (34.6632*54.21) + Numero; y = 3.2 * Pow(2, 12) - 4.1 * x + 69; cout<< "Resultado expresión algebraica = " << (y-x)/(a*x-b); Energía = Masa * Pow(VelocidadLuz, 2); El primer paso para traducir una expresión algebraica a su equivalente de computador es verificar que cada operación esté indicada, como es el caso en la expresión algebraica: 13X + 31Y donde la multiplicación la entendemos tácitamente, esta debe codificarse como 13*X + 31*Y, los espacios en blanco son opcionales, empero, mejoran la presentación de la expresión. En la tabla siguiente se presenta una evaluación "manual" de expresiones aritméticas:

15

Tabla 1.6. Evaluación secuencial de expresiones aritméticas 65.0 / 2 32.5

65 / 2 32

65 % 2 1

5 + 3 * 3 - 4 + 12 * 10 5 + 9 - 4 + 120 14 - 4 + 120 10 + 120 130

6 + 9 * 8 / 2 * 4 - 2 * 3 6 + 72 / 2 * 4 - 2 * 3 6 + 36 * 4 - 2 * 3 6 + 144 - 2 * 3 6 + 144 - 6 150 - 6 144

(63 -20) /(35 -15) 43 / 20 2 (63 -20.0) /(35 -15) 43.0 / 20 2.0

4.2 / 2 + 3.9 / 3 2.1 + 3.9 / 3 2.1 + 1.3 4.4

3 + sqrt(8 % 6 * 10 / 5) 3 + sqrt( 2 * 10 / 5) 3 + sqrt(20 / 5) 3 + sqrt(4) 3 + 2 5

(60 - 20) /35.0 -15 40 /35.0 - 15 1.142 - 15 -13.858

4.2 + 2 * 3.9 - 3 4.2 + 7.8 - 3 12 - 3 9

6 * 9 + 8 * 2 * 4 / 2 - 3 54 + 8 * 2 * 4 / 2 - 3 54 + 16 * 4 / 2 - 3 54 + 64 / 2 - 3 54 + 32 - 3 86 - 3 83

(60 - 20) / 35 - 15 40 / 35 - 15 1 - 15 -14

60 - 20 / 35 - 15 60 - 0 - 15 60 - 15 45

2 + 3 * 4 % 7 / 3 + 21 / 3 2 + 12 % 7 / 3 + 21 / 3 2 + 5 / 3 + 21 / 3 2 + 1 + 21 / 3 2 + 1 + 7 3 + 7 10

60 - 20.0 / 35 - 15 60 - 0.571 - 15 59.429 - 15 44.429

Como ejercicio escriba las expresiones anteriores como expresiones algebraicas.

16

Tabla 1.7 Ejemplos de codificación de expresiones algebraicas

EXPRESIÓN ALGEBRAICA EXPRESIÓN ALGORÍTMICA

60 - 20 --------- 35 - 15

(60 - 20) / (35 - 15)

20 60 - --------- 35 - 15

60 - 20 / (35 - 15)

20 60 - ---- - 15 35

60 - 20 / 35 - 15

60 - 20 -------- - 15 35

(60 - 20) / 35 - 15

a2 + b2 - 54 ------------- 3.4X - 2.1Y

(a*a + b*b - 54)/(3.4*X - 2.1*Y)

(b2 + a) -------- ac ---------------- 3 4.5 - c --- - ------- X+Y 567

(b*b+a)/(a*c)/(3/(X+Y)-(4.5-c)/567)

(aX5 +bY4 -0.3534)(a-b)

(a*pow(X,5)+b*pow(Y,4)-0.3534)*(a-b)

90 - 40 35 13 ------- + ---- - --- 30 - 12 -47 69

(90-40)/(30-12) + 35/(-47) -13/69

a + b ------- 36

(sqrt(a) + sqrt(b)) / pow(3,6)

(1 + seno(x))2

(1 + sin(x)) * (1 + sin(x))

cos2(x) + sen2(x)

cos(x)*cos(x) + sin(x)*sin(x)

a2 + b2 54 ------- - ------ 3.4X 2.1Y

(a*a + b*b)/(3.4*X) - 54/(2.1*Y)

17

1.18 Copie, compile y ejecute el siguiente programa el cual presenta un ejemplo de diferentes agrupaciones con paréntesis en expresiones algebraicas. Escriba expresión algebraica para cada caso y calcúlela "manualmente" comparándola con la obtenida en el computador. #include <iostream.h> #include <conio.h> //COUT02.CPP main(){ clrscr(); cout << "1.0 + 2.0 * 3.0 / 4.0 = " << 1.0 + 2.0 * 3.0 / 4.0; cout << "\n\n( 1.0 + 2.0 * 3.0 ) / 4.0 = " << (1.0 + 2.0 * 3.0) / 4.0; cout << "\n\n1.0 + ( 2.0 * 3.0 ) / 4.0 = " << 1.0 + (2.0 * 3.0) / 4.0; cout << "\n\n( 1.0 + 2.0 ) * 3.0 / 4.0 = " << (1.0 + 2.0) * 3.0 / 4.0; cout << "\n\n(1.0 + 2.0) * (3.0 / 4.0) = " << (1.0 + 2.0) * (3.0 / 4.0); cout << "\n\n1.0 + ( 2.0 * 3.0 / 4.0 ) = " << 1.0 + (2.0 * 3.0 / 4.0); cout << "\n\n1.0 + ( (2.0 * 3.0)/ 4.0) = " << 1.0 + ( (2.0 * 3.0) / 4.0); cout << "\n\n\n\nDigite cualquier tecla para terminar..."; getch(); } Figura 1.7 Efecto de la ejecución del programa COUT02.CPP en pantalla

¡Error! Marcador no definido.1.0 + 2.0 * 3.0 / 4.0 = 2.5 ( 1.0 + 2.0 * 3.0 ) / 4.0 = 1.75 1.0 + ( 2.0 * 3.0 ) / 4.0 = 2.5 ( 1.0 + 2.0 ) * 3.0 / 4.0 = 2.25 (1.0 + 2.0) * (3.0 / 4.0) = 2.25 1.0 + ( 2.0 * 3.0 / 4.0 ) = 2.5 1.0 + ( (2.0 * 3.0)/ 4.0) = 2.5 Digite cualquier tecla para terminar..._

1.19 ACTIVIDADES PARA REALIZAR PERSONALMENTE 1. Codifique 10 expresiones algebraicas en expresiones entendibles por el computador. 2. Codifique las expresiones anteriores como un programa de computador escrito en lenguaje C/C++.

19

CCAAPPÍÍTTUULLOO 22 IINNSSTTRRUUCCCCIIOONNEESS SSEECCUUEENNCCIIAALLEESS 2.1 METODOLOGÍA El profesor en clase magistral explicará algunos de los algoritmos, de esta lección, codificados en lenguaje C. A continuación diríjase al computador y solicitando la ayuda del monitor o de compañeros "más avanzados", compile y corra los programas presentados. Resuelva la tarea personalmente y luego lleve aportes a su Grupo de estudio. Los algoritmos deben ser resueltos con lápiz, papel, borrador y principalmente con sus neuronas. No pretenda que el computador se los resuelva, paradójicamente él solo le ocasionará mayor confusión, en un principio, y se agrava si no tiene un dominio del teclado. Cuando estén seguros de que los algoritmos están bien, vaya al computador y cópielos en el editor del lenguaje, compílelos, córralos y disfrute el mundo de la programación. Si sufre un poco le diré que eso nos pasa a todos, y no solo a los recién iniciados, y le recomiendo se lea "Elogio a la Dificultad" de nuestro maestro Estanislao Zuleta, está en una lectura más adelante. 2.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. La palabra, o secuencia de caracteres, que forma el nombre de uno de estos objetos se llama identificador. Todos los identificadores deben comenzar con una letra o un caracter de subrayado(_) y seguir con caracteres alfanuméricos y subrayados, en especial no deben contener espacios en blanco; las palabras reservadas no se pueden utilizar como identificadores. Los identificadores no admiten espacios intercalados. Con un identificador definiremos variables, constantes, tipos de datos, nombres de funciones, nombres de archivos incluidos y parámetros en definición de funciones. Los identificadores deben no solo ser válidos sino que deben autodocumentar su programa, por ejemplo si necesitamos una variable para el cálculo de un área será mucho más claro llamarla: Area y no solamente A. El lenguaje C hace diferencia entre minúsculas y mayúsculas, de esta forma si dentro del algoritmo escribe AREA no reconocerá este identificador si inicialmente lo definió como Area. Adicionalmente a los identificadores que definamos podemos encontrar otros, de otros archivos con la directiva #include y de esta forma tener acceso a gran cantidad de librerías que vienen adicionadas al lenguaje, 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. Ejemplos de identificadores válidos son los siguientes: SumaTotal Max CiudadCapital AreaCuadrado MoleSolvente Pi Voltaje MARIA VelocidadLuz I_V_A Esta_es_una_variable Costo_de_la_vida Sumatoria _identificador Acidez Arbol Maria

20

Los siguientes son identificadores no válidos: Suma Total 1_variable VariableNoVálida x+y maximo valor cantidad_en_$ MáximoValor if while do Nombre&Apellido 454 árbol ßeta I.V.A. C U A O ¿Cuáles de los siguientes identificadores son válidos, y cuáles no? Para los identificadores no válidos proponga uno válido. Abc TotNomina acumulado Más MiAlgoritmo ABC While Univalle integral serie 1 contador área Cali Valle I xxxx 15 Quince aREa Apellido _contador Uno_A Pascal más abc totalSumas CUAO UNIVALLE 2.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. Deben ser identificadores válidos y no ser palabras reservadas. Cada variable debe ser declarada como de alguno de los tipos primitivos, 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, A - Z, o el signo de subrayado(_). No se admiten espacios en blanco en medio de un identificador. Ejemplos de definición de variables en base a tipos primitivos son los siguientes: int I, contador=0; float Sumatoria=0; int edad, AlturaEnMetros; float VoltajeDelColector, VoltajeEmisor, VoltajeBase; char letra, numero, caracter, nueve='9'; Ejemplo de definición de variables de tipo estructurado: char modulo[20], nombre[30], cadena[256]; char *Apellidos, *codigo; char Ciudad[20]="Palmira Valle"; char *Nombre = "Tania Carolina"; int VectorEnteros[1000], A[210]; float VectorReales[100], X[100]; char VectorCadena[32]; int MatrizEnteros[3][3]; float MatrizReales[5][4]; struct Registro{ char Nombre[10]; int edad; float CxC; } Cliente; struct Registro Persona; En el último ejemplo, Cliente y Persona son variables del tipo estructurado Registro, este tema será de los últimos del presente curso.

21

Las variables pueden ser declaradas globalmente, es decir fuera de las funciones (ver capítulo 3) que compongan el programa; o locamente, es decir dentro del ámbito de una función en particular. 2.4 CONSTANTES Las constantes son objetos las cuales estarán representadas por identificadores válidos y se les asigna un valor, el cual no puede ser cambiado durante el transcurso del programa. Ejemplos de definición de constantes son los siguientes: const int MaxFila = 100; const float PI = 3.14159 const char *CAPITAL = "Bogotá"; Las constantes pueden ser declaradas globalmente, es decir fuera de las funciones que compongan el programa; o locamente, es decir dentro del ámbito de una función en particular. Otra forma de definir constantes en el antiguo C es la siguiente: #define MaxFila 100 #define PI 3.14159 #define CAPITAL "Bogotá" 2.5 TIPOS DE DATOS La computadora es capaz de manejar y almacenar datos e información de varios tipos. La computadora almacena datos tanto en memoria como en dispositivos externos en código binario. La cantidad de espacio que se asigna a cada dato depende de su tipo, de la implantación de cada compilador de lenguaje y de la computadora utilizada. En casi todos los casos el almacenamiento es transparente para el programador y con mayor razón para el usuario, ya que los datos son referidos mediante sus identificadores y el compilador del lenguaje hace la transferencia en forma automática. Los tipos pueden ser numéricos o de caracter, y en base a estos se pueden definir tipos de datos estructurados, ya sea que el lenguaje en particular los traiga predefinidos o el usuario los defina. El C++ no es un lenguaje "fuerte" en declaración de tipos, como por ejemplo lo es el lenguaje Pascal, en vez de esto permite una gran flexibilidad al programar, dejándolo a entera responsabilidad del programador. Lo recomendado es no mezclar tipos no compatibles al asignar valores a una variable, 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. 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. Los objetos los cuales están compuestos de un solo caracter se definen con el tipo predefinido char, estos pueden contener uno cualquiera de los 256 caracteres del código ASCII ampliado. Los caracteres deben ir delimitados con comillas sencillas al ser asignados a variables de tipo char. Un valor de tipo char ocupa un byte de memoria. Ejemplos de declaración de este tipo de variables son: char letra='A'; char opcion, terminar='N';

22

char numero, a, A, caracter, etc; char digito; De esta forma se han declarado las variables letra, opcion, terminar, numero, a, A, caracter, digito y etc; a las cuales se les podrá luego asignar valores ya sea por asignación dentro del algoritmo, por lectura desde el teclado o lectura desde un archivo en disco. 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. Los diferentes tipos numéricos con su correspondiente longitud en Bytes, es decir el espacio que ocupa cada uno en memoria, y el rango de valores numéricos en cual maneja se presentan en la siguiente Tabla. Tabla 2.1 Tipos de Datos Primitivos del C++.

TIPO LONGITUD RANGO DE VALORES

unsigned char char enum unsigned int short int int unsigned long long float double long double

8 bits 8 bits 16 bits 16 bits 16 bits 16 bits 32 bits 32 bits 32 bits 64 bits 80 bits

0 a 255 -128 a 127 -32,768 a 32,767 0 a 65,535 -32,768 a 32,767 -32,768 a 32,767 0 a 4,294,967,295 -2,147,483,648 a 2,147,483,647 3.4 * (10**-38) a 3.4 * (10**+38) 1.7 * (10**-308) a 1.7 * (10**+308) 3.4 * (10**-4932) a 1.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). Ejemplos de definiciones de variables de tipos numéricos son los siguientes: int a, N=100; float X, Total=0; float real; short int EnteroCorto; long EnteroLargo; double DoblePresicion; unsigned int EnteroSinSigno; unsigned long EnteroLargoSinSigno; int Vector[100]; float Matriz[10][20]; De esta forma se han definido las siguientes variables de tipo numérico: a, N, X, Total, real, EnteroCorto, EnteroLargo, DoblePresicion, EnteroSinSigno, EnteroLargoSinSigno, Vector, y Matriz. 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:

23

dimensionando la variable con el tamaño adecuado a la necesidad o definiendo la variable como un puntero(*). El C++ en realidad no tiene predefinido un tipo de datos para este menester. Ejemplos de la declaración de variable de este tipo son los siguientes: char Nombre[20], Apellido[25]; char Ciudad[15]= "Palmira Valle"; char Linea_Texto_en_Pantalla[80]; char *NombreCompleto="Carolina Alexandra Mazuera Bravo"; char *EstaEsUnaVariableDeCadenaDeCaracteres; Se han declarado de esta forma las variables de tipo cadena de caracteres: Nombre, Apellido, Ciudad, Linea_Texto_en_Pantalla, NombreCompleto, y EstaEsUnaVariableDeCadenaDeCaracteres. 2.6 ASIGNACIÓN La asignación es una operación que coloca un valor en una dirección de la memoria RAM. El lenguaje C/C++ utiliza como símbolo de asignación el igual(=). 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(=). 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 valor de la expresión a la derecha debe ser de un tipo de datos compatible con la única variable a la izquierda, en caso contrario se producirán resultados inesperados e inclusive el bloqueo de la máquina. Repitiendo, en una instrucción de asignación, el proceso es el siguiente: El compilador evalúa la expresión a la derecha del símbolo de asignación(=), obteniendo un resultado; este lo asigna a la variable que está a la izquierda, borrando el contenido previo que tuviera; por esto la asignación es una operación destructiva. A diferencia del símbolo igual en matemática, que es como hasta ahora lo a manejado, las asignaciones en un algoritmo de computador, son procesos en una sola dirección. El valor de la expresión de la derecha se asigna al de la única variable a la izquierda. La expresión: X = X + 13; que no tendría significado matemático, ya que no se cumple para ningún X, es completamente válida, y significa que a la variable X se le suma el número 13, este nuevo valor obtenido es asignado a la misma variable X(en la memoria RAM), borrando el inicial. En resumen el efecto es el incremento de la variable X en 13. Los siguientes son ejemplos de asignaciones válidas: fila = 25; contador = contador + 1; valor = 4.5E12; opcion = 'B'; valor = sqrt(144); VectorEntero[2] = 13; VectorReal[0] = 7.6; Matriz[0][0] = VectorEntero[I] * fila;

24

25

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 >>; la cual se encuentra en el archivo a incluir iostream.h. La instrucción cin >> en tiempo de ejecución detiene al computador y espera a que se digite un valor, el valor que puede ser cualquier secuencia de caracteres ASCII terminados con la tecla de <ENTRAR>, será almacenado en la dirección de memoria de la variable que utilice la instrucción, después de esto el control lo devuelve a la siguiente instrucción del programa. Solamente por efectos de presentación en pantalla, debería ir previamente acompañada de una instrucción de impresión en pantalla, para nuestro caso cout <<, donde se le dijera al usuario lo que debe digitar a continuación, por ejemplo: clrscr(); cout << "Digite un número: "; cin >> N; 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, el programa se detendrá, se verá el cursor titilando, en espera de que el usuario digite, en este caso números; la entrada se terminará cuando se digite la tecla de <ENTRAR>. La presentación en pantalla sería la de la derecha de la siguiente figura: Figura 2.1 Efecto en pantalla de la instrucción de lectura cin >>. Se detiene el programa con cin Luego de digitar el # y dar <ENTRAR> ┌─────────────────────────┐ ┌───────────────────────────┐ │Digite un número: _ │ │Digite un número: 13 │ │ │ │ │ │ │ │ │ │ │ │ │ └─────────────────────────┘ └───────────────────────────┘ nota: observe el cursor _

A continuación el valor digitado se almacena en la variable N y el programa sigue secuencialmente en la siguiente instrucción. La presentación en pantalla

sería mostrada en la figura mostrada más abajo. Y si, adicionalmente, secuencialmente siguieran las dos instrucciones siguientes, el efecto se muestra

en la misma próxima figura: cout << "Nombre de ciudad: "; cin >> ciudad;

26

Figura 2.2 Efecto en pantalla de la instrucción de lectura cin >>.

Se detiene el programa con cin Luego de digitar el # y dar <ENTRAR> ┌─────────────────────────┐ ┌───────────────────────────┐ │Digite un número: 13 │ │Digite un número: 13 │ │Nombre de ciudad: _ │ │Nombre de ciudad: Palmira │ │ │ │_ │ └─────────────────────────┘ └───────────────────────────┘ nota: observe el cursor _

2.8 El siguiente algoritmo calcula el volumen de un cilindro, a partir de la lectura del radio de la base y su altura por teclado. #include <iostream.h> #include <conio.h> #include <math.h> // constante para el número : M_PI //COUTIN00.CPP main(){ float radio, altura, volumen; cout << " CALCULO DEL VOLUMEN DE UN CILINDRO \n"; cout << "─────────────────────────────────────────────────────────\n\n"; cout << "Digite el radio de la base del cilindro en centímetros: "; cin >> radio; cout << "Digite la altura del cilindro en centímetros: "; cin >> altura; // volumen = area base( *r²) multiplicada por la altura volumen = M_PI* radio*radio * altura; cout << "\nEl volumen es de " << volumen << " centímetros cúbicos."; cout << "\n\n─────────────────────────────────────────────────────────"; } Figura 2.3 Efecto de la ejecución del programa COUTIN00.CPP en pantalla

CALCULO DEL VOLUMEN DE UN CILINDRO ───────────────────────────────────────────────────────── Digite el radio de la base del cilindro en centímetros: 2.58 Digite la altura del cilindro en centímetros: 78.9 El volumen es de 1649.932861 centímetros cúbicos. ─────────────────────────────────────────────────────────_

Cálculos manuales de la secuencia que debió seguir el computador para el cálculo del Volumen: volumen = M_PI* radio*radio * altura; volumen = 3.14159 * 2.58 * 2.58 * 78.9 volumen = 8.10530994 * 2.58 * 78.9 volumen = 20.911699840 * 78.9 volumen = 1649.933036 observe la diferencia que se presenta en los decimales.

27

2.9 Ejemplo de operaciones de división en expresiones algebraicas. Se introduce un reforzador de tipo en la división de las variables enteras a y b: (float). #include <iostream.h> #include <conio.h> //COUTIN01.CPP main(){ int a, b; clrscr(); cout<<"Digite dos números enteros separados por al menos un espacio:\n"; cin >> a >> b; // simule este error: dele a "b" un valor de cero cout << "\nDivisión entera = " << a / b; cout << "\nDivisión real = " << (float) a / b; //ensaye a borrar el reforzador cout << "\nResiduo división= " << a % b; getch(); } Figura 2.4 Efecto de la ejecución del programa COUTIN01.CPP en pantalla

Digite dos números enteros separados por al menos un espacio: 13 4 División entera = 3 División real = 3.25 Residuo división= 1_

2.10 El siguiente código presenta la evaluación de la expresión algebraica: 2a - 3(b + 2a) + 3X [ X - 2(Y -2) ] los valores reales para X y Y son leídos desde teclado. Los valores para las constantes son: a=2 y b=-3 #include <iostream.h> // cout y cin #include <conio.h> //COUTIN02.CPP main(){ const int a=2, b=-3; float X, Y; clrscr(); cout << " Digite un valor real para X: "; cin >> X; cout << " Digite un valor real para Y: "; cin >> Y; cout << "\n2a-3(b+2a)+3X[X-2(Y-2)] = " << 2*a-3*(b+2*a)+3*X*(X-2*(Y-2)); }

28

2.11 El siguiente algoritmo evalúa la expresión cuadrática: Y = aX²-bX+c para valores de los coeficientes: a, b, c, y de la variable X pedidos por teclado. #include <iostream.h> #include <conio.h> //COUTIN03.CPP main(){ float a, b, c, X, Y; clrscr(); cout << "Digite el coeficiente a: "; cin >> a; cout << "Digite el coeficiente b: "; cin >> b; cout << "Digite el coeficiente c: "; cin >> c; cout << "Digite la variable X: "; cin >> X; Y = a * X * X - b * X + c; cout << "\n\nEl valor de la variable Y es " << Y; getch(); } Figura 2.5 Efecto de la ejecución del programa COUTIN03.CPP en pantalla Digite el coeficiente a: 2 Digite el coeficiente b: 1 Digite el coeficiente c: -1 Digite la variable X: 3 El valor de la variable Y es 14.00000

La evaluación de la expresión algebraica la efectúo el computador de la siguiente forma: Y = a * X * X - b * X + c; Y = 2 * 3 * 3 - 1 * 3 + (-1) Y = 6 * 3 - 1 * 3 + (-1) Y = 18 - 1 * 3 + (-1) Y = 18 - 3 + (-1) Y = 15 + (-1) Y = 15 -1 Y = 14

29

2.12 Se lee un número por teclado y se redondea a la decena más próxima. #include <iostream.h> #include <conio.h> //COUTIN04.CPP main(){ int numero; clrscr(); cout << "Digite un número entero para redondearlo:\n"; cin >> numero; numero = numero + 5; numero = numero / 10; numero = numero * 10; cout << "El número redondeado es: " << numero; cout << "\n\nDigite cualquier tecla para terminar..."; getch(); } Figura 2.6a Efecto de la ejecución del programa COUTIN04.CPP en pantalla Digite un número entero para redondearlo: 879 El número redondeado es: 880 Digite cualquier tecla para terminar..._

Figura 2.6b Efecto de la ejecución del programa COUTIN04.CPP en pantalla Digite un número entero para redondearlo: 844 El número redondeado es: 840 Digite cualquier tecla para terminar..._

30

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_

31

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 / 10000; saldo = saldo % 10000; b5000 = saldo / 5000 ; saldo = saldo % 5000; b2000 = saldo / 2000; saldo = saldo % 2000; m1000 = saldo / 1000; saldo = saldo % 1000; m500 = saldo / 500; saldo = saldo % 500; m200 = saldo / 200; saldo = saldo % 200; m100 = saldo / 100; saldo = saldo % 100; m50 = saldo / 50; saldo = saldo % 50; m20 = saldo / 20; saldo = saldo % 20; m10 = saldo / 10; saldo = saldo % 10; m5 = saldo / 5; saldo = saldo % 5; m2 = saldo / 2; m1 = saldo % 2; cout << "\n──────────────────────────────────"; cout << "\nDENOMINACION CANTIDAD TOTAL($)"; cout << "\n──────────────────────────────────"; cout << "\n$20,000 " << "\t" << b20000 << "\t" << setw(10) << 20000*b20000; cout << "\n$10,000 " << "\t" << b10000 << "\t" << setw(10) << 10000*b10000; cout << "\n$ 5,000 " << "\t" << b5000 << "\t" << setw(10) << 5000*b5000; cout << "\n$ 2,000 " << "\t" << b2000 << "\t" << setw(10)<< 2000*b2000; cout << "\n$ 1,000 " << "\t" << m1000 << "\t" << setw(10)<< 1000*m1000; cout << "\n$ 500 " << "\t" << m500 << "\t" << setw(10)<< 500*m500; cout << "\n$ 200 " << "\t" << m200 << "\t" << setw(10)<< 200*m200; cout << "\n$ 100 " << "\t" << m100 << "\t" << setw(10)<< 100*m100; cout << "\n$ 50 " << "\t" << m50 << "\t" << setw(10)<< 50*m50;

32

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_

33

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 ────────────────────────────────────────────────_

34

2.16 Demostración de los valores del código ASCII. ASCII es el acrónimo de: American Standard Code for International Interchange. Se hace lectura de un caracter con las funciones getch() y getche() de conio.h #include <iostream.h> #include <conio.h> //COUTIN07.CPP main(){ char caracter; clrscr(); cout << "Digite un caracter cualquiera del teclado: "; cin >> caracter; cout << "El caracter digitado fue \"" << caracter << "\" su código ASCII es el " << "\"" << (int) caracter << "\" "; // (int) en la línea anterior es un reforzador de tipo (cast en inglés) cout << "\nDigite otro caracter cualquiera del teclado: "; caracter=getch(); //No hace "eco en pantalla" ni se le dio ENTER cout << "\nEl caracter digitado fue \"" << caracter << "\" su código ASCII es el " << "\"" << (int) caracter << "\" "; cout << "\nDigite otro caracter cualquiera del teclado: "; 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 << "\""; cout << "\nDigite otro caracter cualquiera del teclado: "; 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(); } Figura 2.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"_

35

2.17 A partir de la lectura de un número en base hexadecimal, se presentan operaciones matemáticas elementales, tanto en decimal como en hexadecimal, 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 <iostream.h> #include <iomanip.h> #include <conio.h> //COUTIN12.CPP void main(void){ long int a, b; clrscr(); cout << "Digite operandos en hexadecimal, anteponiendo 0x cada vez\n"; cout << "Primer operando(Digite 0x primero): "; cin >> a; cout << "Segundo operando(Digite 0x primero): "; cin >> b; 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 - 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; getch(); } Figura 2.11 Complete el efecto de la ejecución del programa COUTIN12.CPP.

36

2.18 ACTIVIDADES PARA EFECTUAR PERSONALMENTE 2.18.1 Efectúe lectura de todos los algoritmos presentados anteriormente en este capítulo. Anote las preguntas que crea conveniente efectuar al profesor. Recuerde que cada lenguaje de programación trae gran cantidad de instrucciones, y que sería imposible explicarsélas todas en el limitado espacio de un manual como el presente, tenga presente que si las ve ejecutándose deberá entender que es lo que hacen, recuerde el dicho: "una imagen vale más que mil palabras". 2.18.2 Un conductor lleva registros, tanto de cuantos galones de gasolina a tanqueado como de cuantos kilómetros a recorrido en su vehículo. 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.3 Una compañía paga a los vendedores un salario básico más un porcentaje por comisiones por las ventas efectuadas. Para un vendedor efectúe programa el cual le permita digitar el nombre del vendedor, su cédula, y la cantidad en pesos de sus ventas, y la máquina le responda con el salario básico, las comisiones, y el total a pagar a este vendedor. 2.18.4 Calcule la presión de un gas, dados su volumen, número de moles y temperatura, por medio de la Ley de los gases ideales: PV = nRT, donde R = 0.082054 (atm litro)/(mol K). 2.18.5 Determinar la cantidad de calor Q en calorías a proporcionar a un cuerpo, para obtener un aumento de temperatura desde Ti hasta Tf. Leer desde teclado las temperaturas inicial y final, la masa del cuerpo y el calor específico. Utilice la ecuación Q = m C (Tf - Ti). Corra el programa para cada uno de los siguientes valores de calor específico en calorías/(gramo C) siguientes: Agua = 1.0, Plomo=0.03, Aluminio=0.2 y Cobre = 0.10. 2.18.6 Digite una cantidad que representará dinero(pesos($)), a continuación un número real que representará un porcentaje. El programa debe responderle con la cantidad en pesos correspondiente al porcentaje digitado. 2.18.7 Calcule la conductancia total Gt(Siemens) y la resistencia total Rt(ohmios), de resistores R1, R2, R3 y R4 dados en ohmios, y conectados en paralelo, según las siguientes expresiones: 1 1 1 1 1 Rt = --- + --- + --- + --- ; Gt = --- R1 R2 R3 R4 Rt 2.18.8 Realice programa que permita efectuar las siguientes conversiones de unidades: Longitud: 1 pulgada = 2.54 centímetros Masa: 1 libra = 453.6 gramos Potencia 1 Kw = 58.87 BTU/minuto Presión 1 atm = 14.69 psi Temperatura 1 F = 1.8( C) + 32 Volumen 1 pulgada cúbica = 16.39 centímetros cúbicos Densidad 1 gramo/cm cúbico = 62.43 libras/pie cúbico Información 1 Kbyte = 1024 bytes lea desde el teclado el valor de la primera unidad y conteste con el correspondiente a la segunda. Por ejemplo: Aparece en pantalla: "Digite el número

37

de pulgadas: ", a continuación el usuario digita el número 10, debe aparecer como respuesta: "Son 25.4 centímetros". 2.18.9 Consultando la tabla de caracteres ASCII, escribir un programa que presente en pantalla el siguiente cuadro:

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. 2.18.10 El interés simple de un préstamo se calcula mediante la siguiente fórmula: Interés = Capital x rata x días/365 La fórmula anterior supone que rata en la tasa de interés anual y, por lo tanto, incluye la división entre 365 días. Codifique un programa en C el cual permita capturar el Capital, la rata de interés y los días para el préstamo de un solo cliente de una entidad prestamista, y que calcule y muestre en pantalla el Interés simple para el mismo. 2.18.11 Estudie todos los ejemplos que se ha "saltado", o ha dejado para un mejor momento, de las lecciones anteriores.

39

CCAAPPÍÍTTUULLOO 33 ""DDIIVVIIDDEE YY VVEENNCCEERRÁÁSS"":: FFUUNNCCIIOONNEESS 3.1 METODOLOGÍA El profesor explicará en clase magistral en qué consisten las funciones, definiendo su sintaxis general. Todos los programas del presente capítulo están en el disquete anexo, estúdielos inicialmente y luego compílelos y ejecútelos para verificar sus expectativas. Más sobre las funciones incorporadas en el C++, encontrará en el nivel de ayuda del compilador. 3.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. Estos subproblemas se pueden dividir a su vez en otros más pequeños, y así sucesivamente, según la conveniencia. Esta estrategia también se llama diseño descendente, debido a que se parte de lo general y se diseñan soluciones específicas para sus subproblemas. Estos subproblemas los podemos implementar en el lenguaje C mediante la codificación de funciones. Una función es simplemente un algoritmo el cual devuelve un único valor al sitio del programa en que fue invocada o llamada. Hay funciones predefinidas en el lenguaje y las cuales vienen en los archivos incluidos y también podemos definirlas nosotros mismos. Tabla 3.1 Funciones y constantes incorporadas en el archivo a incluir math.h

Funciones ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ abs acos, acosl asin, asinl atan, atanl atan2, atan2l atof, _atold cabs, cabsl ceil, ceill cos, cosl cosh, coshl exp, expl fabs, fabsl floor, floorl fmod, fmodl frexp, frexpl hypot, hypotl labs ldexp, ldexpl log, logl log10, log101 matherr, _matherrl modf, modfl poly, polyl pow, powl pow10, pow10l sin, sinl sinh, sinhl sqrt, sqrtl tan, tanl tanh, tanhl Constantes: ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ M_PI M_PI_2 M_PI_4 M_1_PI M_2_PI M_1_SQRTPI M_2_SQRTPI M_SQRT2 M_SQRT_2

40

3.3 Este programa emplea funciones matemáticas del archivo de cabecera "math.h" #include <iostream.h> #include <conio.h> #include <math.h> #include <values.h> // MAXINT //COUTIN_6.CPP void main(){ int a; float x,y; clrscr(); cout <<"▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄"; cout << "\nFUNCIONES VARIAS INCORPORADAS EN <MATH.H>\n"; cout <<"▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀"; cout << "\nNúmero para calcularle la raíz cuadrada: "; cin >> x; cout << "Raíz cuadrada de " << x << " = " << sqrt(x); cout<<"\n\nA continuación ejemplo de exponenciación: \n"; cout << "Digite un número como base: "; cin >> x; cout << "Digite el exponente: "; cin >> y; cout<<" " <<x << " ^ " <<y << " = "<< pow(x,y); cout << "\n\n x "; cout << "\nDigite un valor real x para obtener e : "; cin >> x; cout << " " << x << "\ne = " << exp(x); cout << "\n\nEl número e = " << exp(1); cout << "\n\nDigite un número real: "; cin >> x; clrscr(); cout<<"▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄"; cout << "\nFUNCIONES VARIAS INCORPORADAS EN <MATH.H>\n"; cout<<"▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀"; cout << "\nNúmero real: " << x; cout << "\nLogaritmo natural = " << log(x); cout << "\nLogaritmo decimal = " << log10(x); cout << "\n\nRecuerde el máximo entero es " << MAXINT; cout << "\n\nDigite un entero negativo: "; cin >> a; cout << "su valor absoluto es " << abs(a); cout << "\n\nDigite un real negativo: "; cin >> x; cout << "su valor absoluto es " << fabs(x); cout << "\n\nDigite un número con decimales: "; cin >> x; cout<<"Mayor entero, menor que " <<x << " = " <<floor(x); cout<<"\nMenor entero, mayor que "<< x << " = "<<ceil(x); cout << "\n\nHipotenusa de un triángulo rectángulo: "; cout << "\nDigite un cateto: "; cin >> x; cout << "\Digite el otro cateto: "; cin >> y; cout << "\nLa hipotenusa es " << hypot(x, y); }

41

3.4 El siguiente programa emplea funciones trigonométricas contenidas en el archivo de cabecera "math.h" #include <iostream.h> #include <conio.h> #include <math.h> //COUT03.CPP void main(){ double angulo = 0.0; //real de doble precisión, 8 bytes = 64 bits clrscr(); cout << " = " << M_PI; cout.precision(7); // se formatean los números con 7 decimales cout.setf(ios::fixed); // se utiliza notación fija en números cout << "\n\nSeno ( " << angulo <<" ) = " << sin(angulo * M_PI/180); angulo += 30.0; cout << "\nCoseno (" << angulo <<" ) = " << cos(angulo * M_PI/180); angulo += 30.0; cout << "\nTangente (" << angulo << " ) = " << sin(angulo*M_PI/180) / cos(angulo*M_PI/180); angulo += 30.0; cout << "\nCotangente(" << angulo << " ) = " << cos(angulo*M_PI/180)/sin(angulo*M_PI/180); angulo -= 30.0; cout << "\nSecante (" << angulo << " ) = " << 1/cos(angulo* M_PI/180); angulo -= 30.0; cout << "\nCosecante (" << angulo << " ) = " << 1/sin(angulo * M_PI/180); cout << "\n = " << M_PI; cout.precision(1); // se formatean los números con 1 decimal cout.setf(ios::scientific); // se utiliza notación científica cout << "\n = " << M_PI; cout << "\n\n Digite cualquier tecla y terminar..."; getch(); } Figura 3.2 Efecto de la ejecución del programa COUT03.CPP

= 3.141593 Seno ( 0 ) = 0 Coseno (30 ) = 0.8660254 Tangente (60 ) = 1.7320508 Cotangente(90 ) = 0 Secante (60 ) = 2 Cosecante (30 ) = 2 = 3.1415927 = 3.1e+00 Digite cualquier tecla y terminar..._

42

3.5 Algunas funciones para el manejo de cadenas de caracteres incluidas en string.h #include <iostream.h> #include <conio.h> #include <string.h> // para efectuar asignación de cadenas utilizar: strcpy() #include <stdio.h> // para leer espacios en blanco utilizar: gets() //COUTIN09.CPP const int LargoCadena=15; //para efectuar dimensionamiento de las variables de cadena void main(){ char cadena1[LargoCadena], cadena2[LargoCadena]; //variables de tipo cadena clrscr(); cout << "Digite una frase para almacenar en la variable cadena1:\n"; cin >> cadena1; cout << "La frase digitada fue: " << cadena1; cout << "\n\nDigite otra frase para almacenar en la variable cadena2:\n"; gets(cadena2); cout << "La frase digitada fue: " << cadena2; cout << "\n\nen este momento cadena1 = " << cadena1; cout << "\na continuación se asigna la cadena2 a la cadena1\n"; strcpy(cadena1, cadena2); cout << "ahora la variable cadena1 = " << cadena1; //En conclusión debe observar que cin<< solo lee hasta el primer espacio //para leer varias palabras tiene que hacerlo con gets(). cout << "\n\nDigite una frase con mucho más de " << LargoCadena << " caracteres\n"; gets(cadena1); cout << "\nlos caracteres almacenados son: " << cadena1; cout << "\n\n es probable que con lo anterior se le bloquee el computador"; cout << "\n\n\n\n\n\ncualquier tecla y seguir"; getch(); } Figura 3.3 Ejecución programa COUT03.CPP en pantalla. Complételo...

43

3.6 El siguiente programa permite oír notas musicales entre 260 Hz y 520 Hz, a través de la utilización de funciones incorporadas en <dos.h>: sound() y nosound(). #include <iostream.h> #include <conio.h> #include <dos.h> //COUT04.CPP const Tempo=1000; // aproximadamente 1000 milisegundos void main(){ clrscr(); sound(260); cout << "Do "; delay(Tempo); sound(290); cout << "Re "; delay(Tempo); sound(322); cout << "Mi "; delay(Tempo); sound(342); cout << "Fa "; delay(Tempo); sound(390); cout << "Sol "; delay(Tempo); sound(440); cout << "La "; delay(Tempo); sound(494); cout << "Si "; delay(Tempo); sound(520); cout << "Do "; delay(Tempo); nosound(); cout << "\nSilencio\n"; delay(Tempo); sound(260); cout << "Do "; delay(Tempo/2); sound(290); cout << "Re "; delay(Tempo/2); sound(322); cout << "Mi "; delay(Tempo/2); sound(342); cout << "Fa "; delay(Tempo/2); sound(390); cout << "Sol "; delay(Tempo/2); sound(440); cout << "La "; delay(Tempo/2); sound(494); cout << "Si "; delay(Tempo/2); sound(520); cout << "Do "; delay(Tempo/2); nosound(); cout << "\nSilencio\n"; delay(Tempo/2); sound(520); cout << "Do "; delay(Tempo/4); sound(494); cout << "Si "; delay(Tempo/4); sound(440); cout << "La "; delay(Tempo/4); sound(390); cout << "Sol "; delay(Tempo/4); sound(342); cout << "Fa "; delay(Tempo/4); sound(322); cout << "Mi "; delay(Tempo/4); sound(290); cout << "Re "; delay(Tempo/4); sound(260); cout << "Do "; delay(Tempo/4); getch(); nosound(); }

44

3.7 El siguiente programa presenta una introducción a las funciones básicas ó primitivas de dibujo del modo gráfico del Turbo C. #include <graphics.h> #include <conio.h> //GRAFICA1.C IniciaModoGrafico(){ int ManejadorGrafico, ModoGrafico; ManejadorGrafico = DETECT; initgraph(&ManejadorGrafico, &ModoGrafico, "C:\\TC\\BGI"); } main(){ int X, Y; IniciaModoGrafico(); X = getmaxx(); Y = getmaxy(); setbkcolor(BLACK); cleardevice(); putpixel(40,40,WHITE); putpixel(42,42,WHITE); putpixel(48,48,WHITE); putpixel(44,44,WHITE); putpixel(46,46,WHITE); putpixel(50,50,WHITE); setcolor(LIGHTMAGENTA); line( 0, 0, X, Y); setcolor(WHITE); rectangle(10,10,X-10,Y-10); setfillstyle(1,CYAN); setcolor(YELLOW); sector(X/2,Y/8,45,300,X/6,Y/10); setfillstyle(1,YELLOW); pieslice(X-X/4,Y-Y/4,40,360,X/6); setcolor(GREEN); setfillstyle(1,LIGHTBLUE); fillellipse(X/2,Y/2,X/20,Y/4); setcolor(BLUE); ellipse(X/2,Y-Y/8,0,360,X/6,Y/10); setcolor(RED); circle(X/4, Y/2, 50 ); setcolor(BROWN); circle(X/4, Y/2, 100 ); setcolor(DARKGRAY); circle(X/4, Y/2, 150 ); setcolor(BLUE); arc(X/2,Y/2,90,270,150); setcolor(LIGHTGREEN); arc(X/2,Y/2,90,270,100); setfillstyle(1,RED); setcolor(WHITE); bar3d(X/2+50,Y/4,X/2+90,Y/2,X/20,1); setfillstyle(1,GREEN); bar(X-20,15,X-50,Y-15); getch(); closegraph(); } Figura 3.5 Ejecución programa GRAFICA1.C en pantalla. Complételo...

45

46

3.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. En este capítulo se presentan ejemplos de funciones definidas por nosotros mismos en nuestro propio algoritmo. A continuación se codifica algoritmo para el cálculo del volumen de un cilindro. Primero observemos que el algoritmo hace básicamente tres cosas: primero la lectura de datos desde el teclado; en segundo lugar efectúa unos cálculos y en tercer lugar muestra en pantalla los resultados. Sabido esto podríamos trabajar las tres situaciones como entidades separadas y al final unirlas en un solo programa, en un diagrama de bloques se vería como en la Figura siguiente: Figura 3.6 Diseño Descendente del Cálculo de un Volumen. ┌────────────────────┐ │ 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.h> #include <conio.h> #include <math.h> // constante para el número : M_PI //FUNCION0.CPP LecturaDesdeTeclado(); //Definición de prototipos de las funciones CalculoConFormula(); EscrituraEnPantalla();

47

float radio, altura, volumen; //Definición de variable globales main(){ //Función principal clrscr(); cout << " CALCULO DEL VOLUMEN DE UN CILINDRO \n"; cout << "─────────────────────────────────────────────────────────\n\n"; LecturaDesdeTeclado(); // invocación de funciones CalculoConFormula(); EscrituraEnPantalla(); getch(); // instrucción de retardo } LecturaDesdeTeclado(){ cout << "Digite el radio de la base del cilindro en centímetros: "; cin >> radio; cout << "Digite la altura del cilindro en centímetros: "; cin >> altura; } CalculoConFormula(){ // volumen = area base( *r²) multiplicada por la altura volumen = M_PI * radio*radio * altura; } EscrituraEnPantalla(){ cout << "\nEl volumen es de " << volumen << " centímetros cúbicos."; cout << "\n\n─────────────────────────────────────────────────────────"; } Obsérvese, en el algoritmo anterior, que las instrucciones empleadas en la función principal, main(), consisten a su vez, de funciones. Cuando se ejecuta una instrucción de este tipo decimos que se está invocando o llamando a la

función en cuestión, esto ocasiona la transferencia de la secuencia del programa a este bloque de código y su seguida ejecución.

Cuando la función termina la secuencia del programa "retorna" a la instrucción siguiente a la de la invocación. Ejecute el programa anterior paso a paso con la tecla de F7, para ver en pantalla digite Alt+F5. El profesor explicará paso a paso en clase magistral este algoritmo. No en todos los programas son necesarias las funciones. 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. Sin duda, el programa seguirá siendo correcto si se escriben estas proposiciones en cada punto del programa donde se necesiten. Sin embargo esta estrategia presenta varios problemas. En primer lugar el programa será más grande de lo necesario. Esto dificultará la lectura, escritura y posterior mantenimiento del programa. Además, los programas fuentes grandes

48

requieren una porción mayor de la memoria de la computadora en tiempo de ejecución. En segundo lugar, se verá con menor claridad la naturaleza del cálculo que realiza el programa. 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. Si esto no se hace así, el lector del programa abrigará sospechas y se preguntará ¿por qué se repite este código, tiene alguna diferencia? La agrupación de instrucciones a través de funciones sugiere que ellas tienen un objetivo en particular, esto aumentará la legibilidad del programa, y más aún, permitirá el dividir el programa descendentemente y dedicarnos al trabajo de bloques de código determinados (por separado y aún por varias personas, sin perder la abstracción de totalidad del programa), para luego unirlos como piezas de un rompecabezas en un solo programa fuente. 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?, empero, es solo por motivos didácticos de apredizaje que se presenta así, y no complicar con mayores detalles la presentación inicial de las funciones. La verdadera importancia solo se vendrá "a sentir" cuando se desarrollen programas más grandes, en próximos semestres. Efectúe pruebas de ejecución manual a cada uno de ellos. 3.9 El siguiente algoritmo presenta el intercambio del valor de dos variables en la memoria RAM del computador. #include <iostream.h> #include <conio.h> //FUNCION1.CPP float a,b; // Variables globales IntercambioEnMemoria(){ float aux; //variable local aux = a; a = b; b = aux; } main(){ clrscr(); cout << "Digite un real para almacenar en variable A: "; cin >> a; cout << "Digite un real para almacenar en variable B: "; cin >> b; IntercambioEnMemoria(); cout << "\nDespués de intercambiadas, A ahora es igual a " << a; cout << "\ny la variable B ahora es igual a " << b; }

49

3.10 El siguiente algoritmo soluciona un sistema lineal de tres incógnitas con tres variables, por el método de Cramer. #include <iostream.h> #include <conio.h> //FUNCION2.CPP float a,b,c,d,e,f,g,h,i,j,k,l, // coeficientes y términos independientes X, Y, Z; // incógnitas a encontrar. void LeerCoeficientes(){ clrscr(); cout << "Digite términos de la Primera Ecuación: \n"; cout << "----------------------------------------\n"; cout << "Coeficiente de X : "; cin >> a; cout << "Coeficiente de Y : "; cin >> b; cout << "Coeficiente de Z : "; cin >> c; cout << "Término independiente: "; cin >> d; cout << "\nDigite términos de la Segunda Ecuación: \n"; cout << "----------------------------------------\n"; cout << "Coeficiente de X : "; cin >> e; cout << "Coeficiente de Y : "; cin >> f; cout << "Coeficiente de Z : "; cin >> g; cout << "Término independiente: "; cin >> h; cout << "\nDigite términos de la Tercera Ecuación: \n"; cout << "----------------------------------------\n"; cout << "Coeficiente de X : "; cin >> i; cout << "Coeficiente de Y : "; cin >> j; cout << "Coeficiente de Z : "; cin >> k; cout << "Término independiente: "; cin >> l; } void CalculoIncognitas(){ float DetX, DetY, DetZ, DetSistema; // Variables locales DetSistema = a*f*k + e*j*c + i*b*g - i*f*c - j*g*a - k*e*b; DetX = d*f*k + h*j*c + l*b*g - l*f*c - j*g*d - k*h*b; DetY = a*h*k + e*l*c + i*l*g - i*h*c - l*g*a - k*e*d; DetZ = a*f*l + e*j*d + i*b*h - i*f*d - j*h*a - l*e*b; X = DetX / DetSistema; Y = DetY / DetSistema; Z = DetZ / DetSistema; } void EscribirResultados(){ cout << "\n\n"; cout << "X = " << X << " Y = " << Y << " Z = " << Z; cout << "\n\nDigite cualquier tecla para terminar..."; getch(); } void main(){ LeerCoeficientes(); CalculoIncognitas(); EscribirResultados(); }

50

3.11 El siguiente algoritmo descompone una cantidad entera en decenas de mil, unidades de mil, centenas, decenas y unidades. #include <iostream.h> #include <conio.h> #include <values.h> //MAXINT //FUNCION4.CPP int entero; //variable entera a descomponer void DescomponerEntero(){ int resto, X=25, Y=12; // (X,Y) serán coordenadas en pantalla para gotoxy() gotoxy(X,Y); cout << "Decenas de mil = " << entero / 10000; resto = entero % 10000; Y--; gotoxy(X,Y); cout << "Unidades de mil = " << resto / 1000; resto = resto % 1000; Y--; gotoxy(X,Y); cout << "Centenas = " << resto / 100; resto = resto % 100; Y--; gotoxy(X,Y); cout << "Decenas = " << resto / 10; Y--; gotoxy(X,Y); cout << "Unidades = " << resto % 10; } main(){ clrscr(); cout << "Recuerde que el máximo entero es: \a" << MAXINT; cout << "\nDigite un entero: "; cin >> entero; DescomponerEntero(); getch(); }

51

3.12 ACTIVIDADES PARA REALIZAR EN GRUPO DE ESTUDIO 3.12.1 Expresiones algebraicas: Evalúe manualmente, como lo haría el computador, las siguientes expresiones. Muestre cálculos paso a paso hasta llegar al resultado final. (16 - 2 * 4 + 7) % 4 * 11 - pow(3, 4) (16 - 2 * 4) + ( 7 % 4 * 11 ) - pow(3, 4) 16 - 2 * 4 * 7 / 3 * ( 18 - pow(2, 3) ) (16 - 2) * (4 * 7) / 3 * 18 - pow(2, 3) 3.12.2 En economía se dispone de fórmulas para calcular los pagos mensuales debidos a un préstamo. Supóngase que se desea pedir un préstamo de P pesos para pagarlo en n pagos mensuales, con una tasa de interés i. La fórmula para calcular el pago mensual, M es: i ( 1 + i )n M = P ----------------- ( 1 + i )n - 1 Codifique la anterior fórmula como una expresión entendible por el computador y dentro de un programa escrito en lenguaje C++. 3.12.3 Solucione un sistema de ecuaciones lineales, compuesto de tres ecuaciones y tres incógnitas, por el método de Cramer. Lea inicialmente los coeficientes (a, b, c, d, e, f, g, h, i, j, k, l) y calcule los valores de las incógnitas X, Y, Z. El sistema general a solucionar, recuerde que son tres rectas en el espacio, es el siguiente: a X + b Y + c Z = d e X + f Y + g Z = h i X + j Y + k Z = l Método de Cramer: calcule inicialmente el determinante del sistema dado, y luego los determinantes particulares para cada variable, así: a b c d b c a d c a b d S = e f g X = h f g Y = e h g Z = e f h i j k l j k i l k i j 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, así: X Y Z X = ---- Y = ---- Z = ---- S S S 3.12.4 ¿Cuál es la conductancia Gt(Siemens) y resistencia equivalente Rt( ) para cuatro resistores de 4 , 10 , 24 y 26 conectados en serie?. ¿Cuál es la caída de voltaje Vi(Voltios) para cada resistencia, si pasa una corriente I de 10 Amperios por el circuito:

52

Rt = R1 + R2 + R3 + R4; Resistencia equivalente 1 Gt = ---- ; conductancia Rt Vi = I Ri ; caída de voltaje en cada resistencia 3.12.5 Digite un ángulo en grados sexagecimales; a continuación conviértalo a radianes y por medio de las funciones trigonométricas incorporadas en la librería <MATH.H> muestre los valores correspondientes a las funciones seno, coseno, tangente, cotangente, secante y cosecante. 3.12.6 Cree sendas funciones para el cálculo de determinantes de grado: 2x2 y 3x3, y resuelva los siguientes ejemplos con el programa diseñado: a) 2 4 b) 1 3 c) 1 3 0 4 8 4 12 4 0 2 1 2 3 d) 3 -4 0 e) 3 5 f) 3 -2 2 2 1 -2 6 -4 5 -1 1 -1 3.12.7 Digite las coordenadas rectangulares de dos puntos (x1, y1) y (x2,y2), obtenga la pendiente m, la ecuación de la línea recta que los une, el ángulo que forma la recta con el eje X, y la distancia D entre ellos, y2 - y1 y - y1 = --------- (x - x1); y - y1 = m (x - x1) x2 - x1 despejando la expresión anterior obtenemos la ecuación de la recta: y = m x - m x1 + y1 Si el término -m x1 + y1 es positivo el signo + no aparecerá en pantalla, de lo contrario, es decir si es negativo, sí aparecerá. La falta del + dará mala presentación a la expresión de la línea recta. ½ D = ( (x2 - x)² + (y2 - y1)² ) = arctg m 3.12.8 Un avión del ejército deja caer una bomba exactamente encima de un objetivo militar de la "subversión". Como comprenderán ustedes señores Bachilleres, la bomba seguirá desplazándose en el sentido (eje X) del movimiento del avión en el momento en que fue soltada, y caerá (Eje Y) debido a la acción de la fuerza de atracción gravitacional a razón de 9.8 m/s². Calcule el ángulo de elevación con que los sobrevivientes, de un palenque cercano donde cayó, a este lamentable y no intencionado incidente reportarían que vieron al avión cuando dejo caer la bomba. Para lo anterior lea por teclado la altura sobre el terreno que en el momento de soltar la bomba, midió el piloto en los instrumentos del avión. Lea por teclado la distancia que esta(estaba) el palenque del objetivo militar, distancia que inteligencia militar había reportado

53

con exactitud al piloto y evitar de esta forma desgracias que lamentar. Con estos dos datos y utilizando sus conocimientos de trigonometría, calcule el ángulo pedido. Sugerencia: dibuje un gráfico de lo acontecido. 3.12.9 Un tecnólogo industrial tiene que controlar la producción de tres clases, 1, 2 y 3, de un determinado producto, el cual está compuesto de tres materiales diferentes: A, B y C; y de los cuales dispone de 1200Kg, 3000Kg y 2564Kg respectivamente. Determinar las cantidades óptimas a producir de cada uno de los modelos, si cada clase del producto es fabricado según la siguiente tabla:

clase A (kg) B (kg) C (kg)

1 2 3

2 7 1

2 10 12

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. De las respuestas debe tomar solo los valores enteros: Balance para el material 1: 1200 = 2 * clase1 + 7 * clase2 + clase3 Balance para el material 2: 3000 = 2 * clase1 + 10 * clase2 + 12 * clase3 Balance para el material 3: 2564 = 16 * clase1 + 5 * clase2 + 13 * clase3 donde clase1, clase2 y clase3 son las cantidades de cada clase de producto solicitadas. 3.12.10 En un almacén se va a efectuar una factura. Para esto leer por teclado el nombre de el cliente, la cantidad total de artículos a comprar por el cliente, el precio unitario de venta al público (PVP), el descuento que se le efectuará por ser "buen cliente". Se debe borrar a continuación la pantalla y que aparezca lo siguiente: Nombre del cliente, total bruto de la factura, total del descuento, el 16% del IVA y el total neto a cancelar. 3.12.11 Sea una matriz A de 2x2: a11 a12 A = a21 a22 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. y se cumple que la matriz inversa es igual a: 1 a22 -a12 b11 b12 A-1 = ----- suponga que: A-1 = Det A -a21 a11 b21 b22 de donde: a22 -a12 -a21 a11 b11 = ---- b12 = ------ b21 = ---- b22 = ------ Det A Det A Det A Det A

54

Lea cada uno de los cuatro términos de la matriz A por teclado. Calcule el determinante de A. Calcule cada término b11, b12, b21, b22 y muestre en pantalla adecuadamente, es decir en filas y columnas. NOTA: La validación de si el determinante de A es cero la dejamos para el siguiente capítulo sobre instrucciones selectivas, mientras tanto, si ese fuera el caso (de malas), el programa se nos "caerá". 3.12.12 Leer N números reales por teclado, y a continuación muestre en pantalla lo siguiente: sumatoria, media o promedio, la varianza y la desviación estándar. En la siguiente fórmula Xi es cada uno de los N números a digitar (Xi - Media)² Varianza = ------------------ N suponga que N es igual a 4 para efectuar su algoritmo en lenguaje C++. La desviación estándar está dada por la raíz cuadrada de la varianza.

55

3.12.13 Efectúe prueba de ejecución manual al siguiente algoritmo. Considere los dos casos: cuando if es verdadero y cuando es falso. Muestre exactamente en pantalla. #include <conio.h> #include <iostream.h> #include <math.h> //IF_MANUA.CPP int p, q=15, r; void Calculos(){ int x; cout << "\nDigite un número entero: "; cin >> x; r = 25 + p * 2 - pow(x,2); } void main(){ clrscr(); cout << "Q = " << q; cout << "\n\nDigite un número entero: "; cin >> p; r = q + p * 2; if (q <= p) cout << q << " es menor o igual a " << p; else Calculos(); cout << "\nP = " << p; cout << "\nR = " << r; } Efectúe a continuación prueba de ejecución manual del algoritmo del anterior programa IF_MANUA.CPP. Llene el siguiente tabulado, "pantalla" y los cálculos necesarios: Variables en forma tabular "PANTALLA"

p q r x

Escriba aquí los cálculos necesarios:

r = 25 + p * 2 - pow(x,2); r = q + p * 2;

57

CCAAPPÍÍTTUULLOO 44 IINNSSTTRRUUCCCCIIÓÓNN SSEELLEECCTTIIVVAA IIFF 4.1 METODOLOGÍA Estudie el tema presentado en esta lección antes de ir a la correspondiente clase magistral. 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, recuerde que es "obligatorio" el llevar este módulo a todas las clases. Luego diríjase al computador y del disquete anexo cargue los archivos de los programas correspondientes a este capítulo. Después de ejecutarlos efectúeles todas las modificaciones que se le ocurran; a este trabajo debe dedicarle mínimo 10 horas, hasta que le queden "los ojos cuadrados", ya a estas alturas debe sentir el trabajo en computador como un "chicle", en caso contrario efectúe seria reflexión de sus intereses. Efectúe pruebas de ejecución manual a los programas que el profesor no explicó en la clase magistral, en forma personal y luego en Grupo de estudio. 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. Dogmáticamente podríamos decir que "llegará a tener fe" en que determinadas instrucciones producen determinados resultados y no otros. 4.2 INSTRUCCIÓN Si - Entonces DIAGRAMA DE FLUJO 4.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 ...

58

Un programa, basándose en los datos que reciba, puede elegir entre distintas acciones a seguir. Sin embargo si se quiere que tome decisiones, se le debe indicar específicamente qué información debe utilizar, cómo evaluarla y que acciones seguir. Este tipo de acción se denomina bifurcación, y se ejecuta basándose en la evaluación lógica de los datos. La forma más sencilla de bifurcación condicional es la sentencia Si-Entonces, la cual hace que un programa ejecute el bloque de código el cual esta a continuación, si es cierta la condición, en caso contrario no lo ejecutará. En el lenguaje C la instrucción Entonces(Then) está tácita, y no se debe colocar. 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. Esta evaluación produce uno de dos resultados posibles: cierto (True) o falso (False). Si la evaluación es cierta el algoritmo seguirá en el bloque de instrucciones que está inmediatamente después, si el resultado es falso, la secuencia del algoritmo se salta este bloque de instrucciones. En el C/C++ el bloque de instrucciones a continuación estará delimitado por la pareja de corchetes: { } para abrir y cerrar respectivamente. En caso de que el bloque de código a efectuar, si es verdadera la evaluación, conste de una sola instrucción, no es necesario utilizar los delimitadores: { }. Sea la evaluación de la instrucción Si(if) verdadera o falsa, en cualquiera de los dos casos, el flujo del algoritmo continuará secuencialmente. TABLA 4.1 Sintaxis de la instrucción Si (If) en la forma más simple:

Pseudocódigo en Español Lenguaje C/C++

... Si (expresión lógica) Entonces ... instrucción(es) ... Fin_Si ... ... ... ...

... if (expresión lógica){ ... ; instrucción(es); ... ; } ... ; ... ; ... ; if (expresión lógica) instrucciónUnica; ... ; ... ; ... ;

4.3 El siguiente ejemplo utiliza la instrucción selectiva if, de la forma más elemental. #include <iostream.h> #include <conio.h> //IF_0.CPP main(){ int numero; clrscr(); cout << "Digite un número: ";

59

cin >> numero; if (numero > 100) cout << "Se digitó un número mayor a 100"; getch(); } FIGURA 4.1 Pantalla del programa IF_0.CPP. Al correr el programa

Digite un número:

FIGURA 4.2 Pantalla del programa IF_0.CPP. Se digita un entero

Digite un número: 159_

FIGURA 4.3 Pantalla del programa IF_0.CPP. Se da la tecla de ENTRAR

Digite un número: 159 Se digitó un número mayor a 100_

FIGURA 4.4 Pantalla del programa IF_0.CPP. Otra corrida

Digite un número: _

FIGURA 4.5 Pantalla del programa IF_0.CPP. Entero digitado y ENTRAR

Digite un número: 50 _

60

4.4 El siguiente algoritmo utiliza la instrucción selectiva if, con un bloque de código, delimitado con { }. #include <iostream.h> #include <conio.h> //IF_00.CPP main(){ int numero; clrscr(); cout << "Digite un número: "; cin >> numero; if (numero > 100){ numero = numero + 10; cout << "Se digitó un número mayor a 100 \n"; cout << "y a continuación se incrementa en 10 para dar "; } cout << numero; getch(); } FIGURA 4.6 Pantalla del programa IF_00.CPP. El IF es verdadero.

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. Observe que la variable número tomó inicialmente el valor de 236, al ser digitado por teclado, y luego se incremento en 10 para tomar el valor de 246, que es el que finalmente muestra en pantalla. FIGURA 4.7 Pantalla del programa IF_00.CPP. El IF es falso.

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. Observe que la variable número tomo inicialmente el valor de 93, al ser digitado por teclado. El IF al ser falso, el algoritmo continúa en la instrucción: cout << numero, mostrando de esta forma, la variable numero, el mismo valor que se digitó.

61

4.5 El siguiente algoritmo presenta un error de lógica, el compilador no detectará ningún error. #include <iostream.h> #include <conio.h> //IF_000.CPP main(){ int numero; clrscr(); cout << "Digite un número: "; cin >> numero; if (numero > 100); // punto y coma da a entender que el if termina cout << "Se digitó un número mayor a 100"; getch(); } FIGURA 4.8 Pantalla del programa IF_000.CPP. El IF es verdadero.

¡Error! Marcador no definido. Digite un número: 214 Se digitó un número mayor a 100_

FIGURA 4.9 Pantalla del programa IF_000.CPP. El IF es falso. OJO CON ESTE ERROR

¡Error! Marcador no definido. Digite un número: 39 Se digitó un número mayor a 100_

4.6 El siguiente algoritmo calcula el número medio entre tres enteros, no es el promedio. #include <iostream.h> #include <conio.h> //IF_01.CPP main(){ int a, b, c; clrscr(); cout << "Digite entero: "; cin >> a; cout << "Digite entero: "; cin >> b; cout << "Digite entero: "; cin >> c; if ( (b<a && a<c) || (c<a && a<b) ) cout << a << " es el del medio"; if ( (a<b && b<c) || (c<b && b<a) ) cout << b << " es el del medio"; if ( (a<c && c<b) || (b<c && c<a) ) cout << c << " es el del medio"; }

62

4.7 INSTRUCCIÓN SI - ENTONCES - SINO TABLA 4.2 Sintaxis general de la instrucción Si (If) es:

¡Error! Marcador no definido. Pseudocódigo en Español

Lenguaje C/C++

... Si (expresión lógica) Entonces ... instrucción(es) ... Si_No ... instrucción(es) ... Fin_Si ... ... ...

... If (expresión lógica){ ... ; instrucción(es); ... ; } Else{ ... ; instrucción(es) ... ; } ... ; ... ;

DIAGRAMA DE FLUJO 4.2 instrucciones Si-Entonces-Si_No.

¡Error! Marcador no definido. Viene el algoritmo secuencialmente │ ┌────────┴────────┐ │ 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, en el caso de verdadero, ahora veremos la forma completa de la misma instrucción. De esta forma y teniendo en cuenta los datos que reciba a evaluar el Si, 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.

63

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, en caso contrario, es decir cuando la condición es falsa, se ejecutará el bloque de código que está a continuación de la instrucción SINO(else). Repitiendo una vez más, 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. Esta evaluación produce uno de dos resultados posibles: cierto (True) o falso (False). Si la evaluación es cierta el algoritmo seguirá en el bloque de instrucciones que está inmediatamente después, si el resultado es falso, la secuencia del algoritmo seguirá a continuación del SINO(else). En el C/C++ el bloque de instrucciones a continuación, ya sea de la parte que evalúe cuando sea verdadero el Si o la parte que evalúe cuando sea falsa, deberá estar delimitada por los corchetes: { } para abrir y cerrar respectivamente. Lo mismo que para el caso de verdadero, si el bloque de código a efectuar, cuando la evaluación sea falsa, conste de una sola instrucción, no es necesario utilizar los delimitadores: { }. Sea la evaluación de la instrucción Si(if) verdadera o falsa, en cualquiera de los dos casos, el flujo del algoritmo continuará secuencialmente, en la siguiente instrucción.

64

4.8 El siguiente algoritmo utiliza la instrucción selectiva if en su forma completa y de la forma más elemental, es decir sin bloques de código delimitados. #include <iostream.h>

//IF_000.CPP main(){ int numero; cout << "Digite un número: "; cin >> numero; if (numero > 100) cout << "Se digitó un número mayor a 100"; else cout << "Se digitó un número menor o igual a 100"; } FIGURA 4.10 Efecto en pantalla del programa IF_000.CPP. Caso verdadero.

¡Error! Marcador no definido. Digite un número: 154 Se digitó un número mayor a 100

FIGURA 4.11 Efecto en pantalla del programa IF_000.CPP. Caso de falso

¡Error! Marcador no definido. Digite un número: 65 Se digitó un número menor o igual a 100

65

4.9 El siguiente algoritmo utiliza la instrucción selectiva if en su forma completa y con bloques de código delimitados entre { }. #include <iostream.h> //IF_0000.CPP main(){ int numero; clrscr(); cout << "Digite un número: "; cin >> numero; if (numero > 100){ cout << "Se digitó un número mayor a 100 \n"; numero = numero + 10; cout << "y a continuación se incrementa en 10 para dar " ; } else{ cout << "Se digitó un número menor o igual a 100 \n"; numero = numero - 10; cout << "y a continuación se decrementa en 10 para dar " ; } cout << numero; } FIGURA 4.12 Pantalla del programa IF_0000.CPP. El IF es verdadero.

¡Error! Marcador no definido. 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. 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, que es el que finalmente muestra en pantalla. FIGURA 4.13 Pantalla del programa IF_0000.CPP. El IF es falso.

¡Error! Marcador no definido. 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_

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. Observe que la variable numero tomo inicialmente el valor de 93 al ser digitado por teclado. 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.

66

4.10 Este programa tiene un error de tipo lógico en las llaves { } del if. El compilador no dará ningún error. Explique este error. #include <iostream.h> #include <conio.h> main(){ int numero; clrscr(); cout << "Digite un número menor o igual a 100: "; cin >> numero; if (numero > 100) numero = numero + 10; cout << "Se digitó un número mayor a 100 \n"; cout << "y a continuación se incrementa en 10 para dar " << numero; getch(); } 4.11 Este programa presenta un error de sintaxis en la instrucción else, debido a la falta de delimitadores { }. Corríjalo. El compilador no lo dejará ejecutar. #include <iostream.h> //IF0ERROR.CPP main(){ int numero; cout << "Digite un número: "; cin >> numero; if (numero > 100) cout << "Se digitó un número mayor a 100 \n"; numero = numero + 10; cout << "y a continuación se incrementa en 10 para dar " ; else{ cout << "Se digitó un número menor o igual a 100 \n"; numero = numero - 10; cout << "y a continuación se decrementa en 10 para dar " ; } cout << numero; getch(); }

67

4.12 El siguiente algoritmo calcula el número medio entre tres enteros, no es el promedio. Segunda versión. #include <iostream.h> #include <conio.h> //IF_02.CPP main(){ int a, b, c; clrscr(); cout << "Digite entero: "; cin >> a; cout << "Digite entero: "; cin >> b; cout << "Digite entero: "; cin >> c; if ( (b<a && a<c) || (c<a && a<b) ) cout << a << " es el del medio"; else if ( (a<b && b<c) || (c<b && b<a) ) cout << b << " es el del medio"; else cout << c << " es el del medio"; getch(); } 4.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". //IF_03.CPP #include <iostream.h> #include <conio.h> main(){ float a, b; clrscr(); cout << "Digite real: "; cin >> a; cout << "Digite real: "; cin >> b; if ( a > 0 && b > 0) cout << "\nLOS DOS SON POSITIVOS"; else if (a < 0 && b < 0) cout << "\nLOS DOS SON NEGATIVOS"; else cout << "\nTIENEN DIFERENTE SIGNO"; getch(); }

68

4.14 Se digitan tres palabras y a continuación se ordenan alfabéticamente. #include <iostream.h> #include <conio.h> #include <string.h> //IF_04.CPP void main(){ char p1[25], p2[25], p3[25]; clrscr(); cout << "Digite tres palabras separadas por espacios en blanco: \n"; cin >> p1 >> p2 >> p3; if (strcmp(p1,p2)<0 && strcmp(p2,p3)<0) cout << p1 << " " << p2 << " " << p3; else if (strcmp(p1,p3)<0 && strcmp(p3,p2)<0) cout << p1 << " " << p3 << " " << p2; else if (strcmp(p2,p1)<0 && strcmp(p1,p3)<0) cout << p2 << " " << p1 << " " << p3; else if (strcmp(p2,p3)<0 && strcmp(p3,p1)<0) cout << p2 << " " << p3 << " " << p1; else if (strcmp(p3,p1)<0 && strcmp(p1,p2)<0) cout << p3 << " " << p1 << " " << p2; else cout << p3 << " " << p2 << " " << p1; getch(); } 4.15 Dados dos enteros leídos desde teclado, ¿uno es divisor del otro? //IF_05.CPP #include <iostream.h> #include <conio.h> main(){ int x, y; clrscr(); cout << "Digite separados por un espacio dos números enteros: "; cin >> x >> y; if (x % y == 0) cout << y << " es divisor de " << x; else if (y % x == 0) cout << x << " es divisor de " << y; else cout << "No son divisores entre si\a"; }

69

4.16 Se calcula el valor de Y en función de X, teniendo en cuenta los siguientes intervalos: Y = X^2 - 4 si X<=4 Y = X^3 + 2X - 31 si X>4 y X<=10 Y = 3X^2 - 10.5X - 3 si X>10 #include <iostream.h> #include <conio.h> #include <math.h> //IF_06.CPP main(){ float x, y; clrscr(); cout << "Digite valor de la variable independiente X: "; cin >> x ; if (x <= 4) y = x*x - 4; else if (x <= 10) y = pow(x,3) + 2*x - 31; else y = 3*x*x - 10.5*x - 3; cout << "\nVariable dependiente Y = " << y; getch(); }

70

4.17 Una pizzería vende pizzas de tres tamaños: pequeña, mediana y grande. En ella se determina el precio de venta al público(PVP), así: + Un costo fijo igual para todos los tamaños + Un costo variable, dependiente del tamaño, el cual se determina multiplicando un factor, obtenido empíricamente, para cada tamaño por su correspondiente costo fijo. ------------------------------------------------------------------- = 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. 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, de la siguiente forma: pequeña=1.5, mediana=2.0 y grande=3.0. Mostrar finalmente el PVP en pantalla de la pizza solicitada. #include <iostream.h> #include <conio.h> //IF_11.CPP main(){ const int CostoFijo = 1000; const float FactorPequena = 1.5; const float FactorMediana = 2.0; const float FactorGrande = 3.0; float CostoVariable, PVP; char Tamano; clrscr(); cout << "Tipos de pizza: Pequeña Mediana Grande\n"; cout << "Digite inicial de tamaño de pizza a comprar: "; cin >> Tamano; if (Tamano == 'P' || Tamano == 'p') CostoVariable = FactorPequena * CostoFijo; else if (Tamano == 'M' || Tamano == 'm') CostoVariable = FactorMediana * CostoFijo; else CostoVariable = FactorGrande * CostoFijo; PVP = (CostoFijo + CostoVariable) * 1.2; cout << "Precio de Venta al Público = $ " << PVP; getch(); }

71

4.18 Dados tres valores numéricos por teclado, a, b c: se imprime el mayor, el menor y se calcula su promedio. //IF_07.CPP #include <iostream.h> #include <conio.h> main(){ float a, b, c, menor, mayor, promedio; clrscr(); cout << "Digite valor para a: "; cin >> a; cout << "Digite valor para b: "; cin >> b; cout << "Digite valor para c: "; cin >> c; if (a > b && a > c) cout << "Mayor es " << a; else if (b > a && b > c) cout << "Mayor es " << b; else cout << "Mayor es " << c; if (a < b && a < c) cout << " Menor es " << a; else if (b < a && b < c) cout << " Menor es " << b; else cout << " Menor es " << c; promedio = (a + b + c) / 3; cout << " Promedio de los tres números = " << promedio; getch(); } 4.19 El siguiente programa permite leer la hora, minutos y segundos en un instante de tiempo; y a continuación presenta la hora un segundo después. La

hora aparecerá en el formato HH:MM:S, debiendo aparecer los seis dígitos aún cuando sean ceros. //IF_09.CPP #include <iostream.h> #include <conio.h> main(){ int hora, minuto, segundo; clrscr(); cout << "Digite hora(1-12): "; cin >> hora; cout << "Digite minutos (0-59): "; cin >> minuto; cout << "Digite segundos (0-59): "; cin >> segundo; segundo = segundo + 1;

72

if (segundo == 60){ segundo = 0; minuto = minuto + 1; if (minuto == 60){ minuto = 0; hora = hora + 1; if (hora == 13) hora = 1; } } if ( hora < 10) cout << "0" << hora << ":"; else cout << hora << ":"; if (minuto < 10) cout << "0" << minuto << ":"; else cout << minuto << ":"; if (segundo < 10) cout << "0" << segundo; else cout << segundo; getch(); } Efectúe a continuación prueba de ejecución manual del algoritmo del anterior programa IF_09.CPP. Llene el siguiente tabulado, con los valores correspondientes y coloque simultáneamente en pantalla lo que "cree" aparece en ella: Variables en forma tabular "PANTALLA"

¡Error! Marcador no definido. segundo

minuto hora

73

4.20 Dado el número de un mes, digitado desde teclado, y si el año es bisiesto, se determina el nombre y el número de días del mes correspondiente. #include <iostream.h> #include <conio.h> #include <string.h> // strcpy(cadena1,cadena2): asigna cadena2 a cadena1 // strcmp(cadena1,cadena2): si cadena1==cadena2 devuelve cero //IF_10.CPP main(){ int Mes, NumeroDias; char NombreMes[10], Bisiesto; clrscr(); cout << "Digite el número de un mes(1 - 12): "; cin >> Mes; if (Mes == 1){ strcpy(NombreMes, " Enero "); NumeroDias = 31; } else if (Mes == 2){ strcpy(NombreMes, " Febrero "); cout << "¿Es el año bisiesto? (S/N): "; cin >> Bisiesto; if (Bisiesto == 'S' || Bisiesto == 's') // || operador lógico O NumeroDias = 29; else NumeroDias = 28; } else if (Mes == 3){ strcpy(NombreMes, " Marzo "); NumeroDias = 31; } else if (Mes == 4){ strcpy(NombreMes, " Abril "); NumeroDias = 30; } else if (Mes == 5){ strcpy(NombreMes, " Mayo "); NumeroDias = 31; } else if (Mes == 6){ strcpy(NombreMes, " Junio "); NumeroDias = 30; } else if (Mes == 7){ strcpy(NombreMes, " Julio "); NumeroDias = 31; } else if (Mes == 8){ strcpy(NombreMes, " Agosto "); NumeroDias = 31;

74

} else if (Mes == 9){ strcpy(NombreMes, " Septiembre "); NumeroDias = 30; } else if (Mes == 10){ strcpy(NombreMes, " Octubre "); NumeroDias = 31; } else if (Mes == 11){ strcpy(NombreMes, " Noviembre "); NumeroDias = 30; } else if (Mes == 12){ strcpy(NombreMes, " Diciembre "); NumeroDias = 31; } else strcpy(NombreMes, " Error "); if (strcmp(NombreMes, " Error ") == 0) cout << "Se equivocó al digitar número del 1 al 12\a\a"; else cout << NombreMes << "tiene " << NumeroDias << " días"; }

75

4.21 Se lee desde teclado el nombre de un empleado, su salario básico por hora y el número de horas trabajadas durante una semana. Se calcula el salario neto, teniendo en cuenta si el número de horas trabajadas en la semana es mayor a 48, esas horas de más se consideran como extras y tienen un 35% de recargo. Al final se muestra el nombre y el salario neto a cancelar al empleado en pantalla. #include <iostream.h> #include <conio.h> #include <stdio.h> //IF_12.CPP main(){ char NombreEmpleado[23];

float BasicoPorHora, HoraSemanales, HorasExtras, SalarioSemanal; clrscr(); cout << "Digite el nombre y apellido del empleado: "; gets(NombreEmpleado); cout << "\nDigite el salario básico por hora: "; cin >> BasicoPorHora; cout << "\nDigite el número de horas laboradas en esta semana: ";

cin >> HoraSemanales;

if (HoraSemanales <= 48) SalarioSemanal = BasicoPorHora * HoraSemanales;

else{ HorasExtras = HoraSemanales - 48;

SalarioSemanal = BasicoPorHora*48 + HorasExtras*BasicoPorHora*1.35; } cout <<"\n" <<NombreEmpleado <<" devengará esta semana $" << SalarioSemanal; getch(); }

76

4.22 Se desarrolla un algoritmo para leer desde el teclado el nombre de un empleado, su salario básico por mes y el número de horas trabajadas durante el mismo. Se debe calcular el salario bruto, la retención en la fuente y el salario neto. Para el calculo de la retención en la fuente se debe tener en cuenta lo siguiente: Para salarios brutos hasta $890,000 no hay retención en la fuente mayores a $890,000 y menores o iguales a $2'000,000 retención del 5% desde $2'00,001 y menores o iguales a $4'000,00 retención del 8% mayores a $4'000,000 retención del 12% IF_13.CPP*/ #include <iostream.h> #include <conio.h> #include <stdio.h> main(){ char NombreEmpleado[32]; float BasicoMensual, HorasMensuales, ReteFuente, SalarioBruto, SalarioNeto, BasicoHora; clrscr(); cout << "Digite el nombre y apellido del empleado: "; gets(NombreEmpleado); cout << "\nDigite el salario básico Mensual: "; cin >> BasicoMensual; cout << "\nDigite el número de horas laboradas en este mes: "; cin >> HorasMensuales; BasicoHora = BasicoMensual / 30 / 8; // 30 días al mes, 8 horas diarias SalarioBruto = BasicoHora * HorasMensuales; if (SalarioBruto <= 890000) ReteFuente = 0; else if (SalarioBruto <= 200000) ReteFuente = SalarioBruto*5.0/100; else if (SalarioBruto <= 400000) ReteFuente = SalarioBruto*8.0/100; else ReteFuente = SalarioBruto*12.0/100; SalarioNeto = SalarioBruto - ReteFuente; clrscr(); cout << "Nombre Empleado: " << NombreEmpleado; cout << "\nSalario Básico mensual: " << BasicoMensual; cout << "\nSalario Básico por hora: " << BasicoHora; cout << "\nHoras trabajadas en el mes: " << HorasMensuales; cout << "\nSalario Bruto: " << SalarioBruto; cout << "\nRetención en la fuente: " << ReteFuente; cout << "\nSalario Neto A cancelar: $ " << SalarioNeto; }

77

4.23 Se calcula el jornal a pagar, a destajo, a un trabajador, el cual labora en una empresa que tiene dos turnos: diurno y nocturno. La tarifa por hora diurna es de $1,000 y la nocturna de $1,500. Si es festivo la tarifa se incrementará en $500 el turno diurno y en $1,000 el nocturno. #include <iostream.h> #include <conio.h> #include <stdio.h> //IF_14.CPP main(){ char NombreTrabajador[30]; float Jornal, Horas; char Turno, Festivo; clrscr(); cout << "Digite el nombre y apellido del trabajador: "; gets(NombreTrabajador); cout << "Turno Diurno o Nocturno (D/N): "; cin >> Turno; cout << "¿Es festivo? (S/N): "; cin >> Festivo; cout << "Número de horas laboradas en el día: "; cin >> Horas; if (Turno == 'D' || Turno == 'd') if (Festivo == 'S' || Festivo == 's') Jornal = Horas * (1000 + 500); else Jornal = Horas * 1000; else if (Festivo == 'S' || Festivo == 's') Jornal = Horas * (1500 + 1000); else Jornal = Horas * 1500; cout << "\n\nJornal a cancelar a " << NombreTrabajador << " $" << Jornal; getch(); } FIGURA 4.14 Pantalla del programa IF_14.CPP. Complétela usted mismo

¡Error! Marcador no definido.

78

4.24 Se lee el nombre, edad, 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, si es un menor de edad, si es menor de edad casado y si es un hombre mayor de 60 años y soltero. #include <iostream.h> #include <conio.h> #include <stdio.h> //IF_15.CPP main(){ char Nombre[20]; int Edad; char Sexo, EstadoCivil; clrscr(); cout << "Digite el nombre del encuestado: "; gets(Nombre); cout << "Sexo (M/F): "; cin >> Sexo; cout << "Edad: "; cin >> Edad; cout << "Estado Civil (Casado, Soltero, Otro): "; cin >> EstadoCivil; if((Sexo=='M' || Sexo=='m')&&(Edad>60) &&(EstadoCivil=='S' || EstadoCivil=='s')) cout << Nombre << " hombre solterón mayor de 60 años"; else if ( (Sexo == 'F' || Sexo == 'f') && (Edad> 40) && (EstadoCivil == 'C' || EstadoCivil == 'c') ) cout << Nombre << " es una Mujer Casada mayor de 40 años"; else if (Edad < 18){ cout << Nombre << " es un menor de edad "; if (EstadoCivil == 'C' || EstadoCivil == 'c') cout << " casado"; } else cout << "\n\aNo cumple ninguna de las condiciones solicitadas"; getch(); }

79

4.25 Se desarrolla un algoritmo el cual permite leer desde teclado los datos siguientes de una persona: nombre, edad, sexo y estado civil; 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. #include <iostream.h> #include <conio.h> #include <stdio.h> #include <ctype.h> // toupper() pasa a mayúscula //IF_16.CPP main(){ int Edad; char Sexo, EstadoCivil; char Nombre[25]; clrscr(); cout << "Digite el nombre del encuestado: "; gets(Nombre); cout << "Sexo (M/F): "; cin >> Sexo; Sexo = toupper(Sexo); cout << "Edad: "; cin >> Edad; cout << "Estado Civil (Casado, Soltero, Otro): "; cin >> EstadoCivil; EstadoCivil = toupper(EstadoCivil); if ( ( Sexo=='M' && Edad<30 ) || ( Sexo=='F' && Edad<50 ) ) cout << "\n" << Nombre << " Cumple una de las condiciones"; else cout << "\n\aNo cumple ninguna de las condiciones solicitadas"; getch(); } FIGURA 4.15 Complete prueba de ejecución manual del programa IF_16.CPP.

¡Error! Marcador no definido.

80

4.26 ACTIVIDADES PARA REALIZAR EN GRUPO DE ESTUDIO 4.26.1Desarrolle un algoritmo el cual lea desde teclado el nombre, edad, sexo y estado civil de una persona, 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. 4.26.2 Lea un registro desde teclado compuesto de los siguientes tres campos: nombre, salario mensual y porcentaje de retención en la fuente. Si la persona gana más de $590,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 $890,000 presentar el siguiente mensaje: "NO EFECTUAR RETENCIÓN EN LA FUENTE". 4.26.3 El costo de enviar por correo es de $300 para cartas que pesan menos de 30 grs. y $5 por cada gramo adicional para cartas que pesan más de 30 grs. Leer un número real el cual representará el peso de la carta y luego muestre el costo de enviar la carta. 4.26.4 Desarrolle un programa el cual determine si un triángulo es equilátero, isósceles o escaleno por medio de la lectura desde teclado de sus ángulos interiores, valide previamente que la suma sea 180 . 4.26.5 Simule emitir el total de una factura considerando lo siguiente: leer la cantidad, el nombre del artículo y el precio unitario. Si el total bruto da mayor de $150,000 hacer un descuento del 2%, si es mayor a $300,000 hacer un 3% de descuento adicional de descuento. Finalmente agregar el 14% de IVA. 4.26.6 Dado un número entero, presentarlo en pantalla con formato monetario con separación de miles y precedido por el signo $. Ejemplo: Entrada 32420 debe producir en pantalla: $32,420.00. Sugerencia: Descomponga el número como unidades, decenas, centenas, etc. Suponga hasta un máximo valor para los enteros de 32678. 4.26.7 Rehaga el algoritmo sobre la regla de Cramer, para solucionar un sistemas de tres ecuaciones con tres incógnitas. Si el sistema no tiene solución, y esto ocurre cuando el determinante del sistema es cero, muestre en pantalla: "EL SISTEMA NO TIENE SOLUCIÓN". 4.26.8 Rehaga el algoritmo el cual permite leer dos puntos desde el teclado y calcular la pendiente, el ángulo de inclinación, y la ecuación de la línea recta. Se debe recordar que cuando el término independiente de la ecuación de la línea recta es positivo, el + no aparece en pantalla. Hágalo aparecer con la utilización de la instrucción Si. 4.26.9 Una Compañía al recibir el pago de las facturas pendientes, a cada uno de sus cliente, efectúa los siguientes pasos: Inicia leyendo por teclado el nombre del cliente, número de cédula de ciudadanía, el total de la factura y el número del día(0-31) en que está cancelando. Si el cliente paga dentro de los diez primeros días, de cada mes, se le descuenta sobre la factura un 3% y hasta un máximo (de descuento) de $20,000, por pronto pago. Debe aparecer en pantalla un aviso que diga: "CANCELANDO ANTICIPADAMENTE".

81

Si paga dentro de los diez días(11-20) siguientes paga el total de la factura. Debe aparecer en pantalla un aviso que diga: "CANCELANDO AL DÍA". Si paga dentro de los últimos días(21-31) se le cobra un recargo sobre la factura del 3.5% y unos gastos administrativos por cobranza a morosos de $5,000. En este caso debe aparecer un aviso de advertencia en pantalla que diga: "CANCELANDO TARDÍAMENTE". 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, valor original de la factura, el descuento o recargos, y el neto a cancelar en efectivo.

83

CCAAPPÍÍTTUULLOO 55¡¡EErrrroorr!! MMaarrccaaddoorr nnoo ddeeffiinniiddoo.... IINNSSTTRRUUCCCCIIÓÓNN SSEELLEECCTTIIVVAA SSWWIITTCCHH 5.1 METODOLOGÍA Estudie el tema presentado en esta lección antes de ir a la correspondiente clase magistral. 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, incluyendo lo mínimo necesario para el manejo de cadenas de caracteres. 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 computador y del disquete anexo cargue los archivos de los programas correspondientes a este capítulo. Después de ejecutarlos realícele 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, en forma personal y luego en Grupo de estudio; efectúe los algoritmos de tarea asignados al final de esta lección. Debe dedicarle a esto unas tres horas. 5.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, se puede utilizar esta instrucción. La instrucción switch proporciona una forma clara de bifurcación múltiple. TABLA 5.1 Sintaxis general de la instrucción En Caso de (switch):

¡Error! Marcador no definido. Pseudocódigo en Español

Lenguaje C/C++

... SegúnSea (variable) hacer valor1: instrucción(es) valor2: instrucción(es) ... valorN: instrucción(es) Si_No: instrucción(es) FinSegúnSea ... ...

... ; switch (variable) { case v1: instrucción(es); break; case v2: instrucción(es); break; ... case vN: instrucción(es); break; default: instrucción(es) } ... ; ... ;

84

5.3 Dado el número de un día de la semana, hacer aparecer el nombre del día correspondiente: #include <iostream.h> #include <conio.h> //SWITCH_1.CPP void main(){ int Dia; clrscr(); cout << "Digite el número de un día de la semana(1 - 7): "; cin >> Dia; switch (Dia) { case 1: cout << "Es día es LUNES"; break; case 2: cout << "El día es MARTES"; break; case 3: cout << "El día es MIERCOLES"; break; case 4: cout << "El día es JUEVES"; break; case 5: cout << "El día es VIERNES"; break; case 6: cout << "El día es SABADO"; break; case 7: cout << "El día es DOMINGO"; break; default: cout << "\aERROR, no es un entero válido"; } getch(); }

85

5.4 Dado el número de un mes, digitado desde teclado, y si el año es bisiesto, se determina el nombre y el número de días del mes correspondiente. //SWITCH_4.CPP #include <iostream.h> #include <conio.h> #include <string.h> // strcpy(cadena1,cadena2): asigna cadena2 a cadena1 //strcmp(cadena1,cadena2): si cadena1==cadena2 devuelve cero main(){ int Mes, NumeroDias; char NombreMes[10]; char Bisiesto; clrscr(); cout << "Digite el número de un mes(1 - 12): "; cin >> Mes; switch (Mes) { case 1: strcpy(NombreMes, " Enero "); NumeroDias = 31; break; case 2: strcpy(NombreMes, " Febrero "); cout << "¿Es el año bisiesto? (S/N): "; cin >> Bisiesto; if (Bisiesto == 'S' || Bisiesto == 's') // || operador lógico O NumeroDias = 29; else NumeroDias = 28; break; case 3: strcpy(NombreMes, " Marzo "); NumeroDias = 31; break; case 4: strcpy(NombreMes, " Abril "); NumeroDias = 30; break; case 5: strcpy(NombreMes, " Mayo "); NumeroDias = 31; break; case 6: strcpy(NombreMes, " Junio "); NumeroDias = 30; break; case 7: strcpy(NombreMes, " Julio "); NumeroDias = 31; break; case 8: strcpy(NombreMes, " Agosto "); NumeroDias = 31; break; case 9: strcpy(NombreMes, " Septiembre "); NumeroDias = 30; break; case 10:strcpy(NombreMes, " Octubre "); NumeroDias = 31; case 11:strcpy(NombreMes, " Noviembre "); NumeroDias = 30; case 12:strcpy(NombreMes, " Diciembre "); NumeroDias = 31; break; default: strcpy(NombreMes, " Error ");

86

} if (strcmp(NombreMes, " Error ") == 0) cout << "Se equivocó al digitar número del 1 al 12\a\a"; else cout << NombreMes << "tiene " << NumeroDias << " días"; }

87

5.5 Se lee un número entero entre 1 y 999, y a continuación se redondea a la decena más próxima. //SWITCH_2.CPP #include <iostream.h> #include <conio.h> void main(){ int numero, resto, centena, decena, unidad; clrscr(); cout << "Digite un número entero para redondearlo:\n"; cin >> numero; centena = numero / 100; resto = numero % 100; decena = resto / 10; unidad = resto % 10; switch (unidad) { case 0: ; case 1: ; case 2: ; case 3: ; case 4: numero = centena*100 + decena*10; break; case 5: ; case 6: ; case 7: ; case 8: ; case 9: numero = centena*100 + (decena+1)*10; } cout << numero; getch(); }

88

5.6 El siguiente programa presenta un menú en pantalla. Le servirá como plantilla para diseñar sus programas. Se efectúa invocación recursiva de la función main(). //SWITCH_5.CPP #include <iostream.h> #include <conio.h> void funcion1(){ clrscr(); cout << "Función 1"; getch(); } void funcion2(){ clrscr(); cout << "Función 2"; getch(); } void funcion3(){ clrscr(); cout << "Función 3"; getch(); } void main(){ char opcion; clrscr(); cout << "\t\t\tESTE ES EL MENU PRINCIPAL"; cout << "\n\n\n\t\t\tA. Función 1.....\n"; cout << "\n\t\t\tB. Función 2.....\n"; cout << "\n\t\t\tC. Función 3.....\n"; cout << "\n\t\t\tS. Salir\n"; cout << "\n\n\t\tDigite una opción: "; opcion = getch(); switch ( opcion ) { case 'A': case 'a': funcion1(); break; case 'B': case 'b': funcion2(); break; case 'C': case 'c': funcion3(); break; } if ( ! (opcion=='S' || opcion=='s') ) main(); // se invoca, la función main(), a sí misma (recursión) }

89

5.7 Se digita un número menor o igual a 1000 y a continuación se muestra su representación en números romanos. //SWITCH_3.CPP #include <iostream.h> #include <conio.h> #include <string.h>//strcat(cadena1, cadena2) agrega la cadena2 a la cadena1 main(){ int numero, unidades, decenas, centenas, resto; char und[5], dec[5], cent[5]; clrscr(); cout << "Digite número (1 - 1000): "; cin >> numero; centenas = numero / 100; resto = numero % 100; decenas = resto /10; unidades = resto % 10; switch (centenas) { case 0: strcpy(cent, ""); break; case 1: strcpy(cent, "C"); break; case 2: strcpy(cent, "CC"); break; case 3: strcpy(cent, "CCC"); break; case 4: strcpy(cent, "CD"); break; case 5: strcpy(cent, "D"); break; case 6: strcpy(cent, "DC"); break; case 7: strcpy(cent, "DCC"); break; case 8: strcpy(cent, "DCCC");break; case 9: strcpy(cent, "CM"); break; case 10:strcpy(cent, "M"); break; } switch (decenas) { case 0: strcpy(dec, ""); break; case 1: strcpy(dec, "X"); break; case 2: strcpy(dec, "XX"); break; case 3: strcpy(dec, "XXX"); break; case 4: strcpy(dec, "XL"); break; case 5: strcpy(dec, "L"); break; case 6: strcpy(dec, "LX"); break; case 7: strcpy(dec, "LXX"); break; case 8: strcpy(dec, "LXXX");break; case 9: strcpy(dec, "XC"); break; } switch (unidades) { case 0: strcpy(und, ""); break; case 1: strcpy(und, "I"); break; case 2: strcpy(und, "II"); break; case 3: strcpy(und, "III"); break; case 4: strcpy(und, "IV"); break; case 5: strcpy(und, "V"); break; case 6: strcpy(und, "VI"); break;

90

case 7: strcpy(und, "VII"); break; case 8: strcpy(und, "VIII");break; case 9: strcpy(und, "IX"); break; } cout << cent << dec << und; } 5.8 ACTIVIDADES PARA REALIZAR EN GRUPO DE ESTUDIO 5.8.1 Leer un número desde teclado inferior o igual a mil, a continuación muestre en pantalla la misma cantidad pero en palabras. 5.8.2 Estudie todos los algoritmos que no ha estudiado, por falta de tiempo, y efectúe las actividades no resueltas aún. La próxima semana es el primer parcial. 5.8.3 Recodifique al menos 5 de los algoritmos vistos en el curso anterior de pseudocódigo en español.

91

CCAAPPÍÍTTUULLOO 66¡¡EErrrroorr!! MMaarrccaaddoorr nnoo ddeeffiinniiddoo.... IINNSSTTRRUUCCCCIIÓÓNN RREEPPEETTIITTIIVVAA WWHHIILLEE 6.1 METODOLOGÍA Estudie el tema presentado en esta lección antes de ir a la correspondiente clase magistral. Ya en ella efectúe las preguntas que considere necesarias al profesor. El Profesor explicará en esta 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 computador y del disquete anexo cargue los archivos de los programas correspondientes a este capítulo. 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, en forma personal y luego en Grupo de estudio; efectúe los algoritmos de tarea asignados al final de esta lección. Debe dedicarle a esto unas tres horas. 6.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. Hasta el momento la única forma de hacerlo sería o copiándolas varias veces, las instrucciones, o copiarlas dentro de una función e invocarla repetidamente. La instrucción Mientras(while) soluciona este problema, permitiendo ejecutar reiteradamente iteraciones (ciclos, bucles, lazos, rizos). De esta forma será posible "devolvernos" en la secuencia lógica del algoritmo.

Tabla 6.1 Sintaxis general de la instrucción Mientras(while)

¡Error! Marcador no definido. Pseudocódigo en Español

Lenguaje C/C++

.... Mientras <Exp. booleana> hacer .... Instrucción(es) .... Fin_Mientras ....

.... while (Exp. booleana){ .... Instrucción(es); .... } ....

El ciclo que produce la instrucción Mientras (while) se efectuará, ejecutando las instrucciones que contiene, mientras sea verdadera la expresión booleana que

lo está controlando.

92

DIAGRAMA DE FLUJO 6.1. Instrucción Mientras (while) ¡Error! Marcador no definido. 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 C/C++, un valor numérico de 0 es considerado como falso, y cualquier otro valor numérico como verdadero. Cuando la instrucción mientras (while) evalúe la expresión booleana que controla el ciclo como falsa, 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, o sea el Fin_Mientras en el Pseudocódigo en Español o la llave de cerrar } del C/C++. La instrucción while es una palabra reservada del lenguaje C/C++, la cual debe ir seguida de una expresión lógica o relacional encerrada entre paréntesis. La expresión al ser evaluada, si es verdadera decimos que entra la secuencia del algoritmo dentro del ámbito de la instrucción while, y secuencialmente irá ejecutando el código hasta encontrar el terminador }, en este momento el flujo del algoritmo de "devuelve" trasladándose "arriba" a la instrucción while, nuevamente; aquí la expresión es evaluada de nuevo, si es verdadera entra la secuencia otra vez al ámbito de la instrucción, y así sucesivamente hasta que en un momento y dados los cambios ocasionados dentro del ámbito del while, la condición que controla el ciclo se vuelve falsa, en este momento el flujo del programa se traslada después de la llave de cerrar } y el algoritmo seguirá secuencialmente; debido a esto decimos que la instrucción while se sale por arriba. 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, o con alguna otra instrucción que lo obligará a salir, lo cual no es lo más recomendado según los teóricos de la programación estructurada. Si al evaluarse la primera vez la condición de control, esta llegare a ser falsa, no se ejecutarían las instrucciones contenidas en el ámbito del while,

sino que seguiría secuencialmente el programa.

93

A continuación se presenta un algoritmo para sumar los 10 primeros números: main (){ int numero = 0, suma = 0; while (numero < 10){ numero = numero + 1; suma = suma + numero; } cout << "Sumatoria del 1 al 10 = " << suma; } 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, al ejecutarlo se verá así:

¡Error! Marcador no definido.Sumatoria del a al 10 = 55_

6.3 Se presenta la serie de los números pares entre 2 y 10 //WHILE_.CPP #include <iostream.h> #include <conio.h> void main(){ int x = 0, suma = 0; clrscr(); while (x < 10 ) { x = x + 2; cout << x << " "; suma = suma + x; } cout << "\n\nLA SUMA DE LOS NUMEROS PARES ES: " << suma; }

94

6.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.CPP #include <iostream.h> #include <conio.h> main(){ int i=0, n; float termino, suma=0; clrscr(); cout << "Digite el valor de N: "; cin >> n; cout << "\n"; while( i<n ){ i = i + 1; termino = i * (i+1) * (i+2); suma = suma + termino; cout << i << " * " << i+1 << " * " << i+2 << " = " << termino << endl; } cout << "\nSumatoria = " << suma; } 6.5 Se presenta un ciclo infinito. Digite Ctrl+break para terminar. //WHILE_2.CPP #include <iostream.h> const int Verdad=1; main(){ while (Verdad) cout << " Digite las teclas de CONTROL + BREAK para terminar \n"; } Se muestra en pantalla la siguiente serie: S = - 1 + 2 - 3 + 4 -5 ... //WHILE_3.CPP #include <iostream.h> #include <conio.h> main(){ int i=0, n; float suma=0; clrscr(); cout << "DIGITE N:"; cin >> n; while ( i < n ){ i = i + 1; if (i % 2 == 0){ cout << i << " "; suma = suma + i; } else { cout << -i << " "; suma = suma - i; } } cout << "\n\nSumatoria = " << suma; }

95

6.6 Se despliega en pantalla y calcula sumatoria de la siguiente serie: S = -2 +4 -6 +8 -10 +12 -14 ... //WHILE_4.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> main(){ int n, suma=0, termino, i=0, potencia; clrscr(); cout << "Digite la cantidad de términos en la serie: "; cin >> n; while ( i < n ){ i = i + 1; if (i % 2 == 0) termino = 2 * i; else termino = 2 * (-i); suma = suma + termino; cout << setw(5) << termino ; } cout << "\n\n LA SUMA ES: " << suma; getch(); } 6.7 Se suman los N primeros términos de la siguiente serie: 1 1 1 1 1 1 ---- + ---- + ---- + ---- + ---- + .... + ---- 1² 3² 5² 7² 9² N! //WHILE_5.CPP #include <math.h> #include <conio.h> #include <iostream.h> #include <iomanip.h> main(){ float suma = 0, termino; int i = 0, N = 50; clrscr(); while (i < N){ i = i + 1; termino = 1 / pow(2*i-1, 2); cout << setw(10) << termino; suma = suma + termino; } cout << "\n\nSumatoria = " << suma; getch(); }

96

6.8 Ejemplo de graficar círculos concéntricos. //WHILE_6.CPP #include <graphics.h> #include <iostream.h> #include <conio.h> main(){ int radio=0, Xo, Yo, Color; int ManejadorGrafico = DETECT, ModoGrafico; initgraph( &ManejadorGrafico, &ModoGrafico, "..\\" ); cout << "Máximas coordenadas en esta pantalla (" << getmaxx() << "," <<getmaxy() << ")\n"; cout << "Digite valor Xo del centro de los círculos: "; cin >> Xo; cout << "Digite valor Yo del centro de los círculos: "; cin >> Yo; cout << "Digite número del 0 al 16 para el color: "; cin >> Color; setcolor(Color); while (radio <= 200){ radio = radio + 10; circle(Xo, Yo, radio); } getch(); closegraph(); } 6.9 Ejemplo de movimiento de un círculo en la pantalla. //WHILE_7.CPP #include <graphics.h> #include <iostream.h> main(){ unsigned int Radio=40, X=0, Y=200, Color, Fondo; int ManejadorGrafico = DETECT, ModoGrafico; cout << "Digite número del 0 al 16 para el color del círculo: "; cin >> Color; cout << "Digite número del 0 al 7 para el color del fondo: "; cin >> Fondo; initgraph( &ManejadorGrafico, &ModoGrafico, "..\\" ); setbkcolor(Fondo); while (X <= getmaxx() ){ setcolor(Color); circle(X, Y, Radio); setcolor(Fondo); circle(X, Y, Radio); X = X + 2; } closegraph(); }

97

6.10 El siguiente algoritmo, para el cálculo del valor del número e a través de una serie, emplea en concepto de recurrencia: 2 3 N X X X e = 1 + --- + --- + ... + --- 2! 3! N! 2 3 X X X observe que, por ejemplo, al término --- le falta --- para obtener --- 2! 3 3! 3 4 X X X así mismo: --- . --- = --- 3! 4 4! debido a esto, y analizando más casos, se desprende que para cada nueva iteración que se efectúe para calcular cada nuevo término, se tendrá que multiplicar el termino anterior por X/i, donde i es el número de la iteración respectiva o lo que es lo mismo el número de término. //WHILE7.CPP #include <iostream.h> #include <conio.h> main(){ float x, termino, eX; int i=0; cout << "Digite valor de X: "; cin >> x; eX = termino = 1; while ( termino > 0E-04){ //10 elevado a la -4 en notación científica i++; termino = termino * x / i; eX = eX + termino; } cout << "\n\n e elevado a la " << x << " = " << eX; getch(); }

98

6.11 ACTIVIDADES PARA REALIZAR PERSONALMENTE Y EN GRUPO DE ESTUDIO 6.12.1 Efectúe prueba de ejecución manual a todos los algoritmos del presente capítulo. Muestre lo que aparece en pantalla. Diseñe tabulados adecuados para cada uno de los programas. 6.12.2 Rehaga algunos de los ejercicios de la Segunda Parte, pero de tal suerte que aparezca al final el siguiente mensaje: "¿Desea continuar (Si/No)?. E programa debe detenerse y permitir digitar "S" o "N", en caso afirmativo el programa debe pedirle nuevamente datos, y así sucesivamente hasta que digite "N" para terminar. 6.12.3 Se desea leer todas las calificaciones de una clase de Algoritmos y contar el número total de aprobados y reprobados. Escribir al final el promedio de el curso. 6.12.4 Calcule la nota promedio de un salón de clase y la nota mayor con el nombre del alumno. Suponga que cada alumno tiene un número diferente de calificaciones. Muestre para cada alumno su nota definitiva. 6.12.5 Determinar la suma y promedio de una lista indefinida de números positivos, terminados con un número negativo.

99

CCAAPPÍÍTTUULLOO 77¡¡EErrrroorr!! MMaarrccaaddoorr nnoo ddeeffiinniiddoo.... IINNSSTTRRUUCCCCIIÓÓNN WWHHIILLEE((CCoonnttiinnuuaacciióónn)) 7.1 METODOLOGÍA Estudie el tema presentado en esta lección antes de ir a la correspondiente clase magistral. Ya en ella efectúe las preguntas que considere necesarias al profesor. El Profesor explicará en esta 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 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. Luego diríjase al computador y del disquete anexo cargue los archivos de los programas correspondientes a este capítulo. 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, en forma personal y luego en Grupo de estudio; Debe dedicarle al estudio al menos unas seis horas. 7.2 En el siguiente programa se hace sonar el parlante del computador a varias frecuencia, según valores digitados desde teclado. //WHILE_8.CPP #include <iostream.h> #include <conio.h> #include <dos.h> main(){ unsigned int F, Ff, Deltaf, tiempo; clrscr(); cout << "Digite frecuencia inicial en herz: "; cin >> F; cout << "Digite frecuencia final en herz: "; cin >> Ff; cout << "Digite incremento de la frecuencia:"; cin >> Deltaf; cout << "Digite milisegundos para que cada frecuencia suene: "; cin >> tiempo; while (F <= Ff ){ sound(F); cout << "\n" << F; delay(tiempo); F = F + Deltaf; } nosound(); }

100

7.3 Se imprimen en pantalla los números primos entre 2 y 2000. //WHILE8.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include <math.h> const int Verdad=1; const int Falso=0; main(){ int n=2, divisor, EsPrimo; clrscr(); cout << " NUMEROS PRIMOS ENTRE 2 Y 2000 \n\n"; cout << " " << n ; //El 2 es el único primo par n = 1; while (n < 2000){ n = n + 2; // se generan solo números impares EsPrimo = Verdad; divisor = 3; while ( ( divisor <= sqrt(n) ) && EsPrimo ){ if (n % divisor == 0) EsPrimo = Falso; else divisor = divisor + 2; }//while if (EsPrimo) cout << setw(5) << n; }//while gotoxy(1,25); cout << "Digite cualquier tecla para terminar"; getch(); return 0; }

101

7.4 Se generan números al azar hasta "adivinar" el número digitado por teclado. Adicionalmente para cada número generado se genera esa misma frecuencia por el altoparlante. //WHILE9.CPP #include <iostream.h> #include <conio.h> #include <stdlib.h> #include <dos.h> const int Max=1000; void main(){ int N, NumeroAlAzar=0, intentos=0; clrscr(); cout << "Digite un número entero entre 1 y " << Max << ": "; cin >> N; randomize(); //genera una semilla para números aleatorios while (NumeroAlAzar != N){ intentos = intentos + 1; NumeroAlAzar = random(Max+1); cout << NumeroAlAzar << " "; sound(NumeroAlAzar); } nosound(); cout <<"\n\nAdiviné el " <<NumeroAlAzar <<" en " <<intentos << " intentos"; } 7.5 Obtenga la sumatoria de los N primeros términos de la siguiente serie: 1 1 1 1 1 + ---- + 3 + ---- + 5 + ---- + 7 + ---- + .... 2! 4! 6! 8! //WHILE13.CPP #include <conio.h> #include <iostream.h> void main(){ int N, Factorial=1, i=0; float SumatoriaSerie=0; clrscr(); cout << "\tn = "; cin >> N; while (i < N){ i++; SumatoriaSerie = SumatoriaSerie + i; Factorial = Factorial * i; i++; if (i <= N){ Factorial = Factorial * i; SumatoriaSerie = SumatoriaSerie + 1.0 / Factorial; } } cout << "\n\t\tSumatoria Serie = " << SumatoriaSerie; }

102

7.6 Descomposición de un número en sus factores primos. //WHILE_9.CPP #include <iostream.h> #include <conio.h> #include <math.h> main(){ int numero, impar=3; clrscr(); cout << "Digite un Número para calcularle sus factores primos: "; cin >> numero; cout << "\n"; while ((numero % 2) == 0 ){ cout << 2 << endl; numero = numero / 2; } while (impar <= (sqrt(numero)+1) ){ while (numero % impar == 0 ){ cout << impar << endl; numero = numero / impar; } impar = impar + 2; } if ( numero > 1 ) cout << numero; } 7.7 ALGORITMO DE EUCLIDES PARA EL MAXIMO COMÚN DIVISOR entre dos números m y n //WHILE10.CPP #include <iostream.h> #include <conio.h> main(){ int m, n, aux, diferencia; clrscr(); cout << "Digite m: "; cin >> m; cout << "Digite n: "; cin >> n; while (m != n){ if (m < n){ aux = m; m = n; n = aux; } diferencia = m - n; m = n; n = diferencia; } cout << "\n\n\tM.C.D. = " << m; }

103

7.8 La corriente en un circuito eléctrico está dada por: -t/T i(t) = 10 e Seno( 2 t/T ) para 0 <= t <= T/2 i(t) = 0 para T/2 < t <= T calcúlese i(t) e i²(t) para intervalos de t de 0.005 segundos desde t=0 hasta t=T. Suponga que T=1 segundo //WHILE11.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include <math.h> const float Pi=3.14159; main(){ float t=0, /* tiempo en segundos */ T = 1, /* periodo, tiempo de un ciclo */ i=0, /* corriente instantánea, Amperios */ i2, /* intensidad corriente al cuadrado */ intervalo = 0.05; clrscr(); cout << "\n\n tiempo i(t) i²(t)"; cout << "\n──────────────────────────────────────────-\n"; cout << setw(8) << t << setw(14) << i << setw(14) << i*i << endl; while( t <= T/2 ){ t = t + intervalo; i = 10 * exp(-t/T) * sin(2 * Pi * t/T); cout << setw(8) << t << setw(14) << i << setw(14) << i*i << endl; } cout << "\n──────────────────────────────────────────-"; getch(); }

104

7.9 Un número es perfecto si la suma de sus divisores excepto él mismo es igual al propio número. 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, el 36 no lo es. //WHILE14.CPP #include <iostream.h> #include <conio.h> main(){ int numero=1, i, suma; clrscr(); cout << "Espere un momento!\n\n"; while (numero <= 2000){ suma = 0; i = 1; while ( i <= (numero / 2) ){ if (numero % i == 0) suma = suma + i; i = i + 1; } if (suma == numero) cout << "\n\t\t" << numero; numero = numero + 1; } cout << "\n\n\nHasta el 2000 estos son solamente. Digite cualquier tecla"; getch(); }

105

7.10 Leer un número en cualquier base, desde el 2 al 9, y obtener una respuesta en base diez. 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 <--- se hacen divisiones entre 10 hasta obtener un cociente de cero //WHILE15.CPP #include <iostream.h> #include <conio.h> main(){ int numero, base_origen, cociente, digito, decimal, potencia; clrscr(); cout << "\nDigite número en base del 2 al 9(cero para terminar): "; cin >> numero; while ( numero > 0 ){ cout << "base del número digitado: "; cin >> base_origen; potencia = 1; cociente = numero / 10; digito = numero % 10; decimal = digito * potencia; while (cociente > 0){ digito = cociente % 10; cociente = cociente / 10; potencia = potencia * base_origen; decimal = decimal + potencia * digito; } cout <<("en base 10 = %d\n", decimal); getch(); clrscr(); cout << "\nDigite número en base del 2 al 9(cero para terminar): "; cin >> numero; } }

106

7.11 ACTIVIDADES PARA REALIZAR EN GRUPO DE ESTUDIO 7.11.1 Suponga se tiene un conjunto de calificaciones, del 0 al 5, de un estudiante, construya un algoritmo para calcular la calificación definitiva. 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, por consiguiente no deberá intervenir en los cálculos. Adicionalmente se deberá mostrar la calificación mayor y la menor. 7.11.2 Una partícula se mueve en una recta de acuerdo a la siguiente expresión: e = 130 + 100t - 20t2 + 2.5t3 donde e es la distancia en metros y t es le tiempo en segundos. Tabule desde un tiempo de 0 segundos con intervalo de 1 segundo hasta un tiempo de 15 segundos, el correspondiente desplazamiento e, la velocidad(primera derivada) y la aceleración(segunda derivada). 7.11.3 Se leen desde teclado dos tiempos diferentes en horas, minutos y segundos. ¿Calcule la diferencia entre estos dos tiempos?. Lea varios pares de valores. 7.11.4 Calcule el valor de las siguientes series efectuándolas con recurrencia y sin ella: X2 X3 XN * eX = 1 + X + ---- + ---- + .... + ---- 2! 3! N! a) para N dado desde teclado XN b) hasta que N sea tal que ----- menor a 10-4 N! X3 X5 X7 * Seno(X) = X - ---- + ---- - ---- + .... 3! 5! 7! X2 X3 X4 * Ln(1+X) = X - ---- + ---- - ---- + .... 2! 3! 4! 7.11.5 Aceptar como entrada una serie de N valores enteros. Calcular e imprimir: A)¿Cuántos son pares y múltiplos de 13; B) ¿Cuántos son divisibles por siete?; C) El mayor y el menor de la serie. 7.11.6 Coldeportes está interesada en promover el basquetball y para ello desea encontrar personas con las siguientes características: edad menor a 18, estatura mínima 1.80 m, peso máximo 90 Kg. Elabore un algoritmo en el cual se lea el nombre, la edad, estatura y el peso del deportista, verifique si cumple las condiciones impuestas. Al final diga cuántos cumplieron las condiciones. Como condición de terminación de lectura de datos debe colocar en pantalla: ¿Desea continuar(s/n)?. 7.11.7 Se efectuó una encuesta de población, en la cual a cada persona se le pidió la siguiente información: SEXO, EDAD, ESTADO CIVIL, NUMERO DE HIJOS, TRABAJA, NACIONALIDAD, TIENE CASA PROPIA?. La información para un número

107

indeterminado de encuestados debe ser introducida por teclado. Elabore un algoritmo que a través de la utilización de funciones, para cada caso, calcule: - Porcentaje de colombianos que tienen casa propia - Número de menores de edad extranjeros - Los porcentajes de mujeres que trabajan sobre el total de mujeres en la

muestra y sobre el total de la población. - Porcentaje de hombres que trabajan entre 19 y 25 años. Tome como población

el número de hombres con edad en el mismo intervalo. - Porcentaje de mujeres solteras. Tome como población el total de mujeres en

la muestra. - Invente otras dos preguntas que se adapten a la muestra encuestada. 7.11.8 Se tiene un registros con los datos de los estudiantes de una universidad así: código del estudiante, nombre y apellido, valor por materia, número de materias a matricular, valor del recargo por matrícula; 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, nombre y apellido, valor por materia, número de materias, valor del recargo, total matricula; al final se debe mostrar el total a recibir por matrículas y el número total de estudiantes matriculados. 7.11.9 Calcular el valor de las siguientes series: S = - 1 + 2 - 3 + 4 - 5 + 6 - 7 + 8 + ... + 100 S = 1 + 2 + 3 - 4 + 5 + 6 + 7 - 8 + 9 + 10 + 11 - 12 + ... S = 1 - 2 + 3 + 4 - 5 + 6 + 7 + 8 - 9 + 10 + 11 + 12 + .... S = - 2 + 4 - 6 + 8 - 10 + 12 - 14 + ... S = 1 + 3 - 5 + 7 + 9 - 11 + 13 + 15 - 17 + 19 + ... Con la fórmula N²-N+41 se obtienen gran cantidad de números primos, determine para qué valor de N la ecuación falla, es decir se obtiene un número compuesto, y escriba todos los números primos encontrados.

109

CCAAPPÍÍTTUULLOO 88¡¡EErrrroorr!! MMaarrccaaddoorr nnoo ddeeffiinniiddoo.... PPAASSOO PPOORR VVAALLOORR YY RREETTOORRNNOO EENN FFUUNNCCIIOONNEESS 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: #include <dos.h> //SONIDO1.CPP 1: 2: NOTA(int Herz){ 3: sound(Herz); 4: delay(1000); 5: } 6: 7: main(){ 8: int frecuencia=260; 9: 10: NOTA(frecuencia); 11: 12: frecuencia=440; 13: NOTA(frecuencia); 14: nosound(); 15: }

110

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.

111

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

112

8.5 El siguiente algoritmo utiliza una función, la cual es invocada por valor y devuelve a su vez otro. Específicamente efectúa una conversión de unidades termométricas. #include <iostream.h> #include <conio.h> //FUNCION3.CPP float Fahrenheit(float grados){ float F; F = 9.0 / 5 * grados + 32; cout << "\nson " << F << " Fahrenheit"; } void main(){ float centigrados; clrscr(); cout << "Digite temperatura en grados centígrados: "; cin >> centigrados; // se invoca a continuación función Fahrenheit(): Fahrenheit(centigrados); getch(); } En el anterior algoritmo al ejecutarlo, se detendrá inicialmente debido al efecto de la instrucción de lectura: cin >> centígrados; presentando el siguiente aspecto en pantalla:

¡Error! Marcador no definido.Digite temperatura en grados centígrados: _

Al digitar una temperatura, un número, y dar la tecla de <ENTRAR>, el algoritmo continuará secuencialmente, efectuará la invocación de la función Fahrenheit, esta retornará un resultado, el cual será escrito en pantalla, se detendrá nuevamente en la instrucción getch(), presentando el siguiente aspecto:

¡Error! Marcador no definido.Digite temperatura en grados centígrados: 100 son 212 Fahrenheit_

113

8.6 El siguiente programa permite oír notas musicales entre 260 Hz y 520 Hz, mediante funciones: sound() y nosound(), incorporadas en la unidad <dos.h>. #include <iostream.h> #include <conio.h> #include <dos.h> //SONIDO2.CPP Do(int Tempo){ sound(260); cout << "Do "; delay(Tempo); } Re(int Tempo){ sound(290); cout << "Re "; delay(Tempo); } Mi(int Tempo){ sound(322); cout << "Mi "; delay(Tempo); } Fa(int Tempo){ sound(342); cout << "Fa "; delay(Tempo); } Sol(int Tempo){ sound(390); cout << "Sol "; delay(Tempo); } La(int Tempo){ sound(440); cout << "La "; delay(Tempo); } Si(int Tempo){ sound(494); cout << "Si "; delay(Tempo); } DO(int Tempo){ sound(520); cout << "Do "; delay(Tempo); } Silencio(int Tempo){ nosound(); cout << "\nSilencio\n"; delay(Tempo); } main(){ int ms; // milisegundos clrscr(); cout << "Milisegundos que desea suene cada nota: "; cin >> ms; Do(ms); Re(ms); Mi(ms); Fa(ms); Sol(ms); La(ms); Si(ms); DO(ms); Silencio(ms); ms/=2; Do(ms); Re(ms); Mi(ms); Fa(ms); Sol(ms); La(ms); Si(ms); DO(ms); getch(); nosound(); }

114

8.7 RETORNO DE VALORES EN FUNCIONES Hasta ahora todas las funciones que hemos utilizado no han devuelto nada(void), empero, 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. Una función puede tener más de una instrucción de retorno(return), empero por la primera que pase la secuencia de ejecución del programa, la función terminará retornando el valor correspondiente. El profesor el siguiente ejemplo: 8.8 El siguiente algoritmo calcula el número medio entre tres enteros, no es el promedio. Ver el programa IF_01.CPP como comparación. //RETURN_1.CPP #include <iostream.h> #include <conio.h> CalculaMedio(int a, int b, int c){ int Medio; if ( (b<a && a<c) || (c<a && a<b) ) Medio = a; if ( (a<b && b<c) || (c<b && b<a) ) Medio = b; if ( (a<c && c<b) || (b<c && c<a) ) Medio = c; return Medio; } main(){ int a, b, c; clrscr(); cout << "Digite entero: "; cin >> a; cout << "Digite entero: "; cin >> b; cout << "Digite entero: "; cin >> c; cout << CalculaMedio(a, b, c) << " es el del medio"; } 8.9 El siguiente algoritmo utiliza una función, la cual es invocada por valor y devuelve a su vez otro. Específicamente efectúa una conversión de unidades termométricas. Comparar con el programa FUNCION3.CPP. //RETURN_2 #include <iostream.h> #include <conio.h> float Fahrenheit(float grados){ float F; F = 9.0 / 5 * grados + 32; return (F); //la función retorna el valor de F, a donde fue invocada

115

} void main(){ float centigrados; clrscr(); cout << "Digite temperatura en grados centígrados: "; cin >> centigrados; //se invoca función cout << "\nson " << Fahrenheit(centigrados) << " Fahrenheit"; getch(); } 8.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". Comparar con el programa IF_03.CPP. RETURN_3.CPP #include <iostream.h> #include <conio.h> #include <string.h> char *CompararValores(int valor1, int valor2){ char *mensaje;//Observe que es otra forma de manejar cadenas de caracteres //la cual utilizaremos en próximos cursos. if ( valor1 > 0 && valor2 > 0) strcpy(mensaje, "\nLOS DOS SON POSITIVOS"); else if (valor1 < 0 && valor2 < 0) strcpy(mensaje, "\nLOS DOS SON NEGATIVOS"); else strcpy(mensaje, "\nTIENEN DIFERENTE SIGNO"); return mensaje; } void main(){ float a, b; clrscr(); cout << "Digite real: "; cin >> a; cout << "Digite real: "; cin >> b; cout << CompararValores(a, b); getch(); }

116

8.11 Encontrar raíces de función entre intervalos dados por error y ensayo: Evaluar la función: y = x^3 - 9x^2 + 23x - 15 entre el intervalo a = - 1 y b = 7 con incrementos de x de 0.5. Las tres raíces se obtienen donde la y = 0. 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. //WHILE12.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include <math.h> float F(float x){ return (pow(x,3) - 9*pow(x,2) + 23*x - 15); } main(){ float a, b, X, Y, DeltaX; clrscr(); cout << "Digite valor inicial intervalo (a): "; cin >> a; cout << "Digite valor inicial intervalo (b): "; cin >> b; cout << "Digite incremento de X: "; cin >> DeltaX; X = a; cout << "───────────────────────────" << endl; cout << " X Y " << endl; cout << "───────────────────────────" << endl; while (X <= b) { Y = F(X); //Invoca función F() cout << setw(12) << X << setw(12) << Y; if (Y == 0) cout << " Raíz exacta" << endl; else cout << endl; X = X + DeltaX; } cout << "───────────────────────────"; } 8.12 Obtener el enésimo término de la serie de Fibonacci y decir si es primo. Observe hasta que N se puede ejecutar este programa, sin que cometa error. //WHILE16.CPP #include <iostream.h> #include <conio.h> int Fibonacci (int N){ // Calcula el enésimo término de la serie de Fibonacci int ultimo = 1, penultimo = 0, Fib, i=2; switch (N){ case 1: return (0); case 2: return (1); default:

117

while ( i < N ) { i++; Fib = penultimo + ultimo; penultimo = ultimo; ultimo = Fib; } return (Fib); } } EsPrimo (int numero){ int impar = 3; if (numero == 2) //Si es 2 devuelve 1. El 2 es el único par primo return(1); if (numero % 2 == 0) // Si es par devuelve 0(falso). No es primo return (0); 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); else return (0); //El número evaluado no es primo } FibonacciEsPrimo (int N){ int F; F = Fibonacci (N); //Calcula el enésimo término de la serie de fibonacci if ( EsPrimo (F) ) cout << "Fibonacci = " << F << " es primo\n"; else cout << "Fibonacci = " << F << " no primo\n"; } main(){ int N; clrscr(); cout << "Calcula enésimo término serie Fibonacci y se dice si es primo\n\n"; cout << "Digite un N(0 para terminar): "; cin >> N; while (N > 0){ FibonacciEsPrimo (N); cout << "Digite un N(0 para terminar): "; cin >> N; } }

119

CCAAPPÍÍTTUULLOO 99¡¡EErrrroorr!! MMaarrccaaddoorr nnoo ddeeffiinniiddoo.... IINNSSTTRRUUCCCCIIÓÓNN RREEPPEETTIITTIIVVAA DDEESSDDEE 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.

120

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

121

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

122

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

123

9.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.CPP #include <iostream.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; clrscr(); cout<<"Digite exponente(n) para calcular coeficientes del binomial (a+b)_: "; cin >> n; cout <<"\n"; for(i=0; i<=n; i++) { coeficiente = factorial(n) / (factorial(i)*factorial(n-i)); cout << coeficiente << " "; } getch(); return 0; }

124

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 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 1 6 15 20 15 6 1 1 7 21 35 35 21 7 1 1 8 28 56 70 56 28 8 1 1 9 36 84 126 126 84 36 9 1 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; }

125

9.9 El siguiente algoritmo presenta las equivalencias de temperatura entre centígrados y fahrenheit entre un valor inicial y uno final. //FOR_6.CPP #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; 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; } }

126

9.11 Efectúe prueba de ejecución manual al siguiente algoritmo. ¿Qué hace? Escriba enunciado. //FOR_08.CPP #include <iostream.h> #include <conio.h> 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(); }

127

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

128

9.15 Se digita una frase y luego se centra en la pantalla. //FOR_11.CPP #include <string.h> #include <iostream.h> #include <conio.h> #include <stdio.h> void main(){ char cadena[20]; int longitud; clrscr(); cout << "Digite frase para luego centrarla en pantalla: \n"; gets(cadena); clrscr(); gotoxy(1,12); for(longitud = (80- strlen(cadena)) / 2;longitud >0; longitud--) cout << " "; cout << cadena; } 9.16 Se digita un número entero y se determina si es primo. //FOR13.CPP #include <iostream.h> #include <conio.h> #include <math.h> const int verdad=1; const int falso=0; main(){ int N, impar, EsPrimo=verdad; clrscr(); cout << "Digite un entero: "; cin >> N; if (N < 2) EsPrimo = falso; else if (N > 2) if (N % 2 == 0) EsPrimo = falso; else for(impar = 3; impar <= sqrt(N) && EsPrimo; impar = impar + 2 ) if (N % impar == 0 ) EsPrimo = falso; if (EsPrimo) cout << " Es primo"; else cout << " No es primo"; }

129

9.17 Se encuentra el valor aproximado de la función trigonométrica Seno con la siguiente serie: 3 5 7 9 11 N X X X X X X Seno( X ) = X - ---- + ---- - ---- + ---- - ---- + .... ---- 3! 5! 7! 9! 11! N! el ángulo X está en radianes. Y se compara con la función Sin() incorporada en la librería math.h //FOR12.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include <math.h> const int N=20; //Son los términos en la serie. Entre más, mejor la precisión const float Pi=3.14159; main(){ int i, angulo; float termino, senX, X; clrscr(); cout << "----------------------------------------------- \n"; cout << " CALCULO DE FUNCIÓN TRIGONOMETRÍA SENO\n"; cout << "-----------------------------------------------\n"; cout << "ANGULO SERIE math.h DIFERENCIA\n"; cout << "-----------------------------------------------\n"; for (angulo=0; angulo<=180; angulo = angulo + 10){ X = angulo * Pi / 180; termino = X; senX = termino; for (i=2; i<=N; i++){ termino = - termino * pow(X,2)/((2*i-1)*(2*i-2)); senX = senX + termino; } cout << angulo; cout <<setw(15)<<senX<<setw(15) <<sin(X) <<setw(15) <<senX-sin(X)<<endl; } getch(); }

130

9.18 ACTIVIDADES PARA EFECTUAR EN GRUPO DE ESTUDIO 9.18.1Calcular el enésimo término de la serie de Fibonacci, dada por: 0 1 1 2 3 5 8 13 21 34 55 89 ... 9.18.2 La función EXP(x) se puede calcular mediante la suma de la serie infinita: x2 x3 xn ex = 1 + x + ---- + ---- + ... + ---- 2! 3! n! 9.18.3 se desea calcular el valor EXP(x) para x entre 0.0 y 1.0 con incrementos de 0.1, Calcule dicho valor tomando solamente los 10 primeros términos de la serie. 9.18.4 Si se suman los números impares se obtienen los cuadrados así: 1 = 1 = 12 1 + 3 = 4 = 22 1 + 3 + 5 = 9 = 32 1 + 3 + 5 + 7 = 16 = 42 empleando esta curiosidad matemática, calcular y escribir el cuadrado de los N primeros números naturales. 9.18.6 Una empresa tiene para los últimos años el siguiente cuadro de producción:

¡Error! Marcador no definido.MESES--> AÑO

1 2 3 4 5 6 7 8 9 10 11 12

1994 2344

4543

567 4545

434 3452

4542

1233

4545

5454 5453 2321

1995 5321

655 56 7545

4545

4544

1234

1866

6654

234 434 678

1996 567 543 234 665 976 3454

554 5453

4532

3322 5332 2345

1997 3453

6544

3455

1234

7533

3454

7544

7443

3432

6543 3466 6543

1998 6353

6533

7643

8643

8755

9134

9566

9665

9654

10454

9544 9555

Calcular:

131

1) El promedio de producción de cada uno de los años. 2) El mes de mayor producción de 1993. 3) El año de menos producción. 9.18.5 El número de combinaciones, C, de N objetos tomados M cada vez, está dado por: N! C = ------------- M! (N - M)! calcule el número de combinaciones, C, para N objetos de M en M cada vez. Elaborar dos algoritmos por separado de la siguiente forma: 1) Defina una función para el cálculo del factorial. 2) Elabore algoritmo con una expresión recurrente.

133

CCAAPPÍÍTTUULLOO 1100.. IINNSSTTRRUUCCCCIIÓÓNN RREEPPRRTTIITTIIVVAA DDOO......WWHHIILLEE 10.1 METODOLOGÍA Estudie el tema presentado en esta lección antes de ir a la correspondiente clase magistral. 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, 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 computador y del disquete anexo cargue los archivos de los programas correspondientes a este capítulo. 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, en forma personal y luego en Grupo de estudio; efectúe los algoritmos de tarea asignados al final de esta lección. Debe dedicarle a esto unas tres horas. 10.2 INSTRUCCIÓN DO...WHILE Tabla 10.1 Sintaxis general de la instrucción Hacer...Mientras

¡Error! Marcador no definido. Pseudocódigo en Español

Lenguaje C/C++

.... Hacer .... Instrucción(es) .... Mientras <Exp. booleana> ....

.... do{ .... Instrucción(es); .... }while (Exp. booleana); ....

El ciclo que produce la instrucción Mientras (while) se efectuará, ejecutando las instrucciones que contiene, mientras sea verdadera la expresión booleana que

lo está controlando. La expresión booleana que controla el ciclo debe producir un resultado de verdadero o de falso, en C/C++, un valor numérico de 0 es considerado como falso, y cualquier otro valor numérico como verdadero. Cuando la instrucción mientras (while) evalúe la expresión booleana que controla el ciclo como falsa, la ejecución lógica del algoritmo continuará secuencialmente en la siguiente instrucción.

134

DIAGRAMA DE FLUJO 1O.1. Instrucción Hacer...Mientras (do...while)

¡Error! Marcador no definido. ... viene el algoritmo secuencialmente │ ┌─────────┴────────┐ │ Ejecutar │

│ instrucciones ├<─────┐ │ │ │ └─────────┬────────┘ │ │ │ ┌────────┴────────┐ │ │ Expresión │ │ │ booleana ├────>─┘ │ ¿Cierto/Falso? │Verdadera └────────┬────────┘ │Falso │ continúa el algoritmo secuencialmente ...

A continuación se presenta un algoritmo para sumar los 10 primeros números: main (){ int numero = 0, suma = 0; do{ numero = numero + 1; suma = suma + numero; }while (numero < 10); cout << "Sumatoria del 1 al 10 = " << suma; } El resultado es idéntico al presentado con la intrucción while, en lecciones anteriores, el usuario diría que es el mismo programa, se dice que es transparente el cambio para él, solo para el programador sería evidentemente diferente.

135

10.3 Algoritmo de Euclides sobre el máximo común divisor. //DO_1.CPP #include <iostream.h> #include <conio.h> void main(){ int m, n, aux, resto; clrscr(); cout << "Digite m: "; cin >> m; cout << "Digite n: "; cin >> n; do { if (m < n) { aux = m; m = n; n = aux; } resto = m - n; m = n; n = resto; } while (m != n); cout << "\nEl m.c.d = " << m << "\n"; } 10.4 El siguiente programa permite mostrar los códigos de las teclas y secuencias de teclas del teclado. Tengalo muy pendiente, ya que le será de gran utilidad en el trabajo de sus proyectos de software. Verifique los códigos producidos con las tablas presentadas en el apéndice, para códigos ASCII, y para secuencias de ESC ó códigos extendidos. #include <iostream.h> //TECLADO.CPP #include <conio.h> main(){ int c; clrscr(); cout << "Digite ESC para terminar el programa\n" do{ c=getch(); if(c==0){ cout << c << " "; c=getch(); cout << c << "\n"; } else cout << c << "\n"; } while(c!=27); }

136

10.5 Plantilla del diseño de un menú con invocación de funciones. //DO_3.CPP #include <iostream.h> #include <conio.h> #include <dos.h> #include <ctype.h> void funcion1(void){ clrscr(); cout << "Función 1"; delay(1000); } void funcion2(void){ clrscr(); cout << "Función 2"; delay(1000); } void funcion3(void){ clrscr(); cout << "Función 3"; delay(1000); } void main(){ char opcion; int terminar=0; do{ clrscr(); cout << "\n\t\tA. .....\n"; cout << "\n\t\tB. .....\n"; cout << "\n\t\tC. .....\n"; cout << "\n\t\tS. Salir\n"; opcion = toupper(getch()); switch (opcion) { case 'A' : funcion1(); break; case 'B' : funcion2(); break; case 'C' : funcion3(); break; case 'S' : terminar = 1; } } while (!terminar); }

137

10.6 El siguiente programa convierte las teclas ASDFGHJK en teclas musicales. //DO_5.CPP #include <iostream.h> #include <conio.h> #include <dos.h> #include <ctype.h> main(){ char nota='A'; int tiempo=0; clrscr(); cout << "DIGITE EN EL TECLADO LAS LETRAS A S D F G H J K"; cout << "\n en cualquier orden, y oirá las notas musicales"; cout << "\npara terminar digite cualquier otra tecla\n"; do{ tiempo++; if(kbhit() || tiempo>2000){ if (tiempo>2000) nosound(); nota = toupper(getch()); tiempo=0; switch ( nota ){ case 'A':cout << "Do "; sound(260); break; case 'S':cout << "Re "; sound(290); break; case 'D':cout << "Mi "; sound(322); break; case 'F':cout << "Fa "; sound(342); break; case 'G':cout << "Sol "; sound(390); break; case 'H':cout << "La "; sound(440); break; case 'J':cout << "Si "; sound(494); break; case 'K':cout << "Do "; sound(520); break; } } } while ( nota=='A' || nota =='S' || nota=='D' || nota=='F' || nota=='G' || nota =='H' || nota=='J' || nota=='K' ); nosound(); }

138

10.7 ACTIVIDADES PARA EFECTUAR EN GRUPO DE ESTUDIO Y/O PERSONALMENTE 10.7.1 Suponer que la administración de impuestos calcula la retención en la fuente(R) por trabajador; para salarios brutos(SB) mayores a tres salarios mínimos en la siguiente forma: R = SB/5 - 40000 * NH, (NH:Número de Hijos). Cada empleado tiene una tarjeta así: Código del empleado, número de hijos, salario básico, total de retención pagado hasta el momento. Calcular e imprimir la retención de este mes y la retención acumulada por cada trabajador. 10.7.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. Los Cargos fijos son iguales a un salario mínimo. Los Cargos Variables se calculan como un 0.2 del patrimonio más un 0.15% de la renta gravable, tomados estos datos de la correspondiente declaración de renta de los acudientes del estudiante. En cada registro a leer encontraremos los siguientes campos: código del estudiante, monbre y apellido, patrimonio, renta, y se debe obtener una impresión en papel del nombre y apellido del estudiante, renta, patrimonio, cargos fijos, cargos variables y el total de la matrícula a cancelar. 10.7.3 Suponga que la Administración de Impuestos calcula la retención en la fuente, según la siguiente tabla (es solo un ejemplo ficticio): a. Hasta sueldos de $ 700.000 y más de 2 hijos no pagan. b. Hasta sueldos de $ 700.000 y 1 ó 2 hijos un 1%. c. Más de $ 900.000 y menos de $1'850.000 pagan un 2%. d. Más de $1'850.000 pagan un 4%. Se debe leer información, para un número indeterminado de personas, la cual contenga: Número de Cédula, Sueldo Mensual, Número de Hijos, para una empresa cualquiera y a continuación producir los cálculos correspondientes. 10.7.4 Una universidad está interesada en elaborar una relación de los estudiantes que estando casados trabajen. Se tienen registros con los datos de la facultad, nombre del estudiante, edad, estado civil (casado, soltero), situación laboral (trabaja, no trabaja). El listado debe darse a nivel de Facultad, Universidad y ciudad, para lo cual los datos entran ordenados por esta clave. 10.7.5 Se tienen en una empresa cementera registros con los siguientes campos: año de producción, desde 1970 a 1996, toneladas producidas, toneladas vendidas localmente, toneladas exportadas, precio de venta por tonelada. Calcular lo siguiente: - Inventario acumulado(stock) al 01 de enero de 1997 - Ingresos, en pesos $, para cada uno de los años - Total toneladas exportadas.

139

CCAAPPÍÍTTUULLOO 1111.. AARRRREEGGLLOOSS UUNNIIDDIIMMEENNSSIIOONNAALLEESS 11.1 INTRODUCCIÓN En ciencias de la computación un arreglo lineal, o vector, es una colección de elementos del mismo tipo, en donde cada uno, puede ser accesado o referido en forma directa, y es la implementación de la idea de sucesión en la matemática. Es posible formar arreglos de los tipos de datos simples como int, float, char y de sus modificadores de tipo y de tipos estructurados. Cada arreglo de esta forma será una colección de elementos del mismo tipo. Un arreglo puede concebirse como un grupo de celdas o contenedores, cada una con la capacidad de albergar un elemento de datos. Para accesar un elemento específico del arreglo se hace referencia a su número de celda o valor del índice. El índice para un arreglo debe ser de tipo entero. Cuando se declara un arreglo, se declara el tipo de datos del arreglo y su tamaño. A manera de ejemplo, podríamos hacer las siguientes declaraciones de arreglos: int X[7], Numeros[100], cantidades[100]; float Precio[250], costo[250], utilidad[250]; float Anualidades[max]; char nombres[20], apellidos[25]; char letras[26]; Como se ve, el número de elementos del arreglo estará dado por el número colocado entres [ y ] al declararlo, esto se llama dimensionamiento. Este, el dimensionamiento, es obligatorio, a menos que se dé implicitamente el tamaño del arreglo por medio de la inicialización del mismo como en: char Operador[] = {'+', '-', '*', '/'}; int Enteros[] = { 4, 13, 0, 5, 6, -23, 7, 345, 45, -12}; En el primer ejemplo, Operador será un arreglo de cuatro posiciones, y queda inicializado con los correspondientes carateres dados entre llaves. El segundo ejemplo el vector Enteros tendrá 10 posiciones. Los elementos de una variable arreglo, no reciben valores cuando el arreglo se declara(tendrán "basura"). Por esto es conveniente inicializar o efectuar lectura, asignándoles valores antes de efectuar ninguna otra operación con ellos.

A los componentes de un arreglo se asignan valores de forma similar que a cualquier otra variable. Ya dentro del algoritmo podríamos presentar las

siguientes instrucciones: Numeros[3] = 4569; Numeros[I] = pow(2,10); Anualidades[I] = Anualidades[I-1] * 1.3; Precio[artículo] = costo[articulo] + utilidad[articulo]; cout << "Precio máximo = $" << Precio[articulo];

140

cin >> Numeros[i]; gets(nombres[persona]); En los arreglos anteriores, los índices: I, articulo y persona, deben tener valores enteros, los cuales coincidan con las posiciones válidas del arreglo correspondiente. Recuerde si el arreglo es de N elementos, las posiciones válidas van desde el cero hasta N menos uno. Los arreglo unidimensionales son más comunmente conocidos como vectores. La representación gráfica o abstracción que debemos tener de un vector o arreglo unidimensional es la siguiente: Vector X El vector X ha sido declarado como: ┌──────┐ int X[7]; X[0] │ 126 │ ├──────┤ X[1] │ 47 │ y nos lo podemos "imaginar" vertical u ├──────┤ horizontal X[2] │ -4 │ ├──────┤ X[3] │ 0 │ vector X ├──────┤ ┌────┬────┬────┬────┬────┬────┬────┐ X[4] │ 10 │ │126 │ 47 │-4 │ 0 │ 10 │ -99│ 69 │ ├──────┤ └────┴────┴────┴────┴────┴────┴────┘ X[5] │ -99 │ X[0] X[1] X[2] X[3] X[4] X[5] X[6] ├──────┤ X[6] │ 69 │ índice o subíndice encerrado entre [ ] └──────┘ X es el nombre, o identificador del arreglo unidimensional o vector. X[0] se refiere al primer elemento del vector y tiene almacenado el entero 126, el número 0 es el índice. El valor de 126 a podido, por ejemplo, ser asignado directamente en el código del algoritmo por medio de la instrucción: X[0] = 126; X[3] es el cuarto elemento del vector y tiene almacenado un valor de 0, el número 3 es el índice. El valor de 0 en la posición 3 a podido ser leido, por ejemplo por teclado con la siguiente instrucción: cin >> X[3]; En general si I es un entero, tendremos que X[I], será el valor que ocupa la posición I del vector; este valor puede ser asignado directamente, leido por teclado, desde disco, etc. como veremos en los ejemplos siguientes de este capítulo. Cada elemento del vector X, al ser tipo int, ocupa en memoria 2 byte, por lo tanto, el arreglo X ocupará 2 * 7 = 14 bytes en la memoria RAM del computador. Similarmente podríamos hablar para vectores de otros tipos de datos.

141

11.2 Se lee un vector por teclado y luego se muestra en pantalla. //VECTOR_1.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> const int Max=10; void main(){ int i; float vector[Max]; clrscr(); for (i=0; i<Max; i++){ cout << "Real para posición " << i << ": "; cin >> vector[i]; } cout << endl << endl; for (i=0; i<Max; i++){ cout << setw(4) << vector[i]; } while(!kbhit()); } 11.3 Se generan los N primeros términos de la serie de Fibonacci. //VECTOR_2.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> const int N=64; void main(){ float F[N]; int i; clrscr(); F[0] = 0; F[1] = 1; for(i=2;i<N;i++) F[i] = F[i-1] + F[i-2]; for(i=0;i<N;i++){ cout.setf(ios::fixed); cout << setw(20) << F[i]; } while(!kbhit()); }

142

11.4 Se genera un vector, de la cantidad de posiciones "deseadas", aleatoriamente mostrándolo en pantalla. Finalmente se pide buscar un elemento en el vector. //VECTOR1.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include <stdlib.h> const int Max=200; void main(){ int i, N; float vector[Max]; do{ clrscr(); cout << "\aElementos a generar al azar en vector(Máximo " << Max << "): "; cin >> N; } while (N<1 || N>Max); //Válida el valor de N en el rango adecuado randomize(); for (i=0; i < N; i++){ vector[i] = random(100); cout << setw(4) << vector[i]; } //ALGORITMO DE BUSQUEDA SECUENCIAL EN ARREGLO UNIDIMENSIONAL float item; cout << "\n\nDigite un número para encontrar su posición en vector: "; cin >> item; i = 0; while( i<N && item != vector[i]) i++; if (item == vector[i]) cout << "\Encontrado en posición " << i; else cout << "\n\aNo encontrado en vector"; while(!kbhit()); }

143

11.5 Se inserta un elemento en una posición dada en vector en memoria. //VECTOR2.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include<stdlib.h> const int Max=100; main(){ int i, N; float VECTOR[Max]; do{ clrscr(); cout << "\aElementos a generar al azar en VECTOR(Máximo " << Max << "): "; cin >> N; } while (N<1 || N>Max); //Válida el valor de N en el rango adecuado randomize(); for (i=0; i < N; i++){ VECTOR[i] = random(100); cout << setw(4) << VECTOR[i]; } //ALGORITMO DE INSERCION DE ELEMENTO EN POSICION DADA DE UN VECTOR float item; int pos; if (N==Max) cout << "\n\n\aNo se pueden insertar más elementos en el VECTOR"; else{ cout << "\n\nDigite un número para INSERTAR en el VECTOR: "; cin >> item; do{ cout << "\nDigite posición en la que desea insertarlo(0-" << N <<"): "; cin >> pos; } while (pos<0 && pos>N); i = N; //observe que la posición N en el VECTOR, no está ocupada //ahora se "corren" los elementos a la derecha de pos, una posición while(i > pos){ VECTOR[i] = VECTOR[i-1]; i--; } VECTOR[pos] = item; // Oserve que sería lo mismo: VECTOR[i] = item N++; // La cantidad de elementos en el VECTOR aumenta en uno //Se lista el VECTOR, con los valores actuales for (i=0; i < N; i++) cout << setw(4) << VECTOR[i]; cout << "\nAhora el VECTOR tiene " << N << " elementos"; } }

144

11.6 Se elimina un elemento de un vector a partir de su posición. //VECTOR3.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include <stdlib.h> const int Max=50; main(){ int i, N; float X[Max]; do{ clrscr(); cout << "\aElementos a generar al azar en vector(Máximo " << Max << "): "; cin >> N; } while (N<1 || N>Max); //Válida el valor de N en el rango adecuado randomize(); for (i=0; i < N; i++){ X[i] = random(100); cout.width(4); cout << X[i]; } //ALGORITMO DE ELIMINACION DE ELEMENTO EN UNA DADA POSICION DE VECTOR float item; int pos; do{ cout<<"\nDigite posición de número que desea eliminar(0-" << N-1 <<"): "; cin >> pos; } while(pos<0 || pos>N-1); item = X[pos]; while(pos < N){ X[pos] = X[pos+1]; pos++; } N--; // La cantidad de elementos en el X se decrementa en uno //Se lista el X, a continuación, sin item eliminado cout << endl << "Eliminado: " << item << " del vector siguiente: \n"; for (i=0; i < N; i++) cout << setw(4) << X[i]; cout << "\n\nAhora el vector tiene " << N << " elementos"; while(!kbhit()); return 0; }

145

11.7 Se genera un vector, de la cantidad de posiciones "deseadas", aleatoriamente mostrándolo en pantalla. Finalmente se elimina un elemento a partir de su búsqueda. //VECTOR4.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include <stdlib.h> const int Max=10; main(){ int i, N; float A[Max]; do{ clrscr(); cout << "\aElementos a generar al azar en A(Máximo " << Max << "): "; cin >> N; } while (N<1 || N>Max); //Válida el valor de N en el rango adecuado randomize(); for (i=0; i < N; i++){ A[i] = random(1000)/13.0; //Se generan números reales de esta forma cout << setiosflags(ios::fixed) << setw(8) << A[i]; } //ALGORITMO DE ELIMINACION DE ELEMENTO EN VECTOR CON PREVIA BUSQUEDA float item; int pos; cout << "\nDigite valor del elemento que desea eliminar: "; cin >> item; pos = 0; while( pos < N && A[pos] != item ){ //Búsqueda secuencial del elemento pos++; } if(item == A[pos]){ //se encontró elemento y se procede a eliminarlo i = pos; while (i < N-1){ A[i] = A[i+1]; i++; } N--; //Se decrementa en uno la cantidad de elementos en el vector A //Se lista el vector A, a continuación, sin item eliminado for (i=0; i < N; i++) cout << setw(4) << A[i]; cout << "\nAhora el vector tiene " << N << " elementos"; } else cout << "\nNo se encontró el elemento \a"; }

146

11.8 ACTIVIDADES PARA REALIZAR EN GRUPOS 11.8.1 Se tiene un arreglo unidimensional, de N posiciones, en el cual cada uno de sus componentes puede ser solo un dígito. Determinar el número de veces (frecuencia) que aparece cada uno de los (diez) dígitos en el vector. 11.8.2 Leer un vector A de N elementos y un vector B de M elementos (pueden ser repetidos en cada vector). ¿Cuántas veces se encuentra presente cada elemento de A en B, no incluya elementos repetidos?. 11.8.3 Lea un vector A de N elementos todos diferentes y un vector B de M elementos los cuales pueden ser repetidos. ¿Cuántas veces se encuentra presente cada elemento de A en B? 11.8.4 Se tiene un vector de N posiciones de tipo entero. Generar a partir de él otros otros tres vectores A, B y C de suerte que en A estén solo los números pares, en B los impares y en C los múltiplos de 10. 11.8.5 Leer valores numéricos en un vector en desorden, a continuación mostrarlo en la misma secuencia pero ignorando los elementos repetidos y diciendo ¿cuántos se imprimieron?. 11.8.6 Generar por medio de la función random() vector de 100 elementos en desorden. A continuación clasificar en orden ascendente los números pares y en orden descendente los impares. 11.8.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. EXAMENES PUNTAJES 1 80 - 100 2 78 - 100 3 85 - 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. Elabore un algoritmo

que permita calcular, por medio de la utilización de arreglos unidimensionales paralelos, lo siguiente:

- El número de aspirantes aceptados en el plan 751. - El número de aspirantes aceptados en el plan 748. - El número de aspirantes que presentaron exámenes en el plan 749. - El plan que más aspirantes tuvo. - El promedio de calificaciones por plan. - El número total de Estudiantes. 11.8.8 Lea un vector de N elementos y luego imprima cuántos y cuáles elementos son múltiplos del elemento siguiente. 11.8.9 Leer un vector, y luego invertirlo sobre él mismo. (El que estaba de primero quedará de último y viceversa).

147

11.8.10 Leer un número en base 10 y a continuación presentarlo, adecudamente escrito, en base 2. Utilice vector de enteros para almacenar cada uno de los residuos que se calculan repetidamente al dividir entre 2. Al final escriba el vector en orden inverso. 11.8.11 Una línea aérea desea controlar las reservas de vuelo de un avión. El número de cupos disponible para el vuelo es de 25. Se debe presentar un menú el cual cual permita invocar las siguientes funciones: RESERVAR CUPO: El algoritmo debe pedir, al pasajero, Su nombre y en que silla quiere la reserva. En esa posición se debe asignar un UNO (1), siempre y cuando esté en el estado 0, es decir vacía, si ya está reservada, es decir en Estado 1 no se podrá efectuar reserva. (Este es el estado 1). Observe, de lo anterior que el número de la silla lo dará la posición respectiva en el vector. CANCELAR RESERVA: Se pide el número de silla que tiene reservada y se debe asignar a esa posición un CERO (0). (Vuelve al estado 0). 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, para esto asígnele un número DOS(2). (Este será el estado 2). CERRAR EL VUELO(y terminar el programa): Cuando el avión vaya a despegar, producir un listado con la siguiente estadística: a) Números de sillas que van ocupadas(Estado 2); b) Total sillas reservadas y que no viajó el pasajero(Estado 1); c) Sillas totales vacías (Estado 0 + Estado 1). d)Listado de los nombres de todos los pasajeros que viajaron, en orden

alfabético. Para lo anterior debe definir dos vectores "paralelos", uno para los nombres de los pasajeros y otro, de tipo entero, para el estado de cada una de las sillas, recuerde: cuando una silla está vacía debe tener un cero, cuando se reserve un uno, y cuando se aborda el avión (recibe el "pasabordo") debe quedar con un dos. Inicie definiendo variables tipo vector y globales para el nombre y el estado de la silla. En la función principal, main(), haga lo siguiente: Inicializar el vector de el estado de las sillas, cuyos elementos representen los números de cada una de las sillas, con Cero, (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(), Cancelar(), Confirmar() y Cerrar(). En Reservar() debe pedir el nombre del pasajero y el número de la silla en la cual quiere viajar. Se supone que al pasajero se le está mostrando un plano del avión con las sillas numeradas. En la posición del número de la silla asignarle un 1.(Estado 1 de reservada).

148

En cancelar() se debe digitar el número de la silla que el pasajero quiere cancelar y se le debe asignar un 0, volviendo al estado de vacía. En Confirmar() se debe pedir al pasajero el número de la silla, y a continuación asignarle un 2, quedando en estado de ocupada. En Cerrar() presentar en pantalla la estadística pedida y a continuación terminar el programa. 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.8.12 Efectue prueba de ejecución manual al siguiente algoritmo: //VECTOR10.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> const int Max=500; void main(){ int i, j, N, Menos; float Vector[Max]; clrscr(); cout << "\aElementos a generar al azar en vector(Máximo " << Max << "): "; cin >> N; i = Menos = 0; while( i < N ){ Menos++; j=0; while(j < Menos && i < N){ j++; i++; Vector[i-1] = -i; } if ( i < N ){ i++; Vector[i-1] = i; } } for (i=0; i < N; i++) cout << setw(5) << Vector[i]; }

149

CCAAPPÍÍTTUULLOO 1122..¡¡EErrrroorr!! MMaarrccaaddoorr nnoo ddeeffiinniiddoo.. AALLGGOORRIITTMMOOSS DDEE CCLLAASSIIFFIICCAACCIIÓÓNN DDEE VVEECCTTOORREESS 12.1 Se digitan N números se almacenan en vector y luego se ordenan. //VECTOR_3.CPP #include <iostream.h> #include <conio.h> const int N=5; main(){ int vector[N], i=0, j, aux ; clrscr(); cout << "Digite " << N << " enteros\n"; while (i < N){ cout << i+1 << ": "; cin >> vector[i]; i++; } for (i = 0; i < N-1; i++) for (j = i+1; j < N; j++) if (vector[i] > vector[j]) { aux = vector[j]; vector[j] = vector[i]; vector[i] = aux; } cout << "\nLos números ordenados en orden ascendente son:\n\n"; for(i=0; i<N; i++) cout << i+1 << ": " << vector[i] << "\n"; } Prueba de ejecución manual del programa anterior, en su fragmento de ordenamiento, se presenta a continuación para un N=5: for (i = 0; i < N-1; i++) for (j = i+1; j < N; j++) if (vector[i] > vector[j]) { aux = vector[j]; vector[j] = vector[i]; vector[i] = aux; } La variable índice i toma el valor inicial de cero, a continuación el índice j, se hace igual a i+1 o sea que a j se le asigna 1, como se muestra al comienzo de la siguiente tabla:

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 │ 0 2 2<5 4>2 SI └───┴───┴───┴───┴───┘ ┌───┬───┬───┬───┬───┐ │ 2 │ 8 │ 4 │ 3 │ 1 │ 0 3 3<5 2>3 NO └───┴───┴───┴───┴───┘ ┌───┬───┬───┬───┬───┐ │ 2 │ 8 │ 4 │ 3 │ 1 │ 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 3<5 4>3 SI └───┴───┴───┴───┴───┘ ┌───┬───┬───┬───┬───┐ │ 1 │ 3 │ 8 │ 4 │ 2 │ 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, VECTOR EN ORDENAMIENTO ASCENDENTE ───────────────────────────────────────────────────────────────────────────────

151

12.2 Se digitan N números se almacenan en vector y luego se ordenan, en forma descendente, por el algoritmo de la burbuja. (versión 1). //VECTOR_4.CPP #include <iostream.h> #include <conio.h> const int N=5; int vector[N]; //variable global Leer(){ int i=0; cout << "Digite " << N << " enteros\n"; do{ cout << i+1 << ": "; cin >> vector[i]; i++; } while (i < N); } Ordenar(){ //ALGORITMO DE CLASIFICACIÓN POR EL MÉTODO DE LA BURBUJA int i, j, aux ; for (i = 1; i < N; i++) for (j = 0; j < N-i; j++) if (vector[j] < vector[j+1]) { aux = vector[j]; vector[j] = vector[j+1]; vector[j+1] = aux; } } Escribir(){ int i=0; cout << "\nLos números en orden descendente son:\n\n"; while (i < N){ cout << i+1 << ": " << vector[i] << "\n"; i++; } } main(){ clrscr(); Leer(); Ordenar(); Escribir(); while (!kbhit()); }

152

12.3 Se efectúa inserción de elemento en un vector clasificado ascendentemente. //VECTOR5.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include <stdlib.h> const int Max=10; void main(){ int i, N, j, pos_menor, menor; float vector[Max]; do{ clrscr(); cout << "\aElementos a generar al azar en vector(Máximo " << Max << "): "; cin >> N; } while (N<1 || N>Max); //Valida el valor de N en el rango adecuado randomize(); for (i=0; i < N; i++){ vector[i] = random(100)+100; cout << setw(5) << vector[i]; } cout << endl; //Algoritmo de clasificación por selección directa(straigh selection)(versión1): for (i = 0; i < N-1; i++) { menor = vector[i]; pos_menor = i; for (j = i+1; j < N; j++){ if (vector[j] < menor) { menor = vector[j]; pos_menor = j; } } vector[pos_menor] = vector[i]; vector[i] = menor; } for (i=0; i < N; i++) cout << setw(5) << vector[i]; //A CONTINUACIÓN ALGORITMO DE INSERCIÓN EN UN VECTOR ORDENADO ASCENDENTEMENTE: //VECTOR5.CPP float item; int pos; if (N==Max) cout <<"\n\aNo se pueden insertar elementos en vector. Tiene el máximo"; else{ cout << "\n\nDigite valor del item a insertar: "; cin >> item; pos = 0; //Se busca posición donde se debe insertar el nuevo elemento while (pos < N && item > vector[pos]) pos++;

153

//A continuación se "corren" todos los elementos a la derecha de pos, //en una posición a la derecha i = N; while (i > pos){ vector[i] = vector[i-1]; i--; } vector[pos] = item; //Se inserta el item N++; // El número de elementos en el vector aumenta en uno cout << endl; for (i=0; i < N; i++) cout << setw(5) << vector[i]; cout << "\n\nAhora el vector tiene " << N << " elementos"; } }

154

12.4 Se digitan N números se almacenan en vector y luego se ordenan por el algoritmo de la burbuja.(versión 2) //VECTOR_5.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include <stdlib.h> const int Max=5; main(){ float vector[Max]; int i=0, j, aux ; clrscr(); randomize(); cout << "Vector generado aleatoriamente: \n"; for(i=0; i< Max ;i++){ vector[i] = rand(); cout.width(8); cout << vector[i] ; } for (i=Max-1; i>=1; i--) for (j=0; j<i; j++) if (vector[j] > vector[j+1]) { aux = vector[j]; vector[j] = vector[j+1]; vector[j+1] = aux; } cout << "\n\nAhora clasificado:\n"; for(i=0; i<Max ;i++) cout << setw(8) << vector[i]; } A continuación se presenta prueba de ejecución manual del ordenamiento del programa anterior: for (i= Max-1; i>=1; i--) // Max=5 posiciones(0-4) para el vector for (j=0; j<i; j++) if (vector[j] > vector[j+1]) { aux = vector[j]; vector[j] = vector[j+1]; vector[j+1] = aux; } La variable i toma el valor de Max-1 = 5-1 = 4, como se muestra en la siguiente tabla:

155

─────────────────────────────────────────────────────────────────────────────── PRUEBA DE EJECUCIÓN MANUAL DEL PROGRAMA VECTOR_5.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 │ 1 2 1<4 8>2 SI └───┴───┴────┴────┴───┘ ┌───┬───┬────┬────┬───┐ │ 4 │ 2 │ 8 │ 3 │ 1 │ 2 3 2<4 8>3 SI └───┴───┴────┴────┴───┘ ┌───┬───┬────┬────┬───┐ │ 4 │ 2 │ 3 │ 8 │ 1 │ 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 │ 1 2 1<3 4>3 SI └───┴───┴────┴────┴───┘ ┌───┬───┬────┬────┬───┐ │ 2 │ 3 │ 4 │ 1 │ 8 │ 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 ┌───┬───┬────┬────┬───┐ 0 0>=1 Falso │ 1 │ 2 │ 3 │ 4 │ 8 │ POSICIÓN FINAL, VECTOR EN ORDEN ASCENDENTE └───┴───┴────┴────┴───┘

156

12.5 Se efectúa eliminación de elemento en vector clasificado a partir de su búsqueda (versión 1). //VECTOR6.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include <stdlib.h> const int Max=10; void main(){ int i, N, j, PosMayor; int Arreglo[Max], Mayor; do{ clrscr(); cout << "Elementos a generar al azar en Vector(Máximo " << Max << "): "; cin >> N; } while (N<1 || N>Max); //Valida el valor de N en el rango adecuado randomize(); for (i=0; i < N; i++){ Arreglo[i] = random(32767); cout << setw(10) << Arreglo[i]; } //Clasificación por selección directa(straigh selection)versión 2 for (i = N-1; i >=0; i--) { Mayor = Arreglo[i]; PosMayor = i; for (j = 0; j < i; j++){ if (Arreglo[j] > Mayor) { Mayor = Arreglo[j]; PosMayor = j; } } Arreglo[PosMayor] = Arreglo[i]; Arreglo[i] = Mayor; } cout << endl; for (i=0; i < N; i++){ cout << setw(10) << Arreglo[i]; } //ALGORITMO DE ELIMINACIÓN EN VECTOR ORDENADO CON PREVIA BÚSQUEDA: float item; int pos; cout << "\n\nDigite valor del item a eliminar: "; cin >> item; pos = 0; //Se busca posición donde se encuentra el elemento while (item > Arreglo[pos] && pos < N) pos++; if (item == Arreglo[pos]){ //A continuación se "corren" todos los elementos a la derecha de pos, //en una posición a la izquierda

157

i = pos; while (i < N){ Arreglo[i] = Arreglo[i+1]; i++; } N--; // El número de elementos en el Vector se decrementa en uno cout << endl; for (i=0; i < N; i++) cout << setw(10) << Arreglo[i]; cout << "\n\nAhora el Vector tiene " << N << " elementos"; } else cout << "\n\nElemento no se encuentra en el Vector\a\a"; } Del programa anterior, explique el algoritmo de clasificación como ejercicio. Ahora, supongamos que, 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; después de la búsqueda la variable pos tendrá el valor de 1, y luego se le asigna a la i; en el ciclo while los valores del arreglo variaran, debido a la instrucción: Arreglo[i] = Arreglo[i+1], de la siguiente forma para cada i: 0 1 2 3 4 ┌───┬───┬────┬────┬───┐ │ 1 │ 3 │ 3 │ 4 │ 8 │ para i = 1. Arreglo[1] = Arreglo[1+1] └───┴───┴────┴────┴───┘ ┌───┬───┬────┬────┬───┐ │ 1 │ 3 │ 4 │ 4 │ 8 │ para i = 2. Arreglo[2] = Arreglo[2+1] └───┴───┴────┴────┴───┘ ┌───┬───┬────┬────┬───┐ │ 1 │ 3 │ 4 │ 8 │ 8 │ para i = 3. Arreglo[3] = Arreglo[3+1] └───┴───┴────┴────┴───┘ para i=4 el while(i<N-1) se vuelve falso. A continuación la variable N se decrementa en uno, y de esta forma tendremos eliminado el item deseado: 0 1 2 3 ┌───┬───┬────┬────┐ │ 1 │ 3 │ 4 │ 8 │ └───┴───┴────┴────┘

158

12.6 Se digitan N palabras, se almacenan en vector y luego se ordenan //VECTOR_7.CPP #include <iostream.h> #include <conio.h> #include <string.h> const int N=5; const int LargoCadena=20; char cadena[N][LargoCadena]; //observe que es un arreglo bidimensional Leer(){ int i=0; gotoxy(10,2); cout << "Digite " << N << " palabras"; for(i=0; i < N; i++){ gotoxy(10,4+i); cin >> cadena[i]; } } Ordenar(){ int i,j; char aux[LargoCadena]; for (i = 0; i < N-1; i++) for (j = i+1; j < N; j++) if (strcmp(cadena[i], cadena[j]) > 0) { strcpy(aux, cadena[j]); strcpy(cadena[j], cadena[i]); strcpy(cadena[i], aux); } } Escribir(){ int i; cout << "\n\tLas palabras ordenadas son:\n\n"; for (i = 0; i < N; i++){ gotoxy(10,12+i); cout << cadena[i]; } } main(){ clrscr(); Leer(); Ordenar(); Escribir(); while (!kbhit()); }

159

12.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. (Versión 2. ver vector6.cpp) El programa fuente: //VECTOR_6.CPP #include <iostream.h> #include <conio.h> const int N=5; int vector[N]; //variable global Leer(){ int i=0; clrscr(); cout << "Digite " << N << " enteros:\n\n"; while (i < N){ cout << i << ": "; cin >> vector[i]; i++; } } Ordenar(){ int i, j, pos, Mayor; for (i = 0; i < N-1; i++) { Mayor = vector[i]; pos = i; for (j = i+1; j < N; j++){ if (vector[j] > Mayor) { Mayot = vector[j]; pos = j; } } vector[pos] = vector[i]; vector[i] = Mayor; } } Escribir(){ int i=0; cout << "\nOrdenados descendentemente:\n\n"; do{ cout << i << ": " << vector[i] << "\n"; i++; } while (i < N); } void main(){ Leer(); Ordenar(); Escribir(); } A continuación se presenta prueba de ejecución manual para el anterior programa VECTOR_6.CPP El programa inicia su ejecución en la función main(), en ella inicialmente se borra la pantalla, clrscr(), y a continuación se invoca una tras otra las

160

funciones Leer(), Ordenar() y Escribir() para de esta forma terminar el programa. La primera función invocada es Leer(), en ella se propone al usuario que digite N números enteros, en este caso 5, por teclado, los cuales son almacenados en posiciones sucesivas, i, de la variable global Vector; para esto se utiliza la instrucción repetitiva while la cual es controlada por la variable i, 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 función Ordenar() produce la clasificación del vector por el método de encontrar el mayor elemento y colocarlo en "su sitio", es decir en la posición más a la izquierda; esto se repite sucesivamente, dando como resultado el ordenamiento del vector en forma descendente. La función Escribir() nos muestra en pantalla los valores del vector en orden descendente, por medio de la instrucción repetitiva do...while, la cual se vuelve falsa cuando la variable local i se iguala con N, en este caso 5. 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- │ 4 │ │ 4: 58 │ ente los siguientes valores: 0, 1, │ 5 │ │ - │ 2, 3, 4, 5. └───┘ └──────────────────┘ ───────────────────────────────────────────────────────────────────────────────

161

En la invocación de la función Ordenar() se produce clasificación descendente del vector, 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.│ │ │ │ │ │ │ │ │ │ 27 │ 2 │ │ │ │ │ │ │ │ │ ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┤ │ │ │ │ │ │ │ │ │ │ │3 │ V │6>13:falso │ │ │ │ │ │ ├──┼─────┼──────┼─────┼───┼──┼─────┼───────────┤ │ │ │ │ │ │ │ │ │ │ │4 │ V │58>13:verd.│ │ │ │ │ │ │ │ │ │ 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│ │ │ │ │ │ │ │ │ │ └──┴─────┴──────┴─────┴───┴──┴─────┴───────────┴───────────┴───┴───┘

162

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 ┌──────────────────────────────────┐ Vector (en RAM) │ Digite 5 enteros: │ ┌─────┬─────┬─────┬─────┬─────┐ │ │ │ 58 │ 27 │ 13 │ 7 │ 6 │ │ 0: 13 │ └─────┴─────┴─────┴─────┴─────┘ │ 1: 7 │ 0 1 2 3 4 │ 2: 27 │ │ 3: 6 │ │ 4: 58 │ │ │ │ i │ │ Ordenados Descendentemente: │ ├───┤ │ │ │ 0 │ │ 0: 58 │ │ 1 │ │ 1: 27 │ │ 2 │ │ 2: 13 │ │ 3 │ │ 3: 7 │ │ 4 │ │ 4: 6 │ │ │ │ - │ └───┘ └──────────────────────────────────┘ 12.8 ACTIVIDADES PARA REALIZAR EN GRUPOS Y PERSONALMENTE 12.8.1 Efectúe prueba de ejecución manual al siguiente fragmento, del programa VECTOR12.CPP, en el cual se ordenan por medio de el algoritmo de Inserción Binaria. Ver "Algoritmos y Estructuras de Datos" de Niklaus Wirth. for (i = 1; i < N; i++){ Aux = Vector[i]; Izq = 0; Der = i; while(Izq < Der){ Medio = (Izq + Der)>>1; if (Vector[Medio] <= Aux) Izq = Medio + 1; else Der = Medio; } for (j=i; j>=Der+1; j--) Vector[j] = Vector[j-1]; Vector[Der] = Aux; } 12.8.2 Se tienen dos vectores ordenados y sin elementos repetidos cada uno en memoria; producir a partir de ellos uno tercero también ordenado(fusión). Copiar los elementos que estén en ambos solo una vez. 12.8.3 Dado un vector que almacene los nombres de pila de los estudiantes de la Universidad, calcule la frecuencia de cada nombre. Una forma de resolver podría ser clasificando en orden ascendente los nombres. 12.8.4 Efectúe prueba de ejecución manual al siguiente fragmento, del programa VECTOR11.CPP, en el cual se ordenan número por el algoritmo de intercambio directo ó burbuja. Ver "Algoritmos y Estructuras de Datos" de Niklaus Wirth.

163

for (i = 1; i < N; i++) for (j = N-1; j >=i; j--) if (Vector[j-1] > Vector[j]) { Aux = Vector[j-1]; Vector[j-1] = Vector[j]; Vector[j] = Aux; } 12.8.5 Efectúe prueba de ejecución manual al siguiente fragmento, del programa VECTOR13.CPP, en el cual se ordenan por intermedio del algoritmo de Vibración (shakesort). Ver "Algoritmos y Estructuras de Datos" de Niklaus Wirth. Izq = 0; Der = N-1; k = N-1; do{ for (j = Der; j >= Izq; j--) if (Vector[j-1] > Vector[j]){ Aux = Vector[j-1]; Vector[j-1] = Vector[j]; Vector[j] = Aux; k = j; } Izq = k+1; for (j=Izq; j<=Der; j++) if (Vector[j-1] > Vector[j]){ Aux = Vector[j-1]; Vector[j-1] = Vector[j]; Vector[j] = Aux; k = Der; } Der = k-1; } while (Izq < Der);

165

¡¡EErrrroorr!! MMaarrccaaddoorr nnoo ddeeffiinniiddoo..CCAAPPÍÍTTUULLOO 1133.. AALLGGOORRIITTMMOOSS CCOONN VVEECCTTOORREESS ((CCoonnttiinnuuaacciióónn)) 13.1 Cálculo de números primos por la Criba de Eratóstenes. //VECTOR8.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> const int Max=2000; void main(){ int i, multiplo, A[Max]; for (i=2 i < Max; i++) A[i] = i; for (i=4; i < Max; i=i+2) //Se "eliminan" todos los pares A[i] = 0; i = 3; while ( i < (Max/2) ){ //Se eliminan todos los múltiplos de impares multiplo = i*2; while (multiplo < Max){ A[multiplo] = 0; multiplo = multiplo + i; } i += 2; } clrscr(); for (i=2; i < Max; i++) if (A[i]!=0) cout << setw(5) << A[i]; } El algoritmo anterior sigue la siguiente secuencia: en la primera instrucción FOR se asigna a cada posición, iniciando en 2, 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... ┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬── │ │ │ 2│ 3│ 4│ 5│ 6│ 7│ 8│ 9│10│11│12│13│14│15│16│17│18│19│20│21│22│23│24│25│.. └──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴── En el segundo FOR se eliminan todos los pares, con excepción del 2, el cual es un número primo, 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│.. └──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴── A continuación se eliminan todos los múltiplos de 3, 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│.. └──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──

166

Se incrementa el contador en dos para obtener 5 y se procede a borrar los múltiplos del mismo, 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│.. └──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴── y así sucesivamente. 13.2 Se efectúa la fusión de dos vectores, A de tamaño M y B de Tamaño N, clasificados en un tercer vector C de tamaño M+N. //VECTOR7.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include <stdlib.h> const int Max=10; main(){ int i, j, k, l, M, N; float A[Max], B[Max], C[Max*2], aux; do{ clrscr(); cout << "\aElementos a generar al azar en A(Máximo " << Max << "): "; cin >> M; } while (M<1 || M>Max); //Valida el valor de M en el rango adecuado do{ clrscr(); cout <<"\aElementos a generar al azar en A(Máximo " <<Max << "): " << M; cout <<"\n\aElementos a generar al azar en B(Máximo " << Max << "): "; cin >> N; } while (N<1 || N>Max); //Valida el valor de N en el rango adecuado randomize(); for (i=0; i < M; i++) //Se genera "al azar" el vector A A[i] = random(100); for (i=0; i < N; i++) //Se genera "al azar" el vector B B[i] = random(100); for (i = 0; i < M; i++) //Clasificación vector A for (j = i; j < M; j++) if (A[i] > A[j]) { aux = A[j]; A[j] = A[i]; A[i] = aux; } for (i = 0; i < N; i++) //Clasificación vector B for (j = i; j < N; j++) if (B[i] > B[j]) { aux = B[j]; B[j] = B[i]; B[i] = aux;

167

} clrscr(); cout << "Vector A:\n"; for(i=0; i<M; i++) cout << setw(5) << A[i]; cout << "\nVector B:\n"; for(i=0; i<N; i++) cout << setw(5) << B[i]; //ALGORITMO DE FUSIÓN DE DOS VECTORES CLASIFICADOS EN UNO TERCERO //VECTOR7.CPP cout << "\n\nFUSION DE LOS DOS VECTORES:\n"; i = j = k = 0; while(i < M && j < N ){ if (A[i] <= B[j]){ C[k] = A[i]; i++; } else{ C[k] = B[j]; j++; } k++; } if(i==M) //Se término primero el vector A for (l=j; l<N; l++){ C[k]=B[l]; k++; } else //Se término primero el vector B for (l=i; l<M; l++){ C[k]=A[l]; k++; } for (i=0; i < M+N; i++) cout << setw(4) << C[i]; }

168

13.3 Se digitan N números se almacenan en vector luego se ordenan y finalmente se presenta el algoritmo de búsqueda binaria. //VECTOR_8.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include <stdlib.h> //funciones para generar al azar #include <values.h> //MAXINT main(){ const falso=0, verdad=1, N=10; int vector[N] j, aux, HaHabidoIntercambio, pasada, item, izq=0, der=N-1, medio; clrscr(); cout << N << " NÚMEROS GENERADOS AL AZAR\n\n"; randomize(); for (j=0; j<N; j++){ vector[j] = random(MAXINT); cout << setw(8) << vector[j]; } pasada=0; HaHabidoIntercambio=verdad; while (pasada<N && HaHabidoIntercambio){ HaHabidoIntercambio=falso; for (j = 0; j < N-pasada-1; j++) if (vector[j] > vector[j+1]){ aux = vector[j+1]; vector[j+1] = vector[j]; vector[j] = aux; HaHabidoIntercambio=verdad; } pasada++; } cout << "\n\nLOS MISMOS NÚMEROS AHORA EN ORDEN ASCENDENTE:\n\n"; for (j=0; j<N; j++) cout << setw(8) << vector[j]; // ALGORITMO DE LA BÚSQUEDA BINARIA cout << "\n\nDigite un número para encontrarlo en el vector: "; cin >> item; medio = (izq+der)/2; while (vector[medio] != item && izq < der){ if (item > vector[medio]) izq=medio+1; else if (item < vector[medio]) der=medio-1; medio = (izq+der)/2; } if (vector[medio] == item) cout << "\nEncontrado en posición " << medio; else cout << "No encontrado \a"; }

169

13.4 El siguiente programa permite leer palabras en un vector de cadena(matriz de caracteres) y a continuación invertirlo, el primero quedará de último y viceversa. //VECTOR9.CPP #include <iostream.h> #include <conio.h> #include <string.h> const int Max=5; //cambie para Max igual a un número par const int LargoCadena=20; char cadena[Max][LargoCadena]; void Leer(){ gotoxy(10,2); cout << "Digite " << Max << " palabras"; for(int i=0; i < Max; i++){ gotoxy(10,4+i); cin >> cadena[i]; } } Intercambiar(){ int i,j; char aux[LargoCadena]; for (j = 1; j < Max; j++) for (i = 0; i < Max-j; i++) { strcpy(aux, cadena[i]); strcpy(cadena[i], cadena[i+1]); strcpy(cadena[i+1], aux); } } void Escribir(){ cout << "\n\tEste es ahora el orden de las palabras:\n\n"; for (int i = 0; i < Max; i++){ gotoxy(10,12+i); cout << cadena[i]; } } void main(){ Leer(); Intercambiar(); Escribir(); }

170

13.5 ACTIVIDADES PARA REALIZAR EN GRUPOS 13.5.1 Lea un vector de N elementos de tipo real. Almacene en otro vector los elementos mayores que el número pi. 13.5.2 Dado un vector "cantidad" de N posiciones, 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. Calcular el volumen de ventas semanal en pesos en otro vector "ventas" para cada uno de los artículos. Finalmente calcule el total vendido en la semana. 13.5.3 Leer un número entero y utilizando el vector obtenido en el programa VECTOR8.CPP por medio del algoritmo de la Criba de Eratóstenes, encontrar todos sus factores primos. Por ejemplo si se digita el 960 se debe imprimir en pantalla: 960 = 2x2x2x2x2x2x3x5. 13.5.4 Se tendrán cuatro vectores A, B, C y D de MAX elementos. Se deben leer por teclado N elementos para el vector A y m elementos para el B. 13.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. 13.5.6 Si los vectores A y B tienen igual cantidad de elementos, se debe obtener un vector C que guarde en cada posición la suma de los correspondientes de A y B. 13.5.7 Lea dos vectores A y B de igual número de elementos. 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.8 Calcule el producto escalar de dos vectores A y B, teniendo en cuenta que: A = (a1, a2, .... an) B = (b1, b2, ... bn) y de esta forma el producto escalar A B, está dado por: A B = a1b1 + a2b2 + ... + anbn recuerde que el resultado de esta expresión es un escalar. 13.5.9 Debe digitar por teclado los n componentes de cada uno de los dos vectores, a continuación efectuar el cálculo correspondiente al producto escalar y luego presentarlo en pantalla adecuadamente. 13.5.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.

171

13.5.11 Efectúe prueba de ejecución manual a cada una de las siguientes funciones, la variable cadena está en memoria y se ha definido así: char cadena[Max][LargoCadena]; //Max y LargoCadena son constantes globales void Intercambio1(){ int i=0, j=Max-1; char aux[LargoCadena]; while(i<j) { strcpy(aux, cadena[i]); strcpy(cadena[i], cadena[j]); strcpy(cadena[j], aux); i++; j--; } } void Intercambio2(){ int i=0; char aux[Max][LargoCadena]; //observe que aux es un vector de cadenas do{ strcpy(aux[i], cadena[i]); strcpy(cadena[i], cadena[Max-i-1]); i++; } while(i<=Max/2); for(i=Max/2; i<Max; i++) strcpy(cadena[i], aux[Max-i-1]); } void Intercambio3(){ int i,j = Max; char aux[LargoCadena]; for (i = 0; i < Max/2; i++) { j--; strcpy(aux, cadena[i]); strcpy(cadena[i], cadena[j]); strcpy(cadena[j], aux); } } void Intercambio4(){ int i; char aux[LargoCadena]; for (i = 0; i < Max/2; i++) { strcpy(aux, cadena[i]); strcpy(cadena[i], cadena[Max-1-i]); strcpy(cadena[Max-1-i], aux); } }

173

CCAAPPÍÍTTUULLOO 1144.. ¡¡EErrrroorr!! MMaarrccaaddoorr nnoo ddeeffiinniiddoo..AARRRREEGGLLOOSS BBIIDDIIMMEENNSSIIOONNAALLEESS 14.1 INTRODUCCIÓN Los arreglos pueden tener múltiples dimensiones, aquí trataremos solamente los de dos dimensiones, mejor conocidos como matrices o tablas. En los arreglos multidimensionales el número de índices específicos que se requieren para accesar un elemento, corresponde al número de dimensiones, por esto en los arreglos bidimensionales o matrices necesitaremos dos índices; un índice para las filas y otro para las columnas. El dimensionamiento en lenguaje C/C++ se efectuará de la siguiente forma: se coloca el tipo, 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, así por ejemplo se podría dar esta definición: int Matriz[5][4]; esta sería una variable estructurada compuesta por 5 filas y 4 columnas, de la cual nos hacemos la siguiente idea o abstracción:

¡Error! Marcador no definido.

0 1 2 3

0 34 23 67 123

1 0 -5 45 87

2 76 15 13 111

3 53 69 -7 73

4 19 23 0 33

las cinco filas se numeran desde el 0 hasta el 4, las cuatro columnas se numerarán desde el 0 hasta el 3. De esta forma en la fila 0 columna 0 está almacenado el número entero 34, está posición se denotará como Matriz[0][0], y se lee como "Matriz su cero cero". En la posición Matriz[0][1], que se lee "Matriz su cero uno", está almacenado un 23, el cero corresponde a la fila y el uno a la columna.

174

En la posición Matriz[4][1], el 4 corresponde a la fila y el 1 corresponde a la columna, está almacenado un 23. En la posición Matriz[3][4], el 3 corresponde a la fila y el 4 corresponde a la columna, está almacenado un 73.

175

14.2 Se lee un arreglo bidimensional por teclado y luego se muestra en pantalla adecuadamente. //MATRIZ1.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> const int MaxFilas=5; const int MaxColumnas=4; void main(){ int fila, columna, MATRIZ[MaxFilas][MaxColumnas]; clrscr(); for ( fila = 0; fila < MaxFilas; fila++) for ( columna = 0; columna < MaxColumnas; columna++) { cout << "Posición: (" << fila << "," << columna << "): "; cin >> MATRIZ[fila][columna]; } clrscr(); for ( fila = 0; fila < MaxFilas; fila++) { for ( columna = 0; columna < MaxColumnas; columna++) cout << setw(6) << MATRIZ[fila][columna]; cout << endl; } } 14.3 Se genera al azar un arreglo bidimensional y luego se muestra en pantalla adecuadamente. //MATRIZ2.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include <stdlib.h> const int MaxFilas=24; const int MaxColumnas=13; main(){ int fila, columna, MATRIZ[MaxFilas][MaxColumnas]; clrscr(); randomize(); for ( fila = 0; fila < MaxFilas; fila++) { for ( columna = 0; columna < MaxColumnas; columna++) { MATRIZ[fila][columna] = random(100)+100; cout << setw(6) << MATRIZ[fila][columna]; } cout << endl; } }

176

14.4 Se dan valores a un arreglo bidimensional al definirlo, se muestra en pantalla con su sumatoria. Luego se presenta suma de cada una de sus filas. Finalmente y "recorriendo la matriz por columnas" se suman sus columnas. //MATRIZ3.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include <stdlib.h> const int MaxFilas=4; const int MaxColumnas=5; main(){ int fila, columna; float MATRIZ[MaxFilas][MaxColumnas] = {14, 26, 90, 0, -30, 8, 12, 32, 54, 12, 54, 34, -5, 23, 75, 43, 67, 98, 12, -10 }; float Suma = 0; clrscr(); for ( fila = 0; fila < MaxFilas; fila++) { for ( columna = 0; columna < MaxColumnas; columna++) { cout << setw(4) << MATRIZ[fila][columna]; Suma += MATRIZ[fila][columna]; } cout << endl; } cout << "\nSumatoria de la matriz = " << Suma << endl; for ( fila = 0; fila < MaxFilas; fila++) { Suma = 0; for ( columna = 0; columna < MaxColumnas; columna++) Suma += MATRIZ[fila][columna]; cout << "\nSumatoria de la fila " << fila << " = " << Suma; } cout << endl; for ( columna = 0; columna < MaxColumnas; columna++){ Suma = 0; for ( fila = 0; fila < MaxFilas; fila++) Suma += MATRIZ[fila][columna]; cout << "\nSumatoria de la columna " << columna << " = " << Suma; } while (!kbhit()); }

177

14.5 Asigna a una matriz los números desde uno hasta filas*columnas, es decir se numeran las posiciones de izquierda a derecha y de arriba hacia abajo. //MATRIZ4.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> const int MaxFilas=24; const int MaxColumnas=15; main(){ int fila, Filas, columna, Columnas, MATRIZ[MaxFilas][MaxColumnas]; clrscr(); cout << "Digite el número de filas deseado (Máximo " << MaxFilas << "): "; cin >> Filas; cout << "Número de columnas deseado (Máximo " << MaxColumnas << "): "; cin >> Columnas; gotoxy(1,3); for ( fila = 0; fila < Filas; fila++) { for ( columna = 0; columna < Columnas; columna++) { MATRIZ[fila][columna] = fila * Columnas + columna + 1; cout << setw(5) << MATRIZ[fila][columna]; } cout << endl; } } 14.6 Se generan las tablas de multiplicar del 1 al 10. //MATRIZ5.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> main(){ int i, j, Tabla[10][10]; clrscr(); for ( i = 0; i < 10; i++) for ( j = 0; j < 10; j++) Tabla[i][j] = (i+1)*(j+1); cout << " "; for ( i = 0; i < 10; i++) cout << setw(4) << i+1; cout << endl << endl; for ( i = 0; i < 10; i++) { cout << setw(4) << i+1 << " "; for ( j = 0; j < 10; j++) cout << setw(4) << Tabla[i][j]; cout << endl; } }

178

14.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], es decir en relación a la diagonal principal. Se produce un intercambio alrededor de la diagonal principal o sea intercambio de filas por columnas. //MATRIZ6.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include <stdlib.h> const int N=10; void main(){ int fila, columna, n; float MATRIZ[N][N], AUX; do{ clrscr(); cout << "Digite dimensión de matriz deseada (Máximo " << N << "): "; cin >> n; } while (n<1 && n>N); randomize(); // Se genera al azar la matriz for ( fila = 0; fila < n; fila++) { for ( columna = 0; columna < n; columna++) { MATRIZ[fila][columna] = random(100); cout << setw(5) << MATRIZ[fila][columna]; } cout << endl; } for ( fila = 1; fila < n; fila++) //Se produce intercambio en relación a la diagonal principal for ( columna = 0; columna < fila; columna++) { AUX = MATRIZ[fila][columna]; MATRIZ[fila][columna] = MATRIZ[columna][fila]; MATRIZ[columna][fila] = AUX; } cout << "\nIntercambio de Filas por Columnas: \n"; for ( fila = 0; fila < n; fila++) { for ( columna = 0; columna < n; columna++) cout << setw(5) << MATRIZ[fila][columna]; cout << endl; } getch(); }

179

14.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. //MATRIZ7.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include <stdlib.h> const int MaxM=10; const int MaxN=8; void main(){ int i, M, j, N; float A[MaxM][MaxN], B[MaxN][MaxM]; clrscr(); do{ cout << "Digite el número para M deseado (Máximo " << MaxM << "): "; cin >> M; } while (M<1 && M>MaxM); do{ cout << "Número para N deseado (Máximo " << MaxN << "): "; cin >> N; } while (N<1 && N>MaxN); randomize(); cout << "\nMATRIZ A:\n"; for ( i = 0; i < M; i++) { for ( j = 0; j < N; j++) { A[i][j] = random(100); cout << setw(5) << A[i][j]; } cout << endl; } for ( i = 0; i < M; i++) for ( j = 0; j < N; j++) B[j][i] = A[i][j]; cout << "\nMATRIZ B:\n"; for ( j = 0; j < N; j++) { // j recorre las filas for ( i = 0; i < M; i++) // i recorre las columnas cout << setw(5) << B[j][i]; cout << endl; } getch(); }

180

14.9 Se dan valores a una matriz al definirla, luego se muestra en pantalla con su correspondiente sumatoria. Posteriormente se efectúa la suma de las filas asignando el resultado a correspondientes posiciones de un vector. Luego se recorre la matriz por columnas efectuando la sumatoria de las mismas en correspondientes posiciones de otro vector. Finalmente se presentan las sumas de filas y columnas de la matriz contenidas en los sendos vectores. //MATRIZ8.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #include <stdlib.h> const int MaxFilas=4; const int MaxColumnas=5; main(){ int f, c; float Matriz[MaxFilas][MaxColumnas] = {14, 76, 91, 0, -3, 8, 12, 32, 54, 12, 54, 34, -5, 23, 75, 43, 67, 98, 12, 65}; float SumaMatriz=0, VectorFila[MaxFilas], VectorColumna[MaxColumnas]; for ( f = 0; f < MaxFilas; f++) { VectorFila[f] = 0; for ( c = 0; c < MaxColumnas; c++) VectorFila[f] += Matriz[f][c]; } for ( c = 0; c < MaxColumnas; c++){ VectorColumna[c] = 0; for ( f = 0; f < MaxFilas; f++){ VectorColumna[c] += Matriz[f][c]; SumaMatriz += Matriz[f][c]; } } clrscr(); cout << " "; for ( c = 0; c < MaxColumnas; c++) cout << setw(4) << c; cout << "\n\n"; for ( f = 0; f < MaxFilas; f++) { cout << f << ": "; for ( c = 0; c < MaxColumnas; c++) cout << setw(4) << Matriz[f][c]; cout << " " << VectorFila[f] << endl; } cout << endl << " "; for ( c = 0; c < MaxColumnas; c++) cout << setw(4) << VectorColumna[c]; cout << " " << SumaMatriz; }

181

14.10 El siguiente programa presenta un sencillo algoritmo el cual permite jugar al tres en raya o "triqui". #include<stdio.h> #include<stdlib.h> #include<conio.h> #include<iostream.h> main(){ char matriz[3][3], ganador; int i,j,x,y; //inicializar la matriz con un espacio en blanco en cada posición for (i=0;i<3;i++) for (j=0;j<3;j++) matriz[i][j]=' '; do{ clrscr(); //mostrar la matriz for(i=0;i<3;i++){ cout<<" "<<matriz[i][0]<<" | "<<matriz[i][1]<<" | "<<matriz[i][2]; if(i!=2) cout<<"\n---|---|---\n"; } cout<<"\n\n"; do{ //turno del jugador do{ cout<< "USTED JUEGA CON LA X. EL COMPUTADOR CON 0\n" << "Teclee sus coordenadas separadas por un espacio en blanco: "; cin >> x >> y; } while ( (x<1 || x>3) || (y<1 || y>3) ); x--; y--; if (matriz[x][y]!=' ') cout<<"no se puede, intenta otra coordenada\n"; } while (matriz[x][y]!=' '); matriz[x][y]='X'; //verificación de triunfo del jugador for(i=0;i<3;i++) if(matriz[i][0]==matriz[i][1] && matriz[i][0]==matriz[i][2]) ganador=matriz[i][0]; for(i=0;i<3;i++) if(matriz[0][i]==matriz[1][i] && matriz[0][i]==matriz[2][i]) ganador=matriz[0][i]; if(matriz[0][0]==matriz[1][1] && matriz[1][1]==matriz[2][2]) ganador=matriz[0][0]; if(matriz[0][2]==matriz[1][1] && matriz[1][1]==matriz[2][0]) ganador=matriz[0][2]; if (ganador==' '){ //verifica si gano el jugador //turno del computador

182

for(x=0;x<3;x++){ for(y=0;y<3;y++) if(matriz[x][y]==' ')break; if(matriz[x][y]==' ')break; } if(x*y==9){ cout << "Tablas.\n"; getch(); exit(0); } else matriz[x][y]='O'; } //verificacion de triunfo del computador for(i=0; i<3; i++) if(matriz[i][0]==matriz[i][1] && matriz[i][0]==matriz[i][2]) ganador=matriz[i][0]; for(i=0; i<3; i++) if(matriz[0][i]==matriz[1][i] && matriz[0][i]==matriz[2][i]) ganador=matriz[0][i]; if(matriz[0][0]==matriz[1][1] && matriz[1][1]==matriz[2][2]) ganador=matriz[0][0]; if(matriz[0][2]==matriz[1][1] && matriz[1][1]==matriz[2][0]) ganador=matriz[0][2]; } while (ganador==' '); //presentación del tablero final clrscr(); for(i=0;i<3;i++){ cout<<" "<<matriz[i][0]<<" | "<<matriz[i][1]<<" | "<<matriz[i][2]; if(i!=2) cout<<"\n---|---|---\n"; } //Escribe el mensaje de triunfo según el ganador if (ganador=='X') cout<<"\nfelicitaciones, usted acaba de ganar"; else cout<<"\nlo siento, el computador gano"; getch(); }

183

14.11 El siguiente programa presenta la multiplicación de dos matrices A y B. Ver la primera pregunta en los ejercicios asignados, para refrescar la memoria sobre esta multiplicación.

//MATRIZ9.CPP

#include <iostream.h> #include <iomanip.h> #include <conio.h> const int M=2, N=3, P=4; void main(){ int A[M][P], B[P][N], C[M][N], i, j, k; clrscr(); cout << "Digite valores de la matriz A de " << M << "x" << P << ":\n"; for ( i = 0; i < M; i++) for ( j = 0; j < P; j++) { cout << "Posición: (" << i << "," << j << "): "; cin >> A[i][j]; } clrscr(); cout << "\nDigite valores de la matriz B de " << P << "x" << N << ":\n"; for ( i = 0; i < P; i++) for ( j = 0; j < N; j++) { cout << "Posición: (" << i << "," << j << "): "; cin >> B[i][j]; } // ALGORITMO: MULTIPLICACIÓN DE DOS MATRICES for ( i = 0; i < M; i++) for ( j = 0; j < N; j++){ C[i][j] = 0; for ( k = 0; k < P; k++) C[i][j] = C[i][j] + A[i][k] * B[k][j]; } clrscr(); for ( i = 0; i < M; i++) { for ( j = 0; j < P; j++) cout << setw(10) << A[i][j]; cout << endl; } cout << endl; for ( i = 0; i < P; i++) { for ( j = 0; j < N; j++) cout << setw(10) << B[i][j]; cout << endl; } cout << endl; for ( i = 0; i < M; i++) { for ( j = 0; j < N; j++) cout << setw(10) << C[i][j]; cout << endl; } }

184

14.12 ACTIVIDADES PARA RESOLVER POR GRUPOS DE ESTUDIO 14.12.1 Estudie el algoritmo de multiplicación de matrices, C = A x B, dado en el programa MATRIZ11.CPP, 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. La matriz Bij debe ser de orden p x m y en la cual su j-ésima columna la denotamos por bj. 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. Esto es, el ij-ésimo elemento de C es el producto escalar de la i-ésima fila de A, y la j-ésima columna de B. Para obtenerse la expresión final: cij = ai1b1j + ai2b2j + ... + 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. De otra forma, los vectores ai y bj tendrían diferente número de componentes y el producto escalar correspondiente no estaría definido. 14.12.2 Efectúe lectura del siguiente algoritmo. //MATRIZ_1.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> #define MaxFilas 20 #define MaxColumnas 15 void main(){ int fila, Filas, columna, Columnas, MATRIZ[MaxFilas][MaxColumnas]; clrscr(); cout << "Digite el número de filas deseado (Máximo " << MaxFilas << "): "; cin >> Filas; cout << "Número de columnas deseado (Máximo " << MaxColumnas << "): "; cin >> Columnas; gotoxy(1,4); for ( fila = 0; fila < Filas; fila++) { for ( columna = 0; columna < Columnas; columna++) { MATRIZ[fila][columna] = fila * Columnas + columna + 1; cout << setw(5)<< MATRIZ[fila][columna]; } cout << endl; } getch(); }

185

14.12.3 Solucione un sistema de ecuaciones lineales, compuesto de tres ecuaciones y tres incógnitas, por el método de Cramer. Lea inicialmente los coeficientes (a, b, c, d, e, f, g, h, i, j, k, l) y calcule los valores de las incógnitas X, Y, Z. El sistema general a solucionar, recuerde que son tres rectas en el espacio, es el siguiente: a X + b Y + c Z = d e X + f Y + g Z = h i X + j Y + k Z = 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, así:

¡Error! Marcador no definido.a

b c d

e f g h

i j k l

14.12.4 Estudie y mejore el juego de "triqui" o tres en raya presentado en el programa TRIQUI.CPP anterior. Observe que es muy fácil ganarle al computador y no debiera ser así. 14.12.5 Una empresa tiene para los últimos años el siguiente cuadro de producción:

¡Error! Marcador no definido.MESES-->

1 2 3 4 5 6 7 8 9 10 11 12

186

AÑO

1994 2344

4543

567 4545 434 3452 4542 1233 4545 5454 5453 2321

1995 5321

655 56 7545 4545 4544 1234 1866 6654 234 434 678

1996 567 543 234 665 976 3454 554 5453 4532 3322 5332 2345

1997 3453

6544

3455

1234 7533 3454 7544 7443 3432 6543 3466 6543

1998 6353

6533

7643

8643 8755 9134 9566 9665 9654 10454 9544 9555

Defina una matriz de 5 filas y 12 columnas de tipo float, y calcule lo siguiente: a) El promedio de producción de cada uno de los años. b) El mes de mayor producción de 1996. c) El año de menos producción. d) Invente dos preguntas más, similares.

187

CCAAPPÍÍTTUULLOO 1155 PPUUNNTTEERROOSS YY PPAASSOO PPOORR RREEFFEERREENNCCIIAA 15.1 INTRODUCCIÓN Los punteros son variables las cuales guardan direcciones de memoria RAM. En memoria un puntero ocupa 2 bytes. 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, decimos entonces que el puntero "apunta" a esta variable, de la siguiente forma: P VAR ┌────┐ ┌───────────────────────┐ │1000│ │ │ "P apunta a VAR" └────┘ └───┴───┴───┴───┴───┴───┘ 1000 1000 es una dirección(ficticia en nuestro ejemplo, la verdadera la dará el sistema operativo por intermedio del compilador, cuando esté ejecutándose el programa) en memoria, la variable P almacena un valor de 1000. La variable VAR se encuentra en la dirección de memoria 1000(inicia desde hay). La abstracción que se debe hacer es la de que P apunta o señala a VAR. Se puede definir un puntero de cualquier tipo básico o de tipos estructurados; al efectuar su declaración se debe anteponer un asterisco, *, al identificador del mismo. 15.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, entero=13; p entero ┌────┐ ┌─────────┐ │ │ │ 1 │ 3 │ └────┘ └────┴────┘ 1500 1501 1500 es la dirección base de la variable entero, entero al ocupar 2 bytes estamos suponiendo que ocupará las direcciones 1500 y 1501, estos dos bytes son el desplazamiento(offset) de la variable entero. Observe que el 13 almacenado en la variable entero no está en base 10 como es mostrado, sino en binario, empero lo supondremos de esta forma por facilidad. A continuación el puntero p tomará la dirección de la variable entero: p = &entero; se lee esta instrucción así: "la dirección(&) de la variable entero se asigna a la variable puntero p"; en memoria el efecto es el siguiente:

188

p entero ┌────┐ ┌─────────┐ │1500│ │ 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; Está mostrará el valor de 13 en pantalla; *p debe ser leído como: "el valor al cual apunta p", y para saber cual es el valor al cual apunta p, debemos "saber" la dirección que tiene almacenada p y a qué tipo de datos apunta, en este caso la variable p, sabemos, ha sido definida como un puntero a un entero. A través del puntero podemos, además y es lo más importante, modificar el valor de la variable a la cual esté apuntando, esto se efectúa así: *p = 21; se leerá "al valor al que apunta p se le asigna 21", otra vez, para saber cual es el valor al que apunta p, debemos conocer la dirección que almacena, de esta forma en memoria las variables quedarán así: p entero ┌────┐ ┌─────────┐ │1500│ │ 2 │ 1 │ └────┘ └────┴────┘ 1500 1501 el 13 ha sido destruido al efectuarse la asignación *p = 21. 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; 15.3 PUNTERO A VARIABLE DE PUNTO FLOTANTE Los punteros pueden apuntar a variables de cualquier tipo; en el siguiente ejemplo un puntero, pf, apuntarará a una variable, real, de punto flotante, como sabemos este última tipo de variables ocupan 4 bytes en memoria, la sintaxis de la declaración será: float *pf, real=4.67; pf real ┌────┐ ┌───────────────────┐ │ │ │ 4.67 │ └────┘ └────┴────┴────┴────┘ 2500 2501 2502 2503 2500 es la dirección base de la variable real, real ocupa 4 bytes en RAM, y estamos suponiendo que ocupará las direcciones 2500 a la 2503, estos cuatro bytes son el desplazamiento(offset) de la variable real. A continuación el puntero pf tomará la dirección de la variable real: pf = &real;

189

se lee esta instrucción así: "la dirección(&) de la variable real se asigna a la variable puntero pf"; en memoria nos no imaginaremos así: pf real ┌────┐ ┌───────────────────┐ │2500│ │ 4.67 │ └────┘ └────┴────┴────┴────┘ 2500 2501 2502 2503 Para mostrar el valor de la variable real por medio puntero pf, escribiremos la siguiente instrucción: cout << *pf; Mostrará el valor de 4.67 en pantalla; *pf debe ser leído como: "el valor al cual apunta pf", y para saber cual es el valor al cual apunta pf, debemos "saber" la dirección que tiene almacenada pf y a qué tipo de datos apunta, en este caso p sabemos ha sido definido como un puntero a un float. A través del puntero podemos modificar el valor de la variable a la cual esté apuntando: *pf = -23.56; se leerá "al valor al que apunta pf se le asigna -23.56", otra vez, para saber cual es el valor al que apunta pf, debemos conocer la dirección que almacena, de esta forma en memoria las variables quedarán así: pf real ┌────┐ ┌───────────────────┐ │2500│ │ -23.56 │ └────┘ └────┴────┴────┴────┘ 2500 2501 2502 2503 el 4.67 ha sido destruido al efectuarse la asignación *pf = -23.56. 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; 15.4 PUNTERO A UN VECTOR Supongamos tenemos la siguiente declaración de variables: int *pv, vector[5] = {17,2,-6,3,28}; 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, pv, tome la dirección base del vector se debe escribir la siguiente instrucción:

190

pv = vector; observe que no se coloca el operador de dirección &. 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. En este caso la variable vector tiene una dirección base de 500 y un desplazamiento de 2 bytes*5=10 bytes, desde la dirección 500 hasta 509. El anterior arreglo, vector, se puede recorrer con el puntero, según el siguiente fragmento: for(i=0; i<5; i++) cout << setw(4) << pv[i]; que nos mostrará en pantalla los valores: 17 2 -6 3 28. Es decir que el puntero, pv, se puede indexar de igual forma que se hace con los identificadores de los arreglos. Al ejecutar el fragmento anterior el valor en memoria de pv es de 500, es decir apunta todo el tiempo a la dirección base, el índice es el que "avanza" en el arreglo. Diferente será si queremos avanzar en el vector, cambiando la dirección del puntero, es decir que de 500 pase a 502, 504, 506, 508 las cuales son las posiciones base de cada uno de los elementos enteros del vector: vector[0], vector[1], vector[2], vector[3] y vector[4], esto se codificará así: pv = vector; while (*pv && i<5){ cout << setw(4) << *pv; pv++; i++; } En pantalla el efecto sería idéntico que en el caso anterior, aparecerán: 17 2 -6 3 28. En memoria sería muy diferente, la variable pv cada que se le "suma uno" se incrementará según el tipo de datos al que apunta, al ser un entero se desplazará en dos bytes, para entenderlo, veamos prueba de ejecución manual del anterior fragmento en el siguiente tabulado:

191

──────────────────────────────────────────────────────────────────── 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, después de esto, 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", mostrado como ???, y por esto mostraría, eventualmente, en pantalla, algo inesperado, si no se coloca la instrucción i<5 para que termine. 15.5 Esta es una demostración del manejo de un puntero a un número real. #include <iostream.h> #include <conio.h> //PUNTERO1.CPP void main(){ float N=5, *p; clrscr(); cout << "N = " << N; p = &N; cout << "\nA la variable p se le asignó el valor: " << p; cout << "\nN = " << *p; cout << "\nDigite un valor para la variable N: "; cin >> *p; cout << "\nN = " << N; cout <<"\n\nVariable N está en la dirección de memoria: " <<p; cout <<"\n\nVariable N está en la dirección de memoria: "<<&N; cout <<"\n\nPuntero p está en la dirección de memoria: " <<&p; getch(); }

192

15.6 Esta es una demostración del manejo de los punteros. #include <iostream.h> #include <conio.h> #include <stdio.h> //PUNTERO2.CPP main(){ int *pE, i, j, entero=234, vectorE[] = {3,45,23,67,9}, matrizE[][3] = {4, 7, 8, 9, 2, 0, 6, 2, 9}; char *pC = "Esta es una demostración\n\n", caracter = ' ', Cadena[] = {'C','a','l','i','\0'}, *Cad[] = {'\0'}, *Cadenas[] = {"Palmira ", "Valle ","Colombia" }; float *pR, real = 7.5, vectorR[] = {3.2, 4.5, -5.7, 0, 0.2}, matrizR[][3] = {4.3, 6.5, 7.8, 9.8, 1.2, 0.4, 6.4, 2.3, 9.6}; clrscr(); cout << "VARIABLE VALOR DIRECCION\n\n"; pE = &entero; cout << "entero \t" << *pE << "\t" << pE << "\n\n"; pE = vectorE; for (i=0; i<5; i++) { cout <<"\nvectorE[" << i << "]\t" << *pE << "\t" << pE; pE++; } cout <<"\n"; pE = (int *) matrizE; for (i=0; i<3; i++) for (j=0; j<3; j++){ cout <<"\nmatrizE[" <<i <<"][" <<j <<"]\t" <<*pE<<"\t" <<pE; pE++; } getch(); clrscr(); cout << "VARIABLE VALOR DIRECCION\n\n"; pR = &real; cout <<"real \t" << *pR << "\t" << pR << "\n\n"; pR = vectorR; for (i=0; i<5; i++) { cout <<"\nvectorR[" << i << "]\t" << *pR << "\t" << pR; pR++;

193

} cout << "\n"; pR = (float *) matrizR; for (i=0; i<3; i++) for (j=0; j<3; j++){ cout <<"\nmatrizR[" <<i <<"][" <<j <<"]\t" <<*pR <<"\t"<<pR; pR++; } getch(); clrscr(); cout <<"VARIABLE VALOR DIRECCION\n\n"; pC = &caracter; cout <<"caracter\t"<<*pC<<"\t"<<pC<<"\n\n";//No dá la dirección cout <<"Cadena \t" << Cadena <<"\t" << &Cadena << "\n\n"; *Cad = Cadena; cout <<"*Cad\t"<< *Cad<< "\t"<<Cad<<"\n\n";//No dá la dirección pC = Cadena; i=0; while (*pC) { cout<<"\nCadena["<<i<<"]\t"<<*pC <<"\t"<<pC;//No dá dirección pC++; i++; } cout <<"\n"; for (i=0; i<3; i++) cout<<"\n*Cadenas["<<i<<"]\t"<<Cadenas[i]<<"\t"<<&Cadenas[i]; getch(); return 0; }

194

15.7 El siguiente es un ejemplo en el cual un puntero "apunta" a un registro(struct). Ver el siguiente capítulo para la definición de este tipo de datos estructurado. //PUNTERO3.CPP #include <iostream.h> #include <stdio.h> typedef struct persona PERSONA; struct persona{ char nombre[20]; int edad; float alto; } main(){ PERSONA amigo, *p; p = &amigo; cout << "Nombre: "; gets(p->nombre); cout << "Edad: "; cin >> p->edad; cout << "Altura: "; cin >> p->alto; cout << p->nombre << " " << p->edad << " " << p->alto; } 15.8 El siguiente algoritmo presenta el intercambio del valor de dos variables en la memoria RAM del computador, por medio de una invocación de una función por referencia al estilo del C. //FUNCION8.CPP #include <iostream.h> #include <conio.h> IntercambioEnMemoria(int *a, int *b){ int *aux; //variable local *aux= *a; *a = *b; *b = *aux; } main(){ int a,b; clrscr(); cout << "Digite un real para almacenar en variable A: "; cin >> a; cout << "Digite un real para almacenar en variable B: "; cin >> b; IntercambioEnMemoria(&a, &b); cout <<"\nDespués de intercambiadas, A ahora es igual a "<<a; cout << "\ny la variable B ahora es igual a " << b; }

195

15.9 Ejemplo de paso de parámetro por referencia al nuevo estilo del C++. Convierte un número en base 10 a base binaria #include <iostream.h> #include <conio.h> //REFEREN2.CPP leer(int &N){ cout << "Digite: "; cin >> N; //observe que N al ser puntero se coloca sin & } CalcularBinario(int &N){ int c, r; c = N >> 1; // divide entre dos r = N % 2; cout << "\n" << r << " Leer de abajo hacia arriba"; while(c){ r = c % 2; c >>= 1; cout << "\n" << r; } } main(){ int decimal; leer(decimal); //invocación por referencia CalcularBinario(decimal); //invocación por valor } 15.10 El siguiente algoritmo presenta el intercambio del valor de dos variables en la memoria RAM del computador, por medio de una invocación de una función con parámetros por referencia. //FUNCION9.CPP #include <iostream.h> #include <conio.h> IntercambioEnMemoria(int &a, int &b){ //Esto daría error en C, y no en C++ int aux; //variable local aux = a; a = b; b = aux; } void main(){ int a,b; cout << "Digite un real para almacenar en variable A: "; cin >> a; cout << "Digite un real para almacenar en variable B: "; cin >> b; IntercambioEnMemoria(a, b); cout <<"\nAhora A = " <<a << " y B = " << b << " después del intercambio"; }

196

15.12 Este programa convierte un decimal a binario. //PUNTERO6.CPP #include <iostream.h> #include <conio.h> int leer(){ int N; clrscr(); cout << "Digite un entero para convertirlo a binario: "; cin >> N; return (N); } void CalcularBinario(int N, int *r){ int c; c = N >> 1; *r = N % 2; while(c){ r++; *r = c % 2; c >>= 1; } r++; *r = 2; //se utiliza el dos como terminador } void main(){ int b=0, j, decimal, binario[20]; decimal = leer(); CalcularBinario(decimal, binario); cout << "\n\nbinario = " ; while(binario[b]==1 || binario[b]==0) // busca el final de la cadena b++; for(j=b-1; j>=0; j--) // escribe el binario adecuadamente cout << binario[j]; }

197

15.13 El siguiente algoritmo en lenguaje C ordena alfabéticamente, en forma ascendente, cadena de caracteres. //PUNTERO7.CPP #include <iostream.h> #include <string.h> #include <conio.h> #include <stdio.h> void main(){ char *cadena, aux; int i, j; cout << "Digite una frase: "; gets(cadena); cout << "Longitud cadena = " << strlen(cadena) << "\n\n"; for(i=0; i<strlen(cadena); i++) for(j = i+1; j<strlen(cadena); j++) if(cadena[i] > cadena[j]){ aux = cadena[i]; cadena[i] = cadena[j]; cadena[j] = aux; } cout << "\"frase ordenada alfabéticamente\": \n" ; puts(cadena); } 15.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. Recuerde que un arreglo bidimensional es solamente un arreglo de arreglos. //MATRIZ10.CPP #include <iostream.h> #include <iomanip.h> #include <conio.h> const int MaxFila=5, MaxCol=4; void main(){ int Matriz[MaxFila][MaxCol], Fila, Col; clrscr(); for ( Fila = 0; Fila < MaxFila; Fila++){ for ( Col = 0; Col < MaxCol; Col++){ Matriz[Fila][Col]= Fila*Col+1; cout << setw(10) << Matriz[Fila][Col]; } cout << endl; } getch(); for ( Fila = 0; Fila < MaxFila; Fila++) { for ( Col = 0; Col < MaxCol; Col++) cout << setw(10) << *( *(Matriz+Fila) + Col) ; cout << endl; } }

198

15.15 Se digitan N números se almacenan en vector y luego se ordenan. Este programa no funciona si se le da a alguna posición del vector el valor de cero, debido a que la instrucción while lo evaluará como falso, terminando el ciclo repetitivo. El profesor efectuará taller de lectura con este algoritmo. //PUNTERO8.CPP #include <iostream.h> #include <conio.h> const int N=5; Leer(int *v){ int i=0; gotoxy(10,2); cout << "Digite " << N << " números"; while (i < N) { gotoxy(10,4+i); cin >> v[i]; i++; } } Ordenar(int *p){ int *q, aux; while(*p){ q = p+1; while(*q){ if (*p > *q){ aux = *p; *p = *q; *q = aux; } q++; } p++; } } Escribir(int *p){ cout <<"\n\tLos números ordenados son:\n\n"; while(*p){ cout.width(4); cout << *p; p++; } } void main(){ int vector[N]; Leer(vector); Ordenar(vector); Escribir(vector); }

199

15.16 Se digitan N números se almacenan en vector y luego se ordenan. //PUNTERO9.CPP #include <iostream.h> #include <conio.h> #define N 10 Leer(int *v){ int i=0, num; gotoxy(10,2); cout << "Digite " << " números"; while (i < N){ gotoxy(10,4+i); cin >> v[i++]; } } Ordenar(int *v){ int i,j,aux ; for (i = 0; i < N; i++) for (j = i+1; j < N; j++) if (v[i] > v[j]){ aux = v[j]; v[j]= v[i]; v[i] = aux; } } Escribir(int *v){ int i; cout << "\n\tLos números ordenados son:\n\n"; for (i = 0; i < N; i++){ cout.width(5); cout << v[i]; } } main(){ int numeros[N]; clrscr(); Leer(numeros); Ordenar(numeros); Escribir(numeros); while (!kbhit()); }

200

15.17 Programa de estadística básica //ESTADIST.CPP #include <iostream.h> #include <iomanip.h> #include <fstream.h> #include <graphics.h> #include <math.h> #include <conio.h> #include <ctype.h> #include <stdlib.h> const int MaxArreglo = 20; int intro_datos(float *datos) { int t, max; gotoxy(38,1); cout << "Digite número de ítems?: "; gotoxy(63,1); cin >> max; for(t=0; t<max; ++t) { gotoxy(40, 2+t); cout << "Introduzca Item " << t+1 << ": "; cin >> datos[t]; } gotoxy(40, 3+t); cout << "Cualquier tecla y seguir..." ; getch(); return max; } void marco(){ int indice; window(1,1,80,25); clrscr(); cout<<"╔═════════════════════════════════════════════════════════════════╗"; cout<<"║ EJEMPLO DE ESTADÍSTICA BÁSICA ║"; cout<<"╠═════════════════════════════════════════════════════════════════╣"; for(indice = 5; indice < 25; ++indice) cout<<"║ ║"; cout<<"╚═════════════════════════════════════════════════════════════════╝"; window(2,7,70,23); } char CaracterEstaEn(char ch, char *s){ while(*s) { if(ch == *s) return ch; else s++; } return 0; } float CalcularPromedio(float *datos, int N){ register int t; float med=0; for(t = 0; t < N; ++t) med += datos[t]; med /= N; return med; }

201

void Clasificar(float *datos, unsigned int N){ register int i,j; float aux; for (i = 0; i < N; i++) for (j = i; j < N; j++) if (datos[i] > datos[j]){ aux = datos[j]; datos[j]= datos[i]; datos[i] = aux; } } float CalcularMediana(float *datos, unsigned int N){ register int t; float temporal[MaxArreglo]; for (t=0; t<N; ++t) temporal[t] = datos[t]; /* copiar datos*/ Clasificar(temporal, N); return (temporal[(N-1)/2]); } float EncontrarModa(float *datos, int N){ register int t, w; float md, AnteriorModa; int cont, antcont; AnteriorModa=0; antcont=0; for (t=0; t< N; ++t) { md = datos[t]; cont = 1; for(w=t+1; w < N; ++w) if(md == datos[w]) cont++; if(cont > antcont) { AnteriorModa = md; antcont = cont; } } return AnteriorModa; } float BuscarMenor(float *datos, int N){ register int t; float minimo; for(minimo = datos[0], t=1; t < N; ++t) if(datos[t] < minimo) minimo = datos[t]; return minimo; } float BuscarMayor(float *datos, int N){ register int t;

202

float max; for(max = datos[0], t = 1; t < N; ++t) if(datos[t] > max) max = datos[t]; return max; } void mostrar(float *datos, int max){ register int t; float total=0, porcentajes[MaxArreglo]; for (t = 0; t < max; t++) total += datos[t]; for (t = 0; t < max; t++) porcentajes[t] = datos[t] / total; for(t = 0; t < max; ++t) { gotoxy(32,1+t); cout << setfill('.') << setw(2) << t+1 << setiosflags(ios::fixed) << setiosflags(ios::showpoint) << setiosflags(ios::right) << setprecision(2) << setw(10) << datos[t] << setw(10) << porcentajes[t]*100 << "%"; } gotoxy(35,4+t); cout <<"Cualquier tecla y seguir... "; getch(); } float DesviacionEstandard(float *datos, int max){ register int t; float DesvStd=0, Promedio; double aux; Promedio = CalcularPromedio(datos,max); for(t = 0; t < max; ++t) DesvStd += ((datos[t] - Promedio) * (datos[t] - Promedio)); if(max) DesvStd /= max; DesvStd = sqrt(DesvStd); return DesvStd; } void GraficarPorcentajes(float *datos, int max){ int ManejadorGrafico, ModoGrafico; int i, izquierda, arriba, ancho, abajo, profundidad; float total=0; float porcentajes[MaxArreglo]; if (max){ for (i = 0; i < max; i++) total += datos[i]; for (i = 0; i < max; i++) porcentajes[i] = ((float) datos[i]) / total; detectgraph(&ManejadorGrafico, &ModoGrafico); initgraph(&ManejadorGrafico, &ModoGrafico, "c:\\tc\\bgi"); ancho = (int)( (getmaxx()) / ((max * 2 ) + 1) ); abajo = getmaxy() - 10; profundidad = (int) (ancho / 4); izquierda = ancho;

203

setbkcolor(WHITE); for (i = 0; i < max; i++) { arriba=(abajo) - ((int)(porcentajes[i] * (getmaxy() - 25))); setcolor(RED); //color de las líneas de cada barra setfillstyle(i+1, i+1); bar3d(izquierda,arriba,(izquierda+ancho),abajo,profundidad,1); izquierda += (ancho * 2); } getch(); closegraph(); marco(); } } void Impresora(float *datos, int max){ register int t; float total=0, porcentajes[MaxArreglo]; ofstream Imprimir("PRN"); for (t = 0; t < max; t++) total += datos[t]; for (t = 0; t < max; t++) porcentajes[t] = datos[t] / total; gotoxy(35,4); cout <<"Imprimiendo... "; Imprimir<<"\n Registro Datos Porcentajes \n\n"; for(t = 0; t < max; ++t) { Imprimir << setfill('.') <<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; } Imprimir << "\f"; } void LeerArchivoYCargarEnDatos(float *datos, int &N){ int IDArchivo; fstream Archivo; N=0; Archivo.open("Estadist.ica", ios::in | ios::binary); if(Archivo){ while( Archivo.read( (char *)&datos[N], sizeof(float) ) ) N++; Archivo.close(); cout << "Leídos desde disco: " ; mostrar(datos, N); } else cout << "Archivo no existe"; } void GrabarDatosEnArchivo(float *datos, int N){ int i; fstream Archivo; Archivo.open("Estadist.ica", ios::out|ios::binary|ios::trunc);

//borra archivo si existe if (!Archivo)

204

cout << "Error en la apertura del archivo \a"; else{ for(i=0; i<N; i++) Archivo.write((char *)&datos[i], sizeof(float)); Archivo.close(); } } void Regresion(float *datos, int max){ clrscr(); cout << "TAREA: IMPLEMENTE ESTE MODULO. DIGITE TECLA "; getch(); } char OpcionMenu(){ char entrada; clrscr(); do { gotoxy( 3, 1); cout << "MENÚ PRINCIPAL"; gotoxy( 3, 2); cout << "=============="; gotoxy( 3, 3); cout << "Capturar datos"; gotoxy( 3, 4); cout << "Estadísticas básicas"; gotoxy( 3, 5); cout << "Ordenar de menor a mayor"; gotoxy( 3, 6); cout << "Mostrar datos"; gotoxy( 3, 7); cout << "Graficar en barras"; gotoxy( 3, 8); cout << "Imprimir en papel"; gotoxy( 3, 9); cout << "Terminar"; gotoxy( 3,13); cout<<"Elija letra inicial (C E O M G I T): "; gotoxy(39,13); entrada = toupper(getch()); } while (!CaracterEstaEn(entrada, "CEOMGIT")); return entrada; } void main(){ //ESTADÍSTICA BÁSICA FUNCIÓN PRINCIPAL float datos[MaxArreglo]; // almacena valores de la muestra int N=0; //Número verdadero de elementos float Promedio=0,Mediana=0,DesvStd=0, Varianza=0, Moda=0, Mayor=0, Menor=0; marco(); LeerArchivoYCargarEnDatos(datos, N); for(;;) { switch( OpcionMenu() ) { case 'C':N = intro_datos(datos); break; case 'E':Promedio = CalcularPromedio(datos, N); Mediana = CalcularMediana(datos, N); Moda = EncontrarModa(datos, N); Menor = BuscarMenor(datos, N); Mayor = BuscarMayor(datos, N); DesvStd = DesviacionEstandard(datos, N); Varianza = DesvStd*DesvStd; gotoxy(30, 1); cout << "Promedio : " << Promedio; gotoxy(30, 2); cout << "Mediana : " << Mediana; gotoxy(30, 3); cout << "Desviación Std : " << DesvStd; gotoxy(30, 4); cout << "Varianza : " << Varianza;

205

gotoxy(30, 5); cout << "Moda : " << Moda; gotoxy(30, 6); cout << "Máximo : " << Mayor; gotoxy(30, 7); cout << "Mínimo : " << Menor; gotoxy(30, 9); cout << "Cualquier tecla y seguir... "; getch(); break; case 'M':mostrar(datos, N); break; case 'O':Clasificar(datos, N); mostrar(datos, N); break; case 'G':GraficarPorcentajes(datos, N); break; case 'I':Impresora(datos, N); break; case 'T':GrabarDatosEnArchivo(datos, N); exit(0); } } }

207

CAPÍTULO 16. MMEENNÚÚ DDEE CCOONNMMUUTTAADDOORREESS EENN MMOODDOO GGRRÁÁFFIICCOO El siguiente programa es una demostración de un menú de conmutadores horizontales y de varias primitivas de dibujo en modo gráfico. El profesor en clase magistral explicará paso a paso la construcción de un programa como este. Adicionalmente compile y ejecute el programa de demostración de la Borland, BGIDEMO.C, el cual está en el directorio \tc\bgi, observe que tiene extensión *.C, es decir está escrito en lenguaje C, y no en C++. \\MENU_HV.CPP #include <graphics.h> #include <stdlib.h> #include <ctype.h> #include <bios.h> #include <conio.h> #include <dos.h> #include <stdio.h> //Definición de constantes globales: const DesActivo=0, Activo=1; //Definición de algunos prototipos de funciones: void CentrarXCad(int Fila, char *Cad); void RealzaCuadro(int x1,int y1,int x2,int y2,int color1,int color2); void ReCuadro(int X, int Y, char *Cad, int Color, int Oprimido); void PulsadoCuadro(int X,int Y,char *Cad,int Color); void Presentacion0(); void Presentación(); /************************************************************************/ /* 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, char *Cad) { int largo = textwidth(Cad); outtextxy((getmaxx() -largo)/2,Fila,Cad); } /*******************************************************************/ /* Función : RealzaCuadro */ /* Objetivo : Muestra un rectangulo en pantalla, el cual significa */ /* una de las opciones del menú */ /*******************************************************************/ void RealzaCuadro(int x1,int y1,int x2,int y2,int color1,int color2){ setcolor(color1); line(x1,y1,x2,y1); line(x1,y1,x1,y2); setcolor(color2); line(x1,y2,x2,y2); line(x2,y2,x2,y1); } /*************************************************************************/ /* Función : ReCuadro */ /* Objetivo : Realiza recuadro, con una cadena centrada en su interior, */ /* da a significar una de las opciones de un menú */ /*************************************************************************/ void ReCuadro(int X, int Y, char *Cad, int Color, int Oprimido) { register int AltoCuadro, LargoCuadro; char c[2]; settextstyle(DEFAULT_FONT, HORIZ_DIR, 1);

208

AltoCuadro = textheight("H") + 7; LargoCuadro = textwidth(Cad) + 7; setfillstyle(SOLID_FILL, Color); setcolor(DARKGRAY); bar3d(X, Y, X+LargoCuadro,Y+AltoCuadro, 4, 1); if (Oprimido) { setcolor(DARKGRAY); line(X+1, Y+1, X+1, Y+AltoCuadro-1); line(X+1, Y+1, X+LargoCuadro-1, Y+1); setcolor(WHITE); } else { setcolor(WHITE); line(X+1, Y+1, X+1, Y+AltoCuadro-1); line(X+1, Y+1, X+LargoCuadro-1, Y+1); setcolor(DARKGRAY); } line(X+LargoCuadro-1, Y+1, X+LargoCuadro-1, Y+AltoCuadro-1); line(X+1, Y+AltoCuadro-1, X+LargoCuadro-1, Y+AltoCuadro-1); outtextxy(X+5, Y+5, Cad); setcolor(RED); c[0] = Cad[0]; c[1] = '\0'; outtextxy(X+5,Y+5,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,int Y,char *Cad,int Color) { ReCuadro(X,Y,Cad,Color,DesActivo); delay(100); ReCuadro(X,Y,Cad,Color,Activo); delay(100); ReCuadro(X,Y,Cad,Color,DesActivo); } /*************************************************************************/ /* Función : Presentación */ /* Objetivo : presentar el nombre de la función y logo del estudiante */ /*************************************************************************/ void PresentacionSubMenu(char *SubtituloMenu) { clearviewport(); setcolor(MAGENTA); rectangle(0,0, getmaxx(), getmaxy()); RealzaCuadro(10,10,520,437,DARKGRAY,WHITE); RealzaCuadro(20,20,510,430,WHITE,DARKGRAY); setcolor(YELLOW); settextstyle(TRIPLEX_FONT, HORIZ_DIR,5); outtextxy(100,50, "PROYECTO"); settextstyle(TRIPLEX_FONT, HORIZ_DIR,4); setcolor(14); outtextxy(100, 140, "SUBMENÚ"); setcolor(13); outtextxy(100, 250, SubtituloMenu); settextstyle(DEFAULT_FONT, HORIZ_DIR, 1); } /************************************************************************* */ /* Función : subMenu */ /* Objetivo : Implementar menú para el manejo de funciones en la lista. */ /************************************************************************* */ void SubMenu(char *SubtituloMenu) { const int Arb =72, Abj =80, Entrar =13, MaxOp=8; int i, Col=550, c, pos = 0, Invocar=1, Yo=20, DeltaY=25;; char *Opcion[MaxOp] = { "Listar ",

209

"Capturar ", "Eliminar ", "Imprimir ", "Buscar ", "Graficar ", "Recursión", "Salir " }; for(;;) { if(Invocar){ PresentacionSubMenu(SubtituloMenu); Invocar=0; for(i=0; i<MaxOp; i++) { ReCuadro(Col, Yo+DeltaY*i, Opcion[i], LIGHTGRAY, DesActivo); } ReCuadro(Col, Yo+DeltaY*pos, Opcion[pos], LIGHTGRAY, Activo); } c = getch(); while (c==0) { c = getch(); switch (c) { case Abj: ReCuadro(Col,Yo+DeltaY*pos,Opcion[pos],LIGHTGRAY,DesActivo); pos++; if(pos==MaxOp) pos=0; ReCuadro(Col,Yo+DeltaY*pos,Opcion[pos],LIGHTGRAY,Activo); break; case Arb: ReCuadro(Col,Yo+DeltaY*pos,Opcion[pos],LIGHTGRAY,DesActivo); pos--; if(pos== -1) pos= MaxOp -1; ReCuadro(Col,Yo+DeltaY*pos,Opcion[pos],LIGHTGRAY,Activo); break; case 45: exit(0);//Alt-X case 59: break;// F1 } c = getch(); } if (c==27) return; if( isalpha(c) ){//Se digitó letra inicial? c=toupper(c); i=0; while( c!=Opcion[i][0] && i<MaxOp) i++; if(i<MaxOp){// Se digitó letra inicial de opción pos = i; Invocar=1; } } else if (c==Entrar) Invocar=1; else Invocar = 0; if(Invocar){ PulsadoCuadro(Col,Yo+DeltaY*pos,Opcion[pos],LIGHTGRAY); switch(pos) { case 0 : break; case 1 : break; case 2 : break; case 3 : break;

210

case 4 : break; case 5 : break; case 6 : break; case 7 : return; } } } } void PresentacionMain() { clearviewport(); setcolor(DARKGRAY); rectangle(0,0, getmaxx(), getmaxy()); RealzaCuadro(10,40,620,470,DARKGRAY,WHITE); RealzaCuadro(20,50,610,460,WHITE,DARKGRAY); settextstyle(DEFAULT_FONT, HORIZ_DIR,6); setcolor(LIGHTRED); CentrarXCad(60, "C.U.A.O"); setcolor(YELLOW); CentrarXCad(100, "Plantilla Proyecto"); settextstyle(DEFAULT_FONT, HORIZ_DIR,3); setcolor(WHITE); CentrarXCad(200, "Graficación en Lenguaje C"); setcolor(WHITE); CentrarXCad(300, "Profesor"); setcolor(GREEN); CentrarXCad(350, "Humberto Mazuera Párraga"); } /************************************************************************ */ /* Función : Principal */ /* Objetivo :Menú para el manejo de funciones. */ /************************************************************************ */ void main() { const Der =77, Izq =75, Entrar =13, MaxOp =5; int i, fila =10, c, pos = 0, Invocar=1, Ancho=0, Margen=14; char *Opcion[MaxOp]={"Películas","Usuarios","Alquiler","Balance" ,"Salir"}; int PosX[MaxOp]; int Manejador=DETECT, modo; initgraph(&Manejador, &modo, "c:\\tc\\bgi"); for(i=0; i<MaxOp; i++) Ancho= Ancho+textwidth(Opcion[i])+Margen; PosX[0]= (getmaxx()-Ancho)/2; for(i=1; i<MaxOp; i++) PosX[i]= PosX[i-1]+textwidth(Opcion[i-1])+Margen; for(;;) { if (Invocar){ PresentacionMain(); for(i=0; i<MaxOp; i++) { ReCuadro(PosX[i],fila,Opcion[i],LIGHTGRAY,DesActivo); } ReCuadro(PosX[pos],fila,Opcion[pos],LIGHTGRAY,Activo); Invocar = 0; } c = getch(); while (c==0) { c = getch(); switch (c) { case Der: ReCuadro(PosX[pos],fila,Opcion[pos],LIGHTGRAY,DesActivo); pos++;

211

if(pos==MaxOp) pos=0; ReCuadro(PosX[pos],fila,Opcion[pos],LIGHTGRAY,Activo); break; case Izq: ReCuadro(PosX[pos],fila,Opcion[pos],LIGHTGRAY,DesActivo); pos--; if(pos== -1) pos= MaxOp -1; ReCuadro(PosX[pos],fila,Opcion[pos],LIGHTGRAY,Activo); break; case 45: exit(0);//Alt-X case 59: break;// F1 } c = getch(); }//while if (c==27) return; if (c== Entrar) Invocar = 1; else if( isalpha(c) ){//Se digitó letra inicial? c=toupper(c); i=0; while( c!=Opcion[i][0] && i<MaxOp) i++; if(i<MaxOp){// Se digitó letra inicial de opción pos = i; Invocar=1; } } if(Invocar){ PulsadoCuadro(PosX[pos],fila,Opcion[pos],LIGHTGRAY); switch(pos) { case 0 : SubMenu("Películas"); break; case 1 : SubMenu("Usuarios"); break; case 2 : SubMenu("Alquiler"); break; case 3 : SubMenu("Balance"); break; case 4 : closegraph(); return; } } } }

213

CCAAPPÍÍTTUULLOO 1177.. EESSTTRRUUCCTTUURRAA DDEE DDAATTOOSS RREEGGIISSTTRROO 17.1 ESTRUCTURA DE DATOS REGISTROS(STRUCT) En C/C++ un registro se representa por medio de el identificador struct. 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, y que pueden ser declarados en forma global o local. La sintaxis general de este tipo de datos cumple con el siguiente formato: struct NombreDeRegistro{ TipoDeDatos NombreCampo1; TipoDeDatos NombreCampo2; ...; TipoDeDatos NombreCampoN; }; o también: struct NombreDeRegistro{ TipoDeDatos NombreCampo1; TipoDeDatos NombreCampo2; ...; TipoDeDatos NombreCampoN; } NombreVariable1, NombreVariable2, ..., NombreVariableN; En la primera forma presentada, se debe tener mucho cuidado en no omitir el punto y coma como terminador; en caso de omitirlo se presentan una serie de errores, que el recién iniciado, es probable, atribuirá a otras cosas. En cualquiera de las dos formas, se podrán definir variables, posteriormente en el programa, según la siguiente sintaxis: struct NombreDeRegistro NombreVariable1, NombreVariable2, ..., NombreVariableN; Los tipos de datos de cada uno de los campos pueden ser de cualquiera de los tipos primitivos o estructurados, incluyéndose al mismo tipo struct. En los casos en que se pretendan definir todas las variables de tipo, struct, en la misma instrucción, se puede omitir el nombre de el registro, utilizando el siguiente formato: struct { TipoDeDatos NombreCampo1; TipoDeDatos NombreCampo2; ...; TipoDeDatos NombreCampoN; } NombreVariable1, NombreVariable2, ..., NombreVariableN; quedará claro que posteriormente no se podrán definir variables de este mismo tipo.

214

Ejemplos de definición de tipos de datos "estructura" son los siguientes: struct Punto{ struct Nacion{ struct Registro{ int X, char Nombre[20]; char Nombre[Max]; Y, char Capital[25]; int edad; Color, float KilómetrosCuadrados; float salario; Atributo; float Población; } Vector[N]; } MiPuntico; char Lenguaje[15]; } Pais; La utilización de cada uno de los miembros dentro de las estructuras anteriores se efectuará de las siguientes y respectivas formas: MiPuntico.X, MiPuntico.y, MiPuntico.Color, MiPuntico.Atributo. Pais.Nombre, Pais.Capital, Pais.KilometrosCuadrados, Pais.Poblacion, Pais.Lenguaje. Vector[0].nombre, Vector[0].edad, Vector[1].salario Vector[1].nombre, Vector[1].edad, Vector[1].salario ... Vector[N-1].nombre, Vector[N-1].edad, Vector[N-1].salario Las expresiones anteriores se utilizarán como cualquier otro identificador de variable de las vistas hasta ahora, referente a las operaciones de lectura, escritura, asignación y formar parte de expresiones al lado derecho de asignaciones, como pueden observar en los programas que se muestran a continuación en este y siguientes capítulos. En la memoria RAM, las anteriores definiciones de variables debemos abstraerlas de la siguiente forma: VARIABLE MiPuntico:

¡Error! Marcador no definido. X

Y Color Atributo

VARIABLE Pais:

¡Error! Marcador no definido. Nombre

Capital KilometrosCuadrados Poblacion Lenguaje

VARIABLE: Vector: Vector[0] Vector[1] Vector[...] Vector[N-1]

¡Error! Marcador no definido.Vector[0].nombre

Vector[1].nombre Vector[...].nombre Vector[N-1].nombre

Vector[0].edad Vector[1].edad Vector[...].edad Vector[N-1].edad

Vector[0].salario Vector[1].salario Vector[...].salario Vector[N-1].salario

En las anteriores tablas se muestra el nombre de cada campo correspondiente a las tres variables, se sobreentiende que en su lugar irán datos en la memoria RAM.

215

17.2 Se utiliza la estructura de datos incorporada registro del C: struct. Se efectúa ejemplo de lectura y escritura de un registro. #include <iostream.h> //STRUCT0.CPP main(){ const int Max=20; struct registro { char nombre[Max]; int edad; float salario; } amigo; cout << "Digite su nombre: "; cin >> amigo.nombre; cout << "Digite su edad: "; cin >> amigo.edad; cout << "Digite su salario: "; cin >> amigo.salario; cout << "\n\nNombre: " << amigo.nombre << "\nSalario: $ " << amigo.salario << "\nedad: " << amigo.edad << " años"; } 17.3 Se utiliza la estructura de datos incorporada registro del C: struct. Se muestra ejemplo de utilización de vector de registros. #include <iostream.h> #include <conio.h> const int Max=20; //STRUCT1.CPP struct registro { char nombre[20]; int edad; float salario; } amigos[Max]; main(){ int num_reg = 0, i; cout <<"Cuántos amigos desea introducir? (máximo " <<Max <<") "; cin >> num_reg; for (i=0;i<num_reg;++i) { cout << "Registro : " << i << "\n"; cout << " Salario: "; cin >> amigos[i].salario; cout << " Nombre : "; cin >> amigos[i].nombre; cout << " Edad : "; cin >> amigos[i].edad; } clrscr(); cout << "-----------------------------------------------------\n"; for (i=0; i<num_reg; ++i) cout << i+1 << " " << amigos[i].nombre << " " << amigos[i].edad << " " << amigos[i].salario << endl; cout << "-----------------------------------------------------\n"; }

216

¡¡EErrrroorr!! MMaarrccaaddoorr nnoo ddeeffiinniiddoo..CCAAPPÍÍTTUULLOO 1188.. EESSTTRRUUCCTTUURRAA DDEE DDAATTOOSS AARRCCHHIIVVOO 18.1 ARCHIVOS Y REGISTROS Un archivo o fichero es una estructura de datos que reside en memoria auxiliar, por ejemplo en disco duro, consistente en un conjunto de información estructurada en unidades de acceso denominadas registros, todas del mismo tipo y en número limitado solo por la capacidad del medio de almacenamiento. Un registro lógico, artículo o simplemente registro es cada una de las componentes del archivo. Cada uno de estos registros está constituido por uno o más elementos denominados campos o miembros, que pueden ser de diferentes tipos, según ya vimos, en la sección anterior de este capítulo. Si un archivo contiene la información de un conjunto de individuos u objetos, sus registros contienen la información de cada uno de ellos, individuo u objeto, y los campos los diferentes datos que componen a cada registro. Por ejemplo, en el archivo de personal de una Empresa, cada registro contiene la información de un empleado y los campos contienen su número de cédula, nombre, dirección, fecha de ingreso, etc. El nombre será un campo y el campo clave puede ser el número de Cédula. Las principales características que diferencian esta estructura de datos de las restantes son las siguientes: - Residencia en soportes de información externos, también denominados

memorias secundarias o auxiliares, como son las cintas y discos. Para hacer desaparecer un archivo será necesario realizar explícitamente una operación de borrado.

- Independencia respecto de los programas. Significa que la vida del archivo

no está limitada por la vida del programa que lo creó, y también que en diferentes momentos pueden utilizar el mismo archivo diferentes programas.

- Gran capacidad de almacenamiento, dependiendo solo del tamaño del disco. En C++ para abrir un archivo, se debe enlazar con un flujo(stream). Habiendo tres clases de flujos: de entrada, de salida y de entrada/salida. Para abrir un flujo de entrada utilizaremos, del archivo a incluir fstream.h, la clase ifstream. Para uno de salida está la clase ofstream, y para uno de entrada/salida se declarara una variable de la clase fstream. Por ejemplo las siguientes serían declaraciones válidas para flujos(stream): #include <FStream.H> ifstream LecturaArchivo; //Define un buffer para operaciones de entrada (in) ofstream EscrituraArchivo; //Define un buffer para operaciones de salida (out) fstream LectoEscrituraArchivo; //Define un buffer para operaciones de entrada/salida (in/out) A continuación de ser declarada una variable que maneja un flujo, este debe asociarse con un archivo físico (recuerde las reglas de nombres de archivo del DOS), por ejemplo con la función open(), la cual es miembro de cada una de las tres clases señaladas antes en el párrafo anterior. Recordar que todo archivo para su correcto procesamiento, debe inicialmente ser abierto. Adicionalmente la función open(), en caso de no existir el archivo con el cual se está asociando, ella lo creará, no siendo necesario crearlo expresamente, como ocurre con otras familias de funciones del C o de otros lenguajes.

217

Al efectuarse la apertura del archivo, internamente el C++, maneja dos apuntadores al inicio del archivo, es decir al primer registro de el mismo, uno de ellos para operaciones de lectura y otro para operaciones de escritura, sobre esto de los punteros consultar la bibliografía o consultar con el profesor si cree necesario. Por ejemplo los tres flujos definidos antes por medio de sendas variables, pueden ser abiertos de la siguiente forma: LecturaArchivo.open("c:\directorio\NombreAr.Ext", ios::binary); EscrituraArchivo.open("ASCII.COD"); LectoEscrituraArchivo.open(NombreArchivo, ios::binary|ios::trunc); En el primer ejemplo se abre un archivo físico llamado NombreAr.Ext el cual está en la trayectoria c:\directorio\ del disco duro C:, para solo lectura. A

continuación se puede proceder a efectuar operaciones de lectura con las instrucciones adecuadas. Este archivo, NombreAr.Ext, debe tener formato binario para poder ser realizada la operación con satisfacción. El formato binario no puede ser leído fácilmente desde cualquier programa de editor, pero tiene la ventaja de que es más compacto que el de texto. El operador :: es llamado el

operador de resolución de ámbito, y en este caso permite definir los diferentes modos que nos son posibles para la apertura de un archivo, este operador es

propio de la programación orientada a objetos. En el segundo ejemplo se abre un archivo para solo escritura, por medio del flujo EscrituraArchivo. El archivo se llama ASCII.COD y será grabado en la trayectoria actual del disco actual, en formato de tipo texto, por defecto, este tipo de archivos puede ser leído con facilidad por cualquier editor o procesador de texto. Finalmente, el tercer ejemplo, abre un archivo para lectura y escritura, cuyo nombre, pudiendo incluir trayectoria, está almacenado en la variable de cadena NombreArchivo. El archivo será de formato binario. El valor de modo trunc hará que si existe el archivo con anterioridad, será irremediablemente "borrado", 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, la cual lo pueda borrar en parte o totalmente. Para efectos prácticos del usuario, digamos que trunc produce el borrado del correspondiente archivo físico al cual está asociado el flujo. A continuación y dependiendo si es un archivo de texto o binario se realizarán las operaciones de lectura y escritura correspondientes, esto se explica en las dos siguientes secciones. Para finalizar, todo archivo que ha sido abierto, debe ser cerrado por disciplina del programador, según los siguientes ejemplos de los flujos que venimos estudiando: LecturaArchivo.close(); //Cierra el archivo NombreAr.Ext EscrituraArchivo.close(); //Cierra el archivo ASCII.COD LectoEscrituraArchivo.close(); //Cierra el archivo cuyo nombre esta en la variable NombreArchivo Las explicaciones anteriores, están sobre-simplificadas, empero son suficientes para el presente curso; para un mayor aprovechamiento de la potencia del manejo de la biblioteca de E/S del C++, referirse a la bibliografía.

218

18.2 ARCHIVOS DE DATOS DE TEXTO Para este tipo de archivos utilizaremos los operadores de extracción, >>, y de inserción, <<, ya vistos desde los dos primeros capítulos, y de forma enteramente similar a como se utilizan con cin >> y con cout <<. Veamos a continuación algunos ejemplos:

219

18.3 El siguiente programa graba en disco en el archivo MiArch.ivo, en formato de texto, el valor de varias variables de diversos tipos de datos. //ARCTXT_O.CPP #include <iostream.h> #include <fstream.h> void main(){ int n=13; float X= 123.45e-23; char c = ' ', cadena[15]={"LENGUAJE C++"}; ofstream Escribir; Escribir.open("MiArch.ivo"); Escribir << "Entero= " << n << "\nReal= " << X << "\nCaracter= " << c << "\nCadena= " << cadena; Escribir.close(); cout << "Se grabó en disco el siguiente mensaje: \n\n"; cout << "Entero= " << n << "\nReal= " << X << "\nCaracter= " << c << "\nCadena= " << cadena; cin.get(); } 18.4 El siguiente programa lee de disco, en formato de texto, el valor de varias variables. //ARCTXT_I.CPP #include <iostream.h> #include <fstream.h> void main(){ int n; float X; char c, cadena[15]; ifstream Leer; Leer.open("MiArch.ivo"); Leer >> n; Leer >> X; Leer >> c; Leer >> cadena; Leer.close(); cout << "Se leyó del disco el valor de las variables, así: \n\n"; cout << "Entero= " << n << "\nReal= " << X << "\nCaracter= " << c << "\nCadena= " << cadena; //Observe que la lectura de la cadena quedó truncada en el espacio //en blanco anterior a C++, omitiéndola. cin.get(); }

220

18.5 Este programa escribe el código ASCII en un archivo de texto en disco y simultáneamente lo presenta en pantalla. El archivo producido ASCII.CPP, es el utilizado en este manual para mostrar la tabla del código ASCII en el Apéndice al final de este manual, y en el primer capítulo. //ARCASCII.CPP #include <iostream.h> #include <iomanip.h> #include <fstream.h> #include <conio.h> void main(void){ ofstream archivo; //Define un buffer para operaciones de salida (out) int ascii; archivo.open("ASCII.COD", ios::out | ios::trunc); clrscr(); for (ascii = 32; ascii < 256; ascii++){ archivo << setw(3) << ascii << " " << (char) ascii << " "; cout << setw(3) << ascii << " " << (char)ascii << " "; if(ascii % 10 == 1){ archivo << "\n\n"; cout << endl; } } archivo.close(); // cierra el archivo } 18.6 ARCHIVOS DE DATOS BINARIO De entre las varias posibilidades que tiene el C/C++ para manejo de archivo binarios, utilizaremos, para este curso, las funciones miembro read() y write(). Estas funciones permiten leer y escribir, respectivamente, bloques de datos binarios. La sintaxis, simplificada, con la que trabajaremos es la siguiente y suponiendo que Archivo es una variable válida definida como un flujo: ARCHIVO.read( (char *)&VariableALeer, sizeof(VariableALeer) ); ARCHIVO.write( (char *)&VariableAEscribir, sizeof(VariableAEscribir) ); En el primer ejemplo se efectuará lectura, vía buffer, del archivo al cual esté asociado la variable ARCHIVO, de un la cantidad de bytes especificados por el operador sizeof, y colocándose o mejor asignando, lo leído a la variable VariableALeer. La anterior asignación se efectúa byte tras byte a la dirección(&) de la variable VariableAEscribir, debido al reforzador de tipo de puntero a caracter: (char*); este reforzador es obligatorio colocarlo para un correcto funcionamiento. En el segundo se efectuará escritura, vía buffer, de lo contenido en la dirección(&) de la variable VariableAEscribir, y en una cantidad de bytes especificados por el operador sizeof, es decir el tamaño de la variable en RAM. La anterior escritura se efectúa byte tras byte, siendo obligatorio colocar el reforzador de tipo de puntero a caracter: (char*).

221

18.7 En siguiente programa le servirá de plantilla para realizar su proyecto final. Estudie este programa VECTORST.CPP en todos sus detalles, el profesor en clase magistral y en el laboratorio de computadores explicará lo más relevante, observe que incluye gran mayoría del tema estudiado en todo el curso. Este programa maneja registros, struct, en un vector, en memoria RAM. Es el programa que deberá utilizar como plantilla para poder desarrollar su proyecto final. Estudie en detalle cada uno de los algoritmos presentados. //VECTORST.CPP #include <IOStream.h> #include <IOManip.h> #include <FStream.h> #include <ConIO.h> #include <StdIO.h>

#include <ProceS.h> #include <String.h> #include <DOS.h> #include <CType.h> #include <Graphics.h> const int Completo=25; const int Max=100; const char *NombreArchivo = "AMIGO.PER"; typedef struct PERSONA PERSONA; struct PERSONA{ char Nombre[Completo]; //Nombre y apellido int Edad; //años float Alto; //metros struct time Hora; struct date Dia; } Amigo[Max]; int NumReg=0; //Contador para el número de registros void Captura(){ if(NumReg < Max){ cout <<"\n\nReg: " << NumReg; getdate(&Amigo[NumReg].Dia); cout << " Dia: " << (int) Amigo[NumReg].Dia.da_day << " Mes: " << (int) Amigo[NumReg].Dia.da_mon << " Año: " << Amigo[NumReg].Dia.da_year; gettime(&Amigo[NumReg].Hora); cout << " HORA: " << (int) Amigo[NumReg].Hora.ti_hour << ":" << (int) Amigo[NumReg].Hora.ti_min << ":" << (int) Amigo[NumReg].Hora.ti_sec << endl; cout <<"Nombre: "; gets(Amigo[NumReg].Nombre); cout <<"Edad: "; cin >> Amigo[NumReg].Edad; cout <<"Estatura(metros): "; cin >> Amigo[NumReg].Alto; NumReg++; } else cout << "Vector de registros está lleno\a\a"; }

222

void ListarVector(){ clrscr(); if(NumReg){ cout <<"Registro Nombre Edad estatura\n"; for(int i=0; i < NumReg; i++){ cout << setiosflags(ios::right) << setw(8) << i << " " << setiosflags(ios::left) << setw(Completo) << Amigo[i].Nombre << setiosflags(ios::right) << setw(3) << Amigo[i].Edad << setiosflags(ios::right | ios::showpoint | ios::fixed) << setprecision(2) << setw(15) << Amigo[i].Alto << endl; } } } void OrdenarRegistros(){ register int i, j; PERSONA aux; if(NumReg){ for (i = 0; i < NumReg-1; i++) for (j = i+1; j < NumReg; j++) if (Amigo[i].Edad > Amigo[j].Edad){ aux = Amigo[i]; Amigo[i] = Amigo[j]; Amigo[j] = aux; } } else cout << "No hay registros en memoria \a\a"; } void EliminarRegistro(){ char Clave[Completo]=""; int i, pos; if(NumReg){ cout <<"\nDigite Nombre de Amigo a BORRAR: "; gets(Clave); pos = 0; while(pos<NumReg && strcmp(Amigo[pos].Nombre,Clave) != 0) pos++; if (pos==NumReg){ cout << "Clave no encontrada"; delay(1000); } else { for( ; pos<NumReg-1; pos++) Amigo[pos] = Amigo[pos+1]; NumReg--; } } else cout << "No hay registros en memoria"; }

223

void EncontrarRegistro() { char Clave[Completo]=""; int i=0; if(NumReg){ cout <<"\nDigite Nombre de Amigo a encontrar: "; gets(Clave); while( i<NumReg && strcmp(Clave,Amigo[i].Nombre) ) i++; if (i<NumReg){ cout <<"\n\nRegistro Nombre Edad estatura\n"; cout << setiosflags(ios::right) << setw(6) << i << " " << setiosflags(ios::left) << setw(Completo) << Amigo[i].Nombre << setiosflags(ios::right) << setw(2) << Amigo[i].Edad << setiosflags(ios::right | ios::showpoint | ios::fixed) << setprecision(2) << setw(7) << Amigo[i].Alto << endl; } else cout <<"\n\n NO Encontrado \a"; } else cout << "No hay registros en memoria"; getch(); } void ModificarRegistro(){ int registro;; if (!NumReg){ cout <<"\n\nNo existen registros en memoria \a"; delay(1000); } else { cout <<"\nDigite número de registro a modificar: "; cin >> registro; if( registro >= 0 && registro < NumReg) { cout <<"\nDigite nueva información para Registro: " << registro; cout <<"\nNombre: "; gets(Amigo[registro].Nombre); cout <<"Edad: "; cin >> Amigo[registro].Edad; cout <<"Estatura(metros): "; cin >> Amigo[registro].Alto; } } } void LeerArchivoYCargarEnVector(){ fstream Archivo; clrscr(); Archivo.open(NombreArchivo,ios::in|ios::binary); if(Archivo){ NumReg=0; while( Archivo.read( (char *)&Amigo[NumReg], sizeof(Amigo[NumReg]) ) ) NumReg++; Archivo.close(); } else cout << "No se pudo abrir el archivo"; }

224

void GrabarVectorEnArchivo(){ fstream Archivo; Archivo.open(NombreArchivo, ios::out|ios::binary|ios::trunc); if (!Archivo) cout << "Error en la apertura del archivo \a"; else{ for(int i=0; i<NumReg; i++) Archivo.write((char *)&Amigo[i], sizeof(Amigo[i])); Archivo.close(); } } //A continuación algunas macros que le servirán para cambiar el tipo de letra en impresora Epson de matriz //de punto. Consulte el manual de su impresora en otros casos. #define Condensado(f) f<<(char)15; #define CancelaCondensado(f) f<<(char)0x12; #define DobleAlto(f) f<<(char)27<<(char)0x77<<(char)1; #define CancelaDobleAlto(f) f<<(char)27<<(char)0x77<<(char)0; #define DobleAncho(f) f<<(char)27<<(char)0x57<<(char)1; #define CancelaDobleAncho(f) f<<(char)27<<(char)0x57<<(char)0; #define EspacioEntreLineas1_8pulgadas(f) f<<(char)27<<(char)0x30<<(char)0; #define EspacioEntreLineas7_72pulgadas(f) f<<(char)27<<(char)0x31<<(char)1; #define EspacioEntreLineas1_6pulgadas(f) f<<(char)27<<(char)0x32<<(char)2; #define CPI10(f) f<<(char)0x27<<(char)0x50; #define CPI12(f) f<<(char)0x27<<(char)0x4d; #define SaltaPagina(f) f<<"\f"; void ImprimirEnPapelRegistros(){ int Linea=0; PERSONA registro; fstream Impresora; if(NumReg==0) cout << "No hay registros en memoria \a\a"; else{ Impresora.open("LPT1", ios::out); // LPT1 es igual a PRN cout << "\n\nIMPRIMIENDO..."; DobleAncho(Impresora) Impresora <<"\n\nRegistro Nombre Edad Estatura\n\n"; CancelaDobleAncho(Impresora) Condensado(Impresora) for(int i=0; i<NumReg; i++){ Impresora << setiosflags(ios::right) << setw(20) << ++Linea << " " << setiosflags(ios::left) << setw(25) << Amigo[i].Nombre << setiosflags(ios::right) << setw(15) << Amigo[i].Edad << setiosflags(ios::right | ios::showpoint | ios::fixed) << setprecision(2) << setw(25) << Amigo[i].Alto << endl; } CancelaCondensado(Impresora) SaltaPagina(Impresora); Impresora.close(); } }

225

void Graficarbarras(){ int ManejadorGrafico = DETECT, ModoGrafico; int izquierda, arriba=20, arribabar, ancho, abajo, profundidad, eje=10; float fraccion, MayorEdad=0, Delta; initgraph( &ManejadorGrafico, &ModoGrafico, "c:\\tc\\bgi" ); setbkcolor(BLUE); setcolor(YELLOW); rectangle(0, 0, getmaxx(), getmaxy()); if( NumReg ){ MayorEdad=Amigo[0].Edad; for(int i=1; i<NumReg; i++) if(Amigo[i].Edad>MayorEdad) MayorEdad = Amigo[i].Edad; ancho = (int)( (getmaxx()-eje) / ((NumReg * 2 ) + 1) ); abajo = getmaxy() - 30; profundidad = (int)(ancho / 8); izquierda = ancho+eje; setcolor(YELLOW); settextstyle(DEFAULT_FONT, HORIZ_DIR, 2); outtextxy(5, abajo+10 , "EDADES"); Delta= (float)(abajo-arriba+1)/MayorEdad; line(eje/2, arriba, eje/2, abajo); //eje y for(float rayita=abajo; rayita>=arriba-Delta; rayita-=Delta) line(3, (int)rayita, 7, (int)rayita); for( i=0; i<NumReg; i++){ fraccion = (float) Amigo[i].Edad / MayorEdad; arribabar = (int)(abajo - fraccion * (abajo-arriba) ); setcolor(RED); setfillstyle(SOLID_FILL, MAGENTA); bar3d(izquierda,arribabar,(izquierda+ancho), abajo, profundidad, 1); setcolor(CYAN); settextstyle(SMALL_FONT,HORIZ_DIR, 0);//(tipo letra, direccion, tamaño ) outtextxy(izquierda+ancho/3, arribabar, Amigo[i].Nombre); izquierda += (ancho * 2); } } else{ setcolor(RED); settextstyle(TRIPLEX_FONT, VERT_DIR, 7); outtextxy(getmaxx()/2-10, 10, "NO HAY DATOS"); } getch(); closegraph(); }

226

void main(){ LeerArchivoYCargarEnVector(); for(;;) { ListarVector(); cout <<"\n\nCaptura Imprimir Ordenar eNcontrar Eliminar Modificar Graficas Borrar Salir: "; switch ( toupper( getch() ) ){ case 'C': Captura(); break; case 'I': ImprimirEnPapelRegistros(); break; case 'O': OrdenarRegistros(); break; case 'N': EncontrarRegistro(); break; case 'E': EliminarRegistro(); break; case 'M': ModificarRegistro(); break; case 'G': Graficarbarras(); break; case 'B': unlink(NombreArchivo); NumReg=0; break; case 'S': GrabarVectorEnArchivo(); return; } } } // main()

227

18.8 ACTIVIDADES PARA RESOLVER POR GRUPOS COMO PROYECTO FINAL. 18.8.1 El proyecto debe, para todos los grupos, incluir al menos lo siguiente: - Rehacer enunciado entregado de forma resumida y clara. - Presentar pulcramente el sangrado de todo el código fuente. - Dejar separación adecuada entre funciones, y colocarle a cada una de ellas su

objetivo. - Presentar logotipo adecuado al tema escogido. - Utilizar menú de conmutadores horizontal en el principal y verticales en los

submenús. - los identificadores que utilice, defínalos autodocumentados, en ningún

momento en clave o abreviaturas que no se entiendan rápidamente. - Utilizar operaciones de archivo tanto de lectura como de escritura, con los

registros con los que se trabaje. - No utilizar la librería string.h, en vez de ella construir una librería que

incluya las funciones para manejo de cadenas necesarias. - Presentar niveles de ayuda con la tecla F1 en varias partes del programa,

donde crea necesario. - Presentar estadísticas adecuadas con la ayuda del programa estadist.cpp. - Utilizar en algunas funciones paso de parámetros por valor y por referencia. - Presentar la información adecuadamente tabulada en pantalla, y con los

colores que crea más agradables. - Presentar los registros clasificados por más de una clave en pantalla y/o papel. 18.8.2 Suponga va a elaborar un programa para calcular la nómina de empleados de una compañía, los pagos se efectúan mensualmente. 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, Apellidos, Cédula de identidad, salario mensual básico, porcentaje de retención en la fuente y porcentaje de retención del Seguro Social. Escribir función principal(main) la cual permita presentar en pantalla un menú y efectuar, iterativamente, 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). Solo un registro cada vez que se invoque. Se debe a continuación proceder a grabarlo en disco.

LISTAR: Abrir el archivo en el cual están los registros, leerlo e ir

presentando los campos en pantalla. CLASIFICAR: Se deberá efectuar un ordenamiento, directamente sobre el disco,

por la clave Apellido, en orden ascendente, recuerde que como es cadena de caracteres debe utilizar strcmp.

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. Si se encuentra debe mostrarse en pantalla el nombre, apellido, y salario básico del mismo. Si no se encuentra la cédula debe mostrar aviso que entere de esta situación.

NOMINA: La impresora debe listar comprobantes de pago para cada uno de los

empleados y la nómina mensual.

228

18.8.3 En un juego del popular "Concéntrese", se tendrán 52 cartas de la baraja francesa representadas en memoria de la siguiente forma: struct carta{ char pinta; // La inicial de: Diamante, Trébol, Corazón, Pica char color; // Rojo, Negro int numero; // del 1 al 13 char tapada;//Si esta Tapada o si ya se Retiró del juego } Baraja[52]; Construir el juego del concéntrese, utilizando el modo de texto del vídeo. El programa debe permitir suspender la partida y poderla recuperar posteriormente en otro momento, es decir se debe grabar en disco el estado del juego. 18.8.4 Se tienen en unos registros los siguientes datos: Año de producción (desde 1970 a 1995); toneladas producidas de café para cada año, valor promedio($) en el año por libra vendida en el exterior, toneladas exportadas. Calcular el promedio de producción de café para cada uno de los años. Calcular el promedio de toneladas exportadas para cada uno de los años. Para cada año calcular los dólares en exportación y efectuar un gráfico de barras. 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. Los Cargos fijos son de $100,000. Los Cargos Variables se calculan como un 0.1 del patrimonio + 0.15% de la renta gravable, tomados estos datos de la correspondiente declaración de renta de los acudientes del estudiante. Se debe calcular el valor de los cargos fijos, los cargos variables y el total a cancelar por concepto de matrícula. En cada registro, a leer inicialmente desde teclado y posteriormente grabar en disco, 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, nombre, apellido, patrimonio y renta Representar globalmente el vector de registros que pueda representar la información del estudiante. 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. El programa presentará inicialmente un menú principal de conmutadores, el cual permita invocar funciones que hagan lo siguiente: CAPTURAR: Leer los campos de cada registro de estudiante por teclado, cada vez la correspondiente variable global debe incrementarse en uno. LISTAR: presentar en pantalla un submenú el cual permita listar la información clasificada por las claves: código del estudiantes, por apellido. El listado debe obtener una impresión por impresora de código, estudiante, renta, patrimonio, cargos fijos, cargos variable y total de matrícula. BUSCAR: se debe presentar un submenú el cual permita invocar sendas funciones las cuales permitan:- Digitar el código del estudiante y a continuación, y si existe, debe aparecer en pantalla toda su información sobre la matrícula. - Digitar el nombre de un estudiante y a continuación, y si existe, debe aparecer

229

en pantalla toda su información sobre la matrícula. Digitar un apellido o nombre y a continuación presentar todos los nombres completos de estudiantes que lo contengan. TOTAL MATRICULA: submenú que permita presentar en pantalla o escrito en papel. Presentar listado de el total de matrículas, totalizando al final. Se debe permitir tener la opción de escoger varios tipos de letra para imprimir en papel. ESTADÍSTICA: presentar estadísticas de el total de matrícula, con la ayuda del programa ESTADIST.CPP. 18.8.5 En una encuesta de un indeterminado número de jefes de hogar, 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?. Presentar algoritmo pulcramente con sangrado adecuado en lenguaje C++. 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. y cuarta opción que permita calcular y mostrar el salario promedio por hogar, dividiendo la sumatoria de los ingresos mensuales entre el número de jefes de hogar. Se debe calcular cúantos hogares tienen ingresos superiores a tres salarios mínimos, cuántos mayores o igual al mínimo y menores a tres salarios mínimos y cuántos tienen ingresos inferiores al mínimo. CAPTURA: leer los campos Cédula jefe de hogar, salario, renta, número de hijos y efectuando ciclo repetitivo capturar la edad de cada uno de sus hijos, acumularlas, para finalmente asignar a campo de edad promedio su respectivo valor. LISTADOS: En submenús presente listados clasificados por salario, renta, promedio de hijos y cédula de identificación. BUSCAR: Submenús que permitan encontrar los ciudadanos que están en cada uno de los rangos de salario mínimo señalados anteriormente; a partir de una cédula mostrar los datos de la correspondiente persona. Digitar un valor de renta y mostrar todos los registros que cumplen con que la de ellos en mayo o igual. Una editorial tiene un conjunto de registros para cada uno de los títulos de libros existentes, cada uno de los cuales contiene: código del libro, título de la obra, nombre completo del autor, número de páginas, existencia en bodega de cada título. Efectuar funciones que permitan: CAPTURAR: la captura de estos registros y mantenerlos en memoria en un vector de registros. PRECIO UNITARIO: A partir de digitar el código de un libro, efectuar su búsqueda y mostrar su precio teniendo en cuanta lo siguiente: El precio básico de un libro es de $2.000, más 35 pesos por página; empero, si el número de páginas excede de 300, el precio sufrirá un recargo adicional de $10; si el número de páginas excede de 550, el precio se incrementará $8, y esto debido al mayor costo de la compaginación y empastado. LISTAR: Por medio de un submenú mostrar en pantalla o en papel lo siguiente. Calcular e imprimir el código y el precio para cada uno de los libros, clasificados por el código del libro. Imprimir el total, en pesos, del inventario de libros. Mostrar el mismo inventario de libros clasificados por autor. Mostrar también clasificado por título.

230

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. Digitar un valor de libro y listar a continuación todos los libros que tienen igual o mayor precio. Digitar el nombre de un autor y a continuación mostrar todos los libros que le pertenezcan de entre el inventario. Digitar un título de un libro y a continuación decir cuantos ejemplares de ese título hay en existencia en el momento. Digitar un apellido o nombre y a continuación presentar todos los nombres completos de autores que lo contengan. Digitar una palabra y mostrar en pantalla todos los títulos que la contengan. CLASIFICAR: Por medio de submenús clasificar por: código, valor de cada libro, titulo y autor. Escoja al gusto si prefiere ordenes descendentes o ascendentes. ESTADÍSTICA: presente estadísticas de el valor de los libros, con la ayuda del programa ESTADIST.CPP 18.8.6 Cierta Universidad está interesada en saber estadísticamente la calificación promedio de los estudiantes que recibieron matemática durante un semestre. Desea saber también el número total de estudiantes y el número de estudiantes reprobados, en matemática, por plan y en total. CAPTURAR: Calcular lo anterior teniendo en cuenta que se leen: la calificación definitiva de matemáticas, código y número de plan, de todos los estudiantes que cursaron 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. LISTAR y CLASIFICAR: Listar por medio de submenús, información clasificada por plan de estudios, y dentro de cada plan de estudios listar clasificado por código de cada estudiante, como clave secundaria. BUSCAR: Se digita un código y a continuación se muestra la nota de el estudiante correspondiente. 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. GRABAR Y CARGAR: Todos los registros deben estar en disco. ESTADÍSTICA: presente estadísticas de las calificaciones de matemática, con la ayuda del programa ESTADIST.CPP 18.8.6 Una compañía le encarga un informe para comprar mercancía, y por esto le entregó unos registros con los siguientes datos, los cuales debe capturar por teclado y posteriormente mantener en disco:- Código del artículo (clave).- Nombre del artículo.- Existencia actual en inventario, en unidades.- Existencia mínima en unidades.(Cantidad de reorden).- Valor unitario. 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 menor a la existencia mínima. - Cantidad en pesos($) del total de artículos a comprar.- Listado de artículos sin existencia en inventario.- Listado de artículos con existencia superior a un 50% de la existencia mínima. Mostrar el total del inventario representado en pesos($). Permitir la impresión en cada oportunidad en papel.

231

BUSCAR: por medio de submenús contestar lo siguiente: Digitar un código de artículo y mostrar la información correspondiente a él, si es que existe. Digitar un nombre de artículo y contestar con su cantidad en inventario, si es que existe. Digitar una palabra y a continuación mostrar todos los nombres de productos que la contienen. CLASIFICAR: Por medio de submenús. Mantener clasificado por la clave Código de artículo. Clasificar por medio de la clave nombre de el artículo. ESTADÍSTICA: presente estadísticas de el existencias multiplicadas por el valor unitario de cada artículo, y con la ayuda del programa ESTADIST.CPP 18.8.7 Se debe elaborar un informe de cartera con base a una serie de registros con los datos de: código, nombre del cliente, Número de factura, valor original de la factura, plazo del crédito para cancelar la obligación; y los cuales hay que capturar por teclado, y mantener adecuadamente actualizados en disco. LISTAR: Utilizando submenú listar en pantalla adecuadamente y por impresora en papel utilizando diversas claves de ordenamiento. BUSCAR: Utilizar submenús para contestar lo siguiente: Se debe elaborar un informe a nivel de cliente teniendo en cuenta que si el plazo es hasta de 30 días se liquida 1% de interés; si el plazo esta entre 30 y 60 días se liquida un 2%; si el plazo está entre 60 y 120 días se liquida un 2,5%; y para plazos mayores de 120 días se liquida un 3%. Digitar el nombre de un cliente y a continuación mostrar todas las facturas que tiene pendientes de pago, con el plazo correspondiente en días. Digitar un número de factura y mostrar toda la información disponible y por calcular de la misma. ESTADÍSTICA: presente estadísticas de el total de las facturas, con la ayuda del programa ESTADIST.CPP 18.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, así: - Límite de velocidad de 60 kph en avenidas. Por cada kilómetro de exceso se

le cobran $2,000 adicionales. - El límite de velocidad en calles es de 40 kph. Por cada kilómetro de exceso

se le cobran $3,000 adicionales. - El límite de velocidad en autopista es de 80 kph. Por cada kilómetro de

exceso se le cobran $4,000 adicionales. 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. CAPTURAR: Se deben leer los siguientes campos por cada registro de vehículo infractor: Placa del carro, Velocidad del vehículo infractor, tipo de vía. Se deben tener en disco actualizados los registros. LISTAR: Presentar por medio de submenú las multas de todos los infractores, y clasificada por el número de placa. Presentar tanto en papel como en pantalla.

232

BUSCAR: Por medio de submenú. Digitar un tipo de vía y mostrar a continuación todos los registros de multa que coincida con él. Digitar un número de placa y mostrar en pantalla el registro de multa correspondiente, si es que existe. Digitar un real que representará kph y a continuación mostrar todos los registros que tengan infracción por este kilometraje y mayor. CLASIFICAR: Presentar listados en pantalla y en papel clasificados por tipo de vía, placa de carro, y de velocidad de infracción. ESTADÍSTICA: presente estadísticas de el total de multas cobradas, con la ayuda del programa ESTADIST.CPP 18.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, Valor del préstamo, Tasa de interés convenida en %, número del día del año en que fue hecho el préstamo(del 1 al 365). Se deben capturar los anteriores datos y mantenerlos tanto en RAM como en disco. 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 - día del préstamo)/360. Se debe imprimir el valor del interés pagado por cada cliente y el total para todos ellos. Este listado debe aparecer clasificado por la clave Cédula. 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. Digitar cédula y de igual forma aparecer en pantalla toda la información del cliente correspondiente. Digitar un nombre o apellido y mostrar en pantalla todos los nombres completos de clientes que lo contienen. CLASIFICAR: utilizando submenús mostrar en pantalla clasificaciones ascendentes y descendentes por las claves: cédula, nombre cliente, valor prestamos, tasas de interés. ESTADÍSTICA: presente estadísticas de el total de intereses a cancelar, con la ayuda del programa ESTADIST.CPP 18.8.10 Se requiere condensar algunas estadísticas sobre los estudiantes de la Universidad. Para cada registro se tiene: Código, Edad, Sexo(Masculino, Femenino), y Facultad (Psicología, Ingeniería, Comercio), los cuales deben capturar y mantener almacenados en disco. LISTAR: Se debe calcular e imprimir en pantalla y en papel: Promedio de edad de los estudiantes, porcentaje de hombres y mujeres por cada facultad y en la Universidad. Mantener clasificado por Código de estudiante. BUSCAR: Digitar un código y a continuación debe aparecer el registro correspondiente de es estudiante, si es que existe. Digitar un sexo y mostrar todos los registros que coinciden con él. Digitar un nombre de facultad y a continuación digitar todos los registros que la contengan. Digitar dos edades y a continuación mostrar todos los registros que están en el correspondiente intervalo de edades. CLASIFICAR: utilizando submenú presente listados clasificados por edad, sexo y de facultad, en forma ascendente y descendente. ESTADÍSTICA: presente estadísticas respecto a la edades, con la ayuda del programa ESTADIST.CPP

233

18.8.11 La Compañía AXZ tiene un registro por cada empleado con: Cédula de identificación, edad, meses trabajados en la compañía, cantidad en dinero a cancelar por hora trabajada, horas regulares trabajadas, horas extras(se cancela 50 adicional sobre el valor regular), los cuales debe capturar y mantener en disco. LISTAR: Por medio de submenú. Se desea saber si los nuevos empleados(menos de un año) tienden a trabajar más horas extras que los antiguos. Se desea saber qué cantidad de empleados tienen menos de un año en la compañía, de uno a menos de tres años, de tres a cinco años, de cinco a diez años y más de diez años. Por cada grupo se desea saber el promedio de horas trabajadas por empleado. Mantener clasificado por el número de cédula al mostrar lo anterior. Mostrar la cantidad a cancelar a cada uno de los empleados. BUSCAR: Utilizando submenú. Se digita cédula y de debe mostrar el registro correspondiente si es que existe, incluyendo la cantidad total que hay que cancelar a este empleado. Digitar dos edades y a continuación mostrar todos los registros que están en el correspondiente intervalo de edades. Digitar dos enteros que representarán meses y a continuación mostrar todos los registros que están en el correspondiente intervalo de meses. CLASIFICAR: Mostrar en pantalla clasificado por cédula de identidad, edad, meses de antigüedad en la compañía en ordenes ascendentes y descendentes. ESTADÍSTICA: presente estadísticas de el total pagado a cada empleado, con la ayuda del programa ESTADIST.CPP 18.8.12 En un almacén de cadena se tienen unos registros de inventario con los siguientes datos: código del almacén, código del departamento, código del artículo, saldo anterior, entradas, salidas, stock mínimo y costo unitario, los cuales se debe capturar por teclado y mantener adicionalmente en disco. 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", 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. Deben darse totales de los valores por cada departamento de almacén, por cada almacén y para toda la cadena. BUSCAR: digite un código de almacén y a continuación mostrar todos los registros que lo contengan. Lo mismo para el código del departamento. y finalmente igual para el código de artículo. CLASIFICAR: Por las claves código de departamento, de almacén y de artículo en forma ascendente y descendente. ESTADÍSTICA: presente estadísticas de el valor de las mercancías en inventario, teniendo en cuenta que para cada ítem de inventario, su total está dado por el saldo anterior más las entradas, menos las salidas y, este guarismo resultante, multiplicado por el costo unitario, con la ayuda del programa ESTADIST.CPP 18.8.13 Una asociación de universidades está interesada en elaborar una relación de estudiantes que sean casados y que trabajen. Se tienen registros con los datos de la ciudad, Universidad, Facultad, nombre del estudiante, edad, estado civil(casado, soltero), situación laboral (trabaja, no trabaja), campos estos que deben ser capturados y mantenidos en disco.

234

LISTAR: Debe presentarse un listado clasificado por Ciudad como primera clave, Universidad como segunda clave, y Facultad como tercera clave, para lo cual los datos deben mantenerse clasificados de esta forma en memoria RAM. enlazada. BUSCAR: Digitar nombre de estudiante y a continuación mostrar los correspondientes campos del registro correspondiente. Digitar nombre de universidad y mostrar a continuación todos los registros de estudiantes que la contienen. Digitar nombre de ciudad y a continuación mostrar todos los registros correspondiente. CLASIFICAR: Mostrar listados por separado clasificados por edad, estado civil y situación laboral. ESTADÍSTICA: presente estadísticas de edades de los estudiantes de las universidades, con la ayuda del programa ESTADIST.CPP. 18.8.14 PROGRAMA PARA UNA LÍNEA AÉREA: Una línea aérea desea controlar las reservas de vuelo de un avión. El número de cupos disponible para el vuelo es de MAX sillas. Representar en memoria por medio de un vector de registros. Cada registro en la lista representa una silla, habrá un número prefijado de sillas. Cada registro debe tener al menos los siguientes campos: Nombre pasajero, edad, teléfono, cédula, estado de la silla(Vacía, Reservada, Ocupada) Representar globalmente el vector de registros y variable que cuente las reservas efectuadas. 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). A continuación, presentar un menú principal de conmutadores, el cual permita invocar funciones que hagan lo siguiente: RESERVAR CUPO: En caso de estar llenos los cupos que aparezca el aviso "CUPO COMPLETO. POR FAVOR CIERRE EL VUELO". En caso de haber disponibilidad se le asigna el número de silla marcando como "Reservada" en el campo "Estado de la silla". De esta forma el número de reservas aumentará en una cada vez que sea invocada esta función. CANCELAR RESERVA: Se pide al pasajero el número de silla que tiene reservada, y se debe dejar marcada como "vacía" en el campo "Estado de la Silla" correspondiente. De esta forma el número de reservas se decrementará en una. 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". LISTAR: presentar en pantalla un submenú el cual permita listar la información clasificada por: cédula, y otro por apellido, y otra opción que permita imprimir en papel. CERRAR EL VUELO(y terminar el programa): Cuando el avión vaya a despegar, producir un listado con la siguiente estadística:

235

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

b) Listado de todos los nombres de pasajeros clasificados en orden

alfabético, con su respectivo teléfono y cédula. c) Estadísticas de las edades de los pasajeros, con la ayuda del programa ESTADIST.CPP.

237

AAPPÉÉNNDDIICCEE AA.. LLAASS TTRRAADDIICCIIOONNAALLEESS PPRRIINNTTFF YY SSCCAANNFF DDEELL ““VVIIEEJJOO CC”” Las instrucciones de lectura y escritura más utilizadas en el lenguaje C, hasta el momento, son scanf y printf respectivamente, las cuales son reemplazadas, con

gran ventaja como ya vimos, por el cout y el cin en el C++. A.1 El siguiente programa muestra la utilización de las instrucciones de lectura

scanf y de escritura printf. Así mismo presenta una introducción al formateo de números. Ver programa COUTIN06.CPP, en el Capítulo 2, el cual

realiza lo mismo con las instrucciones cin >> y cout <<. C_7.C*/ #include <stdio.h> #include <conio.h> 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(); printf( "┌───────────────────────────────────────────────┐\n"); printf( "│ MERCADO DE FRUTAS │\n"); printf( "└───────────────────────────────────────────────┘\n"); printf( "Digite el nombre de la fruta 2: "); scanf("%s", fruta2); printf( "\ndigite el precio(con centavos) de la fruta 2: $ "); scanf("%f", &p2); printf( "\ndigite la cantidad a comprar de la fruta 2: "); scanf("%d", &c2); printf( "\n\n┌───────────────────────────────────────────────┐\n"); printf( "│NOMBRE CANTIDAD PRECIO TOTAL │\n"); printf( "└───────────────────────────────────────────────┘\n"); printf( " %-10s %8d %15.2f %10.2f\n", fruta1, c1, p1, c1*p1); printf( " %-10s %8d %15.2f %10.2f\n", fruta2, c2, p2, c2*p2); printf( " %-10s %8d %15.2f %10.2f\n", fruta3, c3, p3, c3*p3); printf( "────────────────────────────────────────────────\n\n"); getch(); return 0; }

238

A.2 SE ESCRIBEN LOS N PRIMEROS MÚLTIPLOS DE 11 Y 15 /*C_1.C*/ main(){ int n, i, j, s11=0, s15=0, M11, M_15; clrscr(); printf ("Valor de n:"); scanf ("%d",&n); printf("\n\n"); for (i = 1; i < n; i++){ M11 = i * 11; printf("%4d", M11); s11 += M11; } printf("\n\nLA SUMA DE LOS %d PRIMEROS MÚLTIPLOS DE 11 ES :%d", n, s11); printf("\n\n"); for (j = 1; j < n ; j++ ){ M_15 = j * 15; printf ("%4d", M_15); s15 += M_15; } printf("\n\nLA SUMA DE LOS %d PRIMEROS MÚLTIPLOS DE 15 ES :%d", n, s15); getch(); } A.3 Se calcula la siguiente serie: S = 1 + 2 + 3 - 4 + 5 + 6 + 7 - 8 +... /*C_3.C*/ main(){ int n, suma=0, i=1; clrscr(); printf("DIGITE UN VALOR PARA N:"); scanf("%d", &n); gotoxy(1,4); for( ; i <= n ; i++){ if ( i % 4 == 0 ){ printf("%5d", -i); suma -= i; } else { suma += i; printf("%5d", i); } } printf("\n\nSumatoria = %d", suma); getch(); }

239

A.4 Efectúe prueba de ejecución manual al siguiente algoritmo. /* C_4.C */ main(){ int t; clrscr(); printf("introducir un número: "); scanf("%d", &t); total(t); } total(int x){ int suma = 0, i, contador; for( i = 0; i < x; i++) { suma += i; for(contador = 0 ; contador < 10; contador++) printf("."); printf ("la suma del 0 al %2d es %4d\n", i, suma); } getch(); } A.5 Se desarrolla un algoritmo el cual lee desde teclado los datos de una persona los cuales vienen en tarjetas: nombre, edad, sexo y estado civil; 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. /* C_5.C*/ #include <stdio.h> main(){ int Edad; char Sexo, EstadoCivil; char Nombre[20]; clrscr(); printf("Digite el nombre del encuestado: "); gets(Nombre); fflush(stdin); printf("Sexo (M/F): "); scanf("%c", &Sexo); fflush(stdin); Sexo = toupper(Sexo); printf("Edad: "); scanf("%d", &Edad); fflush(stdin); printf("Estado Civil (Casado, Soltero, Otro): "); scanf("%c", &EstadoCivil); fflush(stdin); EstadoCivil = toupper(EstadoCivil); if ( ( Sexo=='M' && Edad<30 ) || ( Sexo=='F' && Edad<50 ) ) printf( "\n % s Cumple una de las condiciones", Nombre); else printf( "\n\aNo cumple ninguna de las condiciones solicitadas"); }

240

A.6 Se digitan los valores de dos vectores del mismo tamaño y luego se produce su intercambio por medio de punteros. /*PUNTERO2.*/ #define Max 10 intercambio(int *va, int *vb){ int auxiliar, i; while (i<Max) { i++; auxiliar = *va; *va = *vb; *vb = auxiliar; va++; vb++; } } main(){ int a[Max], b[Max]; register int indice; clrscr(); printf("Digite %d valores para el vector A: \n", Max); for(indice = 0; indice < Max; indice++){ printf("A[%2d] = ", indice + 1); scanf("%d", &a[indice]); } printf("\n\nDigite %d valores para el vector B: \n", Max); for(indice = 0; indice < Max; indice++){ printf("B[%2d] = ", indice + 1); scanf("%d", &b[indice]); } clrscr(); printf("-----------------------------------------\n"); printf("Vectores originales A B \n"); printf("-----------------------------------------\n"); for(indice = 0; indice < Max; ++indice) printf("%30d%10d\n", a[indice], b[indice]); printf("-----------------------------------------\n\n"); intercambio(a, b); printf("Vectores intercambiados A B \n"); printf("-----------------------------------------\n"); for(indice = 0; indice < Max; ++indice) printf("%30d%10d\n", a[indice], b[indice]); getch(); }

241

APÉNDICE B. CÓDIGO ASCII Y SECUENCIAS DE ESC 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 de Caracteres ASCII imprimibles. 32 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 128 Ç 129 ü 130 é 131 â 132 ä 133 à 134 å 135 ç 136 ê 137 ë 138 è 139 ï 140 î 141 ì 142 Ä 143 Å 144 É 145 æ 146 Æ 147 ô 148 ö 149 ò 150 û 151 ù 152 _ 153 Ö 154 Ü 155 ¢ 156 £ 157 ¥ 158 _ 159 160 á 161 í 162 ó 163 ú 164 ñ 165 Ñ 166 ª 167 º 168 ¿ 169 _ 170 171 ½ 172 ¼ 173 ¡ 174 « 175 » 176 ░ 177 ▒ 178 ▓ 179 │ 180 ┤ 181 ╡ 182 ╢ 183 ╖ 184 ╕ 185 ╣ 186 ║ 187 ╗ 188 ╝ 189 ╜ 190 ╛ 191 ┐ 192 └ 193 ┴ 194 ┬ 195 ├ 196 ─ 197 ┼ 198 ╞ 199 ╟ 200 ╚ 201 ╔ 202 ╩ 203 ╦ 204 ╠ 205 ═ 206 ╬ 207 ╧ 208 ╨ 209 ╤ 210 ╥ 211 ╙ 212 ╘ 213 ╒ 214 ╓ 215 ╫ 216 ╪ 217 ┘ 218 ┌ 219 █ 220 ▄ 221 ▌ 222 ▐ 223 ▀ 224 225 ß 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 ± 242 243 244 245 246 247 248 249 250 251 252 _ 253 ² 254 255

A continuación se presentan los códigos de exploración de varias teclas y combinación de teclas. 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, 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, sino es leído con otra instrucción de lectura, él 50 se perderá, veámoslo con un pequeño fragmento en C: cout << "digite Combinación de teclas: "; c = getch(); supongamos el usuario hasta aquí digita ALT M, para ver qué quedó en la variable c: cout << " la variable c tiene el valor de " << c; se presentará el valor de 0. Para leer el código siguiente o código extendido:

242

c = getch(); cout << " el código extendido es " << (int) c; se coloca el reforzador de tipo, (int), 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 ║ ╚══════════════════════╧═════════════════╝

243

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.CTRL A 1 ... ... Y 25 F1 0 94 ... ... F10 0 103 IZQUIERDA 0 115 DERECHA 0 116 END 0 117 PAGE DOWN 0 118 HOME 0 119 PAGE UP 0 132 F11 0 137 F12 0 138 ARRIBA 0 141 - 0 142 + 0 144 ABAJO 0 145 INSERT 0 146 DELETE 0 147 / 0 149 * 0 150

ALT ESC 0 1 RETROCESO 0 14 Q 0 16 W 0 17 E 0 18 R 0 19 T 0 20 Y 0 21 U 0 22 I 0 23 O 0 24 P 0 25 ENTER 0 28 A 0 30 S 0 31 D 0 32 F 0 33 G 0 34 H 0 35 J 0 36 K 0 37 L 0 38 ; 0 39 ' 0 40 ` 0 41 \ 0 43 Z 0 44 X 0 45 C 0 46 V 0 47 B 0 48 N 0 49

ALT M 0 50 , 0 51 . 0 52 / 0 53 F1...F10 0 104-113 1 0 120 2 0 121 3 0 122 4 0 123 5 0 124 6 0 125 7 0 126 8 0 127 9 0 128 0 0 129 - 0 130 = 0 131 F11 0 139 F12 0 140 HOME 0 151 FLECHA ARRIBA 0 152 PAGE UP 0 153 FLECHA IZQUIERDA 0 155 FLECHA DERECHA 0 157 END 0 159 FLECHA ABAJO 0 160 PAGE DOWN 0 161 INSERT 0 162 DELETE 0 163 TAB 0 165 ENTER 0 166