C++ Corre

UNIVERSIDAD NACIONAL DEL CENTRO DEL PERU
TECNICAS DE PROGRAMACION ESTRUCTURADA: APLICACIONES CON C++
ABRAHAM GAMARRA MORENO DANIEL GAMARRA MORENO JUAN GAMARRA MORENO
CONTENIDO
INTRODUCCIN......................................................................................................1 1.1.Construccin de un programa de computadora...........................................3 1.1.1.Anlisis del problema........................................................................4 1.1.2.Proceso de solucin..........................................................................4 1.1.3.Refinamiento del Programa..............................................................5 1.2.Caractersticas de los programas.................................................................5 1.2.1.Claridad.............................................................................................5 1.2.2.Eficiencia...........................................................................................5 1.2.3.Modularidad y estructuracin............................................................6 1.3.Objetos de un programa...............................................................................6 1.3.1.Constantes........................................................................................6 1.3.2.Variables...........................................................................................7 2.1.Definiciones..................................................................................................8 2.1.1.Algoritmo...........................................................................................8 2.1.2.Programacin modular......................................................................8 2.1.3.Programacin estructurada..............................................................9 2.2.Construccin de algoritmos........................................................................11 2.3.Representacin de algoritmos....................................................................11 2.3.1.Diagrama de Flujo...........................................................................11 2.3.2.Diagrama N-S.................................................................................12 2.3.3.Pseudocdigo.................................................................................12 3.1.Caractersticas............................................................................................13 3.2.Identificadores............................................................................................14 3.3.Palabras reservadas...................................................................................14 3.4.Estructura de un programa.........................................................................15
3.5.Comentarios...............................................................................................15 3.5.1.Comentario en ms de una linea....................................................15 3.5.2.comentario en una sola lnea..........................................................15 3.6.Bloques 16 3.7.Tipos de datos fundamentales...................................................................16 3.7.1.Tipo char.........................................................................................16 3.7.2.Tipos enteros..................................................................................16 3.7.3.Tipos de punto flotante...................................................................17 3.7.4.Tipo void..........................................................................................17 3.8.Modificadores de tipo.................................................................................17 3.9.Constantes..................................................................................................17 3.9.1.Constantes enteras.........................................................................17 3.9.2.Constante carcter (char)...............................................................18 3.9.3.Constante cadena...........................................................................18 3.9.4.Constante de punto flotante............................................................19 3.10.Definicin de constantes..........................................................................19 3.10.1.La directiva #define.......................................................................19 3.10.2.Const.............................................................................................19 3.11.Declaracin de variables..........................................................................19 3.12.Expresiones..............................................................................................20 3.13.Conversin de tipos..................................................................................21 4.1.Operadores aritmticos..............................................................................22 4.2.Operador de asignacin.............................................................................23 4.2.1.Igual (=)...........................................................................................24 4.2.2.Asignacin mltiple.........................................................................24 4.2.3.Asignacin relativa..........................................................................24
4.3.Operadores de relacin..............................................................................25 4.4.Operadores lgicos....................................................................................25 5.1.Salida/entrada estndar en c++.................................................................26 5.1.1.Salida con cout...............................................................................26 5.1.2.Entrada con cin...............................................................................27 6.1.Sentencia if.................................................................................................29 6.2.Sentencia switch.........................................................................................36 6.3.Sentencias repetitivas o bucles..................................................................38 6.4.Sentencia while..........................................................................................39 6.5.Sentencia do while.....................................................................................42 6.6.Sentencia for...............................................................................................43 6.7.Sentencia break..........................................................................................46 6.8.Sentencia continue.....................................................................................47 6.9.Sentencia goto............................................................................................47 6.10.Programas de aplicacin..........................................................................48 7.1.Subprogramas o subrutinas.......................................................................62 7.2.Cundo utilizar un subprograma?............................................................62 7.3.Diseo descendente (Top Down)...............................................................63 7.3.1.Ejemplo...........................................................................................63 7.4.Programacin modular...............................................................................66 7.4.1.Modulo............................................................................................66 7.4.2.Criterios a considerar en programacin modular...........................67 7.4.3.Fases de la programacin modular................................................67 7.5.Definicin de funciones..............................................................................67 7.5.1.Declaracin de prototipos...............................................................68 7.5.2.Llamada a una funcin:...................................................................69
7.5.3.Parmetros por valor......................................................................71 7.5.4.Parmetros por referencia..............................................................71 7.5.5.mbito de una variable...................................................................73 7.5.6.Variables locales.............................................................................74 7.5.7.Prametros formales y reales.........................................................74 7.5.8.Variables globales...........................................................................74 7.6.Programas de aplicacin............................................................................77 7.7.Funciones del sistema................................................................................81 7.7.1.Utilizacion de la directiva #include..................................................81 8.1.Arreglos unidimensionales: vectores..........................................................84 8.2.Arreglos bidimensionales: tablas / matrices...............................................90 9.1.Representacin de registros......................................................................96 9.2.Estructuras..................................................................................................96 9.3.Uniones 98 9.4.Operaciones con estructuras...................................................................100 9.4.1.Paso de estructuras a funciones..................................................100 9.4.2.Anidamiento de estructuras..........................................................102 9.5.Arreglos de registros................................................................................104 9.6.Programas de aplicacin.........................................................................105 10.1.Conceptos basicos.................................................................................110 10.2.Cadenas y caracteres.............................................................................112 10.3.Punteros a estructuras...........................................................................117 10.4.Listas enlazadas.....................................................................................117 10.5.Colas (fifo)..............................................................................................123 11.1.Organizacin de archivos.......................................................................126 11.2.Escritura en archivos:.............................................................................129
11.3.Lectura de archivos:...............................................................................129 11.4.Ubicacin del puntero para acceso directo............................................130 BIBLIOGRAFIA.....................................................................................................137
INTRODUCCIN
La programacin de computadoras en sus inicios fue concebida como un arte donde la inspiracin del programador era la base para escribir programas. Con el objetivo de disminuir el tiempo de elaboracin de programas, disminuir el costo de mantenimiento y mejorar el trabajo en equipo, se idearon tcnicas como la metodologa estructurada que a su vez dio origen al anlisis y diseo estructurado. En la actualidad existen nuevas tcnicas como la metodologa orientada a objetos, pero que en la prctica es una metodologa ms estructurada. Dentro de la diversidad de Lenguajes de Programacin el C/C++ sigue siendo un estndar universal por su portabilidad, es as que muchos compiladores comerciales han sido desarrollados en el C/C++. La mayora de la bibliografa del Lenguaje de Programacin C/C++ asume que el lector tiene conocimientos previos de programacin, lo que conlleva a una secuencia de aprendizaje donde primero se estudian cursos introductorios como Pascal y metodologa de la programacin estructurada, que forman las bases y luego se estudia el Lenguaje de Programacin C/C++. Nuestra experiencia en la enseanza de lenguajes de programacin no nos ha permitido recomendar un texto que contenga la metodologa y programacin en C/C++. Es por eso que el texto esta dirigido a lectores que necesitan mejorar su metodologa de programacin y elaborar programas en C++, encontrando en este texto ejercicios variados en forma y
TECNICAS DE PROGRAMACIN ESTRUCTURADA: Aplicaciones en C++ GamarraMorenoADJ 1
complejidad. El texto contiene tcnicas de programacin estructurada con aplicaciones en Lenguaje C/C++. En los captulos I y II se desarrollan los conceptos bsicos sobre las tcnicas de programacin. Los captulos III, IV y V desarrollan las caractersticas del lenguaje de programacin C++. Las Sentencias de control, tratada en el capitulo VI, es la parte medular de cualquier programa y son estas que la que definen la secuencia de ejecucin de las sentencias del programa. En el capitulo VII, los programas grandes son divididos en pequeos programas llamados subprogramas y implementados como funciones, mediante las tcnicas del diseo descendente y la programacin modular se consigue una divisin optima del programa en subprogramas. Las estructuras de datos como los registros (en C/C++ struct) y arreglos (en ingls arrays) son desarrollados en el capitulo VIII. El capitulo VIII y IX tratan sobre los punteros y el uso de archivos de datos respectivamente. Esperamos que este material sea de gran ayuda aprendizaje en la programacin de computadoras. en su
LOS AUTORES.
TECNICAS DE PROGRAMACIN ESTRUCTURADA: Aplicaciones en C++
GamarraMorenoADJ
CAPITULO 1 PROGRAMACIN DE COMPUTADORAS

1.1. CONSTRUCCIN COMPUTADORA DE UN PROGRAMA DE
Cualquier tarea que involucre el enfrentarse a un problema - no necesariamente la construccin de un programa de computadora -, involucra el tener una comprensin total del mismo y planear cuidadosamente cada uno de los pasos que intervienen en su solucin. La aparicin de la computadora se ha constituido como un potente medio por el cual podemos resolver muchos de nuestros problemas (cuando el problema lo permita), pero, cmo nos ayuda la computadora a resolver estos problemas?. Para ello empleamos un conjunto de instrucciones que pueda entender la computadora, a este conjunto de instrucciones le llamamos programa de computadora. Estos programas pueden desarrollarse en alguno o varios de los diferentes lenguajes de programacin existentes, tambin se pueden emplear una combinacin de estos. Obviamente debemos conocer las particularidades de cada lenguaje de programacin y emplearlo adecuadamente. En nuestro caso emplearemos el Lenguaje de Programacin C++ aplicado con Tcnicas de
Programacin Estructurada, ambos sern analizados con ms detalle en las secciones que siguen. El desarrollo del Programa de Computadora implica el seguimiento de varias etapas, los cuales pasamos a describir:
1.1.1. ANLISIS DEL PROBLEMA

Aqu damos el primer paso para el desarrollo de un Programa de Computadora, en esta parte se describe detalladamente el problema, determinando lo siguiente: Datos de entrada En el cual se especifica los datos proporcionados por el problema en cuestin. Algunas veces se tendrn que seleccionar entre muchos datos, aquellos datos importantes para obtener lo que se requiere. Datos de salida El programa que se elabora para solucionar el problema generar un resultado (lo que requerimos), qu resultado?. Evidentemente, esto tambin lo encontramos al analizar el problema, de esta forma establecemos los datos que se deben obtener al aplicar el programa.
1.1.2. PROCESO DE SOLUCIN

Luego del anlisis estableceremos la relacin existente entre los datos de entrada y los datos de salida. Puesto que si el problema es factible de ser solucionado recurriendo a un programa de computadora, los datos de entrada deben sustentar una relacin con los datos de salida a travs de un algoritmo que ser la solucin a nuestro problema. Un algoritmo es simplemente el conjunto de acciones que se debern establecer para solucionar nuestro problema. Este algoritmo - el Captulo Dos trata en detalle acerca de los algoritmos puede ser presentado de diversas maneras, una
de sus formas de presentacin es a travs de cdigo en un lenguaje de programacin.
1.1.3. REFINAMIENTO DEL PROGRAMA

En esta etapa sometemos al programa a una serie de pruebas para determinar que cambios se podran realizar al programa para mejorar la funcionalidad del mismo, para este fin nos valemos de un grupo de datos de prueba que en muchas ocasiones nos permiten encontrar ciertos detalles que habamos dejado sueltos.
1.2. CARACTERSTICAS DE LOS PROGRAMAS

Para llegar a la solucin de un problema podemos utilizar varios mtodos de solucin, o lo que es lo mismo, varios algoritmos. Para seleccionar el algoritmo correcto debemos tener en cuenta ciertas caractersticas inherentes a estos algoritmos, que pueden estar representados en la forma de un programa de computadora. He aqu algunas de las caractersticas que podemos mencionar para este programa de computadora.
1.2.1. CLARIDAD
Ha de ser fcil de leer y entender, en lo posible se debe emplear el algoritmo ms simple, de entre las mltiples opciones existentes. Un modo de mejora en la claridad del programa, es el de disponer comentarios en el programa, esto permite adicionalmente; la facilidad en el mantenimiento, las modificaciones y actualizaciones cuando sea necesario.
1.2.2. EFICIENCIA
Se busca hasta donde se menor cantidad de acciones el programa, aprovechando pueda ofrecer el sistema pueda, emplear la o instrucciones en los recursos que y la computadora,
GamarraMorenoADJ
debe ser fcilmente adaptado a otro lenguaje de programacin.
1.2.3. MODULARIDAD Y ESTRUCTURACIN

Puede estar subdividido en bloques o mdulos, cada mdulo realiza una parte del trabajo total. Los mdulos deben usar las tcnicas de la Programacin Estructurada para facilitar la verificacin, depuracin y mantenimiento del programa.
1.3. OBJETOS DE UN PROGRAMA

Se consideran como objetos de un programa a aquellos elementos que son utilizados para almacenar y representar los datos ha emplearse en un programa, tienen las siguientes caractersticas: Identificador: Es el nombre que identificara al objeto. Ejemplo: suma, var1, pi, etc. Tipo: Es el conjunto de valores que puede tomar, el C++ tiene varios tipos de datos, el tipo de dato determina el conjunto de valores posibles para el objeto. Valor: Dentro del conjunto de valores que puede tomar se le asigna uno de ellos en un instante. Ejemplo: a = 5. Los objetos Variables. los podemos dividir en Constantes y
1.3.1. CONSTANTES
Estos objetos tienen valores fijos y que no pueden ser variados a lo largo de la ejecucin de un programa. Se tiene aquellas que son predefinidas y definitivamente sus valores no pueden ser cambiados. Por ejemplo: __time__ significa la hora en el que fue compilado el archivo fuente.
GamarraMorenoADJ
En el C++ tambin existen lo que se ha dado por llamar variables constantes, aunque realmente sean las constantes que define el propio programador.
1.3.2. VARIABLES
Son objetos cuyos valores tienen posibilidad de ser cambiados durante ejecucin del programa. Ejemplo: int declara una variable a de tipo int. la la a;
GamarraMorenoADJ
CAPITULO 2 ALGORITMOS
2.1. DEFINICIONES
2.1.1. ALGORITMO
El algoritmo tal como lo vimos inicialmente, es el conjunto de acciones que se debern realizar para resolver un problema. Si este problema ha de ser resuelto por una computadora, entonces el algoritmo es el conjunto de instrucciones que debern ser realizados por la computadora. El algoritmo empleado debe indicar el orden de realizacin de cada instruccin, el nmero de instrucciones ser finito. Se debe obtener los mismos resultados, cuando los datos de entrada son los mismos. Para la construccin de los algoritmos emplearemos; la Programacin Modular y una Tcnica de Programacin Estructurada.
2.1.2. PROGRAMACIN MODULAR

Existe una regla de oro en la programacin, divide y vencers. La Programacin Modular
es la aplicacin de esta regla, divide el programa en mdulos, en el caso del C++ estos mdulos estn representados en la forma de funciones, ya que el C++ es un lenguaje funcional, es decir solamente emplea funciones en la construccin de un programa. Estos mdulos reducen la complejidad de un programa, al permitir que cada mdulo pueda ser analizado y perfeccionado casi independientemente del resto de los mdulos, no totalmente independiente porque no se debe perder la visin global del programa. Los mdulos son interdependientes entre s; uno de ellos, el mdulo principal, controla y relaciona los dems mdulos. El mdulo principal, tambin es conocido como programa principal; en el caso del C++ esta viene a ser la funcin principal o funcin main(). El resto de mdulos se conocen como procedimientos o subprogramas; en el caso del C++ se denominan simplemente funciones. Un mdulo es un conjunto de instrucciones ordenadas, los cuales pueden ser referenciados empleando el nombre que se le asigna al mdulo. Cabe mencionar que, si el programa no es muy complejo no ser necesario crear ms de un mdulo, en este caso no se ha dividido el programa.
2.1.3. PROGRAMACIN ESTRUCTURADA

Ya sea que el programa cuente con uno o varios mdulos, en nuestro caso del C++, con una o ms funciones, tendremos que emplear la tcnica de programacin estructurada en el mdulo o los mdulos. La Programacin Estructurada, es una tcnica de programacin existen otras- que emplea en el diseo de los mdulos: estructuras de control, recursos abstractos y un diseo descendente.
GamarraMorenoADJ
Estructuras de control Son tres tipos de estructuras que al utilizarse individualmente o en forma combinada pueden resolver cualquier problema de programacin con un solo punto de entrada y de salida. Las estructuras son las siguientes: Estructura secuencial, el cual ejecuta el conjunto de instrucciones sucesivamente una a continuacin de otra, sin omitir ninguna. Estructuras selectivas, son aquellas que seleccionan una alternativa puede ser una o varias instrucciones- a realizar, la seleccin depende del valor de una condicin. Estas a su vez se dividen en estructuras selectiva simple, doble y mltiple. Estructuras repetitivas, son aqullas en le que una instruccin o conjunto de instrucciones se repiten una cantidad de veces determinada por una condicin. Tenemos las siguientes, estructura repetitiva mientras, hacer mientras, desde hasta (para). Recursos abstractos El conjunto de instrucciones a seguir es un recurso abstracto, pues es independiente del tipo de computadora a emplear, as como tambin del lenguaje de programacin. Estas instrucciones deben ser implementadas con pocos o casi ningn cambio, en un lenguaje de programacin especfico para cualquier tipo de computadora. Metodologa Descendente de Arriba hacia Abajo Esta metodologa conocida tambin como top_down coloca las instrucciones en una estructura jerrquica, teniendo que algunas de estas instrucciones se encuentren en niveles respecto a otros. Dos instrucciones de niveles inmediatos se relacionan a travs de sus entradas y salidas. En cada nivel se detalla como se utilizan los datos que permitir la resolucin del
2.2. CONSTRUCCIN DE ALGORITMOS
problema planteado. Estos niveles muchas veces representan mdulos de programas.
Con el conocimiento acerca de los datos de entrada y salida, se puede iniciar la construccin del algoritmo. Para construir un algoritmo se emplea un diseo descendente, por lo tanto el algoritmo puede emplear mdulos de programa que sern fciles de analizar. Cada uno de estos mdulos pueden modificados constantemente de tal manera que se ajusten cada vez ms a las necesidades de nuestro programa. Luego es necesario representar el algoritmo a travs de algunas herramientas que mencionaremos en la siguiente seccin.
2.3. REPRESENTACIN DE ALGORITMOS

El algoritmo puede ser representado de diversas maneras, para ello emplearemos algunas de las denominadas herramientas de programacin: Diagrama de flujo, Diagrama N-S, Pseudocdigo. La representacin del algoritmo recurriendo al cdigo de un Lenguaje de Programacin tal como el C++, hace que se tenga que conocer necesariamente la sintaxis y caractersticas de este, por ello en forma general e independientemente del lenguaje de programacin, es mejor representarlo empleando algunas de estas herramientas. En este libro orientaremos el diseo del algoritmo para su representacin en el C++.
2.3.1. DIAGRAMA DE FLUJO

Es una tcnica que sirve para representar un algoritmo a travs de smbolos y representa el orden de la secuencia de los algoritmos a travs de lneas de flujo, representadas como flechas. Existen unos pocos smbolos denominados principales que permite representar un algoritmo en forma general, pero adems se cuenta con un conjunto de smbolos
adicionales que se emplean para situaciones especificas.
2.3.2. DIAGRAMA N-S

El diagrama Nassi Schneiderman, para abreviar diagrama N-S, cumple tambin la funcin de representar un algoritmo, para ello hace uso de cajas contiguas, dispuestas uno tras de otros. Igual que el anterior, permite representar todas las instrucciones que deben ir en un programa.
2.3.3. PSEUDOCDIGO
Representa al algoritmo, en forma de palabras y frases del lenguaje natural, en nuestro caso el espaol. El Pseudocdigo a de estar sujeto a ciertas reglas que mencionaremos oportunamente, de tal manera que permitan expresar nuestro algoritmo de manera fcil y flexible.
GamarraMorenoADJ 12
CAPITULO 3 CARACTERISTICAS DEL C++

3.1. CARACTERSTICAS
El lenguaje de programacin C++ se emplea para escribir sistemas de operativos, compiladores, programas ensambladores, programas de bases de datos, sistemas expertos, etc. Y sus caractersticas son: Es de propsito general;
Es un lenguaje de alto nivel como: PASCAL, BASIC, etc; Es un lenguaje estructurado, pues contiene las estructuras bsicas de composicin, seleccin y lazo o ciclo con entrada nica; Se le considera lenguaje de nivel medio, esto es, entre lenguaje ensamblador y de alto nivel, pues permite el manejo de datos a nivel de bits, bytes y direcciones; Permite la programacin modular: se pueden escribir programas independientes (mdulos) constituyendo libreras de programas para ser utilizados posteriormente;
GamarraMorenoADJ 13
Es transportable: los programas escritos en este lenguaje pueden ser ejecutados bajo diferentes plataformas (Sistemas Operativos).
3.2. IDENTIFICADORES
Un identificador es el nombre que se da a un programa, variable, constantes, etiqueta, funcin, clase, estructura, etc. Su longitud significativa por defecto es de 32 caracteres y debe estar formado por: El primer carcter debe ser una letra o el carcter subrayado (_), Los siguientes caracteres al primero pueden ser letras, dgitos, o el carcter subrayado (no esta permitido los espacios), El lenguaje C++ diferencia entre maysculas y minsculas en los identificadores, es decir los identificadores AREA y area son diferentes, y No se deben usar como identificadores las palabras reservadas por el lenguaje (ejemplo: break, case, char, int, etc.)
3.3. PALABRAS RESERVADAS

Las palabras reservadas forman parte del lenguaje de programacin C++ y entre algunas de las palabras reservadas tenemos: Asm cdecl continue Do enum far Friend inline long Pascal register short static this virtual Auto Char _cs Double _es _fastcall Goto Int Near Private Return Signed Struct typedef void Break Class default _ds Extern float huge Interrupt new protected _saveregs sizeof switch union volatile case const delete else _export for if _loadds operator public _seg _ss template unsigned while
GamarraMorenoADJ 14
3.4. ESTRUCTURA DE UN PROGRAMA

El Lenguaje de programacin C++ esta formado por funciones y estos a su vez estn formados por bloques, la funcin main es la encargada de llamar a las otras funciones. // Directivas y declaraciones main(){ //Directivas declaraciones //Sentencias } funcin_1(){ //Directivas declaraciones //Sentencias } //Ms funciones Las Directivas son orden de programa que no se traducen a lenguaje de maquina porque es un mensaje para el compilador (o preprocesador), algunas directivas son: #include, #pragma, #define, #undef, etc. Las declaraciones son sentencias que especifican atributos (identificador, tipo de datos, alcance, tiempo de vida) de una variable o una funcin. La declaracin de una funcin se conoce como prototipo.
3.5. COMENTARIOS
Los comentarios son ignorados por el compilador y se utilizan para autodocumentar los programas y C++ soporta dos tipos:
3.5.1. COMENTARIO EN MS DE UNA LINEA

/* Comentario */ El compilador ignora todo lo que se encuentra entre /* y */.
3.5.2. COMENTARIO EN UNA SOLA LNEA

// Comentario
GamarraMorenoADJ 15
El compilador ignora todo lo que viene despus de // hasta el final de la lnea.
3.6. BLOQUES
Cualquier grupo de instrucciones puede formar un bloque y ser tratado como una instruccin simple, para lo cual basta encerrarlo entre llaves. { //Sentencias } Se pueden anidar como se muestra a continuacin {//Comienzo de bloque {//Comienzo de sub-bloque .. } //Fin de sub-bloque }//Fin de bloque
3.7. TIPOS DE DATOS FUNDAMENTALES

3.7.1. TIPO CHAR
Son datos de un byte de longitud. Las variables de este tipo pueden tener signo (por defecto) o no tener signo, su rango es de -128 a 127 y de 0 a 255, respectivamente. Puede almacenar codigos ASCII (de: letras, digitos, signos de puntuacion, simbolos especiales, etc. Este tipo de dato internamente como un nmero entero. es tratado
3.7.2. TIPOS ENTEROS

Guardan nmeros enteros positivos o negativos o cero, los tipos enteros son: TIPO Unsigned char Char Enum Unsigned int Short int Int Unsigned long LONGITUD 8 bits 8 bits 16 bits 16 bits 16 bits 16 bits 32 bits RANGO 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
GamarraMorenoADJ 16
TIPO Long
LONGITUD RANGO 32 bits -2,147,483,648 a 2,147,483,647
3.7.3. TIPOS DE PUNTO FLOTANTE

Guardan nmeros positivos, negativos o cero con parte fraccionaria o punto decimal. TIPO Float Double Long double LONGITUD 32 bits 64 bits 80 bits RANGO 3.4*10-38 a 3.4*1038) 1.7*10-308) a 1.7*10308 3.4*10-4932 a 1.1*104932
3.7.4. TIPO VOID

Es un tipo de dato que indica vaco (nulo). Cuando una funcin no devuelve un valor la funcin es de tipo void.
3.8. MODIFICADORES DE TIPO

Los modificadores de tipo son: signed, unsigned, short, long. Alteran el rango del tipo. Todos los modificadores son aplicables al tipo int. Los modificadores signed, unsigned puede ser aplicado al tipo char. Cuando el tipo es omitido entonces int es asumido. El modificador long puede ser aplicado al tipo double. Ejemplos: long x; /* long int */ unsigned char car; /* Caracter sin signo */ unsigned long int; /* Se puede omitir int, porque el tipo por defecto es int */
3.9. CONSTANTES
Son valores numricos, caracteres o cadenas que no ocupa memoria fuera del cdigo del programa.
3.9.1. CONSTANTES ENTERAS

Son constantes sin parte fraccionaria y puede estar en sistema de numeracin octal, decimal
o hexadecimal; por decimal: 34, 5678.
ejemplo
en
el
sistema
Constante hexadecimal Las constantes Hexadecimales y estn precedidas por 0x, utiliza los dgitos del 0..9 y las letras de A..F (para representar valores del 10..15); por ejemplo: 0xFF, 0x12. Constante octal Son constantes en el sistema de numeracin octal y estn precedidos por 0 (cero), utiliza los dgitos del 0..7; por ejemplo: 011, 004.
3.9.2. CONSTANTE CARCTER (CHAR)

Es una constante que esta formado por un solo carcter encerrado entre comillas o una secuencia de escape; por ejemplo: '\n','A'. Las secuencias utilizar son: S.ESC \a \b \f \n \t \" \r \\ \? \DDD \xHHH \0 \' \v de escape que se pueden
CARACTER DE SALIDA alerta (beep) Retroceso salto de pagina (alimentacin) salto de lnea tabulador horizontal comillas dobles retorno de carro Backslash Signo de interrogacin Cdigo octal de un carcter Cdigo hexadecimal de un carcter carcter nulo comilla simple Tabulacin vertical
3.9.3. CONSTANTE CADENA

La constante cadena es un conjunto de caracteres y/o secuencias de escape que estn encerrados entre comillas dobles. "A" es una cadena y 'A' es un carcter.
3.9.4. CONSTANTE DE PUNTO FLOTANTE

Son constantes fraccionaria; por -4.3E+38. numricas ejemplo: con 12.48, parte .24,
3.10. DEFINICIN DE CONSTANTES

Una constante no puede cambiar su valor cuando el programa esta en ejecucin. Se define utilizando:
3.10.1.
LA DIRECTIVA #DEFINE
#define <identificador> <Valor> Ejemplo: #define NOTA_MAX 20 #define ENTER 0x13 #define titulo "TURBO C"
3.10.2.
CONST
const <identificador>=<Valor>; Ejemplo: const NOTA_MAX=20;
3.11. DECLARACIN DE VARIABLES

Toda variable para ser usada por un programa debe ser antes declarada y el formato a utilizar es: [<almacenamiento>] [<=valor>]; <tipo> <identificador>
< almacenamiento>: auto, static, register, extern. Si se omite asume auto. <identificador>: Indica los nombres de las variables a definir y estn separados por comas. Ejemplos: int contador=0; float sueldo, descuento, igv=0.18;
GamarraMorenoADJ 19
3.12. EXPRESIONES
Son valores, constantes, variables, llamada a una funcin o una combinaciones de los anteriores. Cuando se mezclan variables de diferentes tipos en una expresin, C++ las convierte a un mismo tipo. C++ convertir todos los operandos al tipo ms grande segn: Todos los tipos char, short int se convierten a int. Todos los tipos float a double. Para todo par de operandos, lo siguiente ocurre en secuencia: a) b) c) d) EJEMPLO char ch; int i; float f; double d; r=(ch / i) int int double double En la conversin, el tipo char ch es convertido a int y el float f es convertido a double. Luego segn los operandos se van modificando los tipos hasta obtener double. Si uno de los operandos es un long double el otro se convierte a long double. Si uno de los operandos es double el otro se convierte a double. Si uno de los operandos es long el otro se convierte a long. Si uno de los operandos es unsigned el otro se convierte a unsigned.
(f
d)
(f
i);
double at double
double double double
GamarraMorenoADJ 20
3.13. CONVERSIN DE TIPOS

Para forzar el tipo de una expresin utilice: (tipo) <expresin> Ejemplo: float res; int num=13; i=(float) num/2; /* i toma el valor de 6.5 */ /* Primero num se cambia al tipo float luego efectua la operacin */ y
GamarraMorenoADJ 21
CAPITULO 4 OPERADORES BSICOS

4.1. OPERADORES ARITMTICOS
Los operandos de mayor precedencia se ejecutan antes que los de menor precedencia. Por ejemplo: 4+5*214 Los operandos con igual precedencia se ejecutan de izquierda a derecha. Por ejemplo: 5*4/2/25 OPERADOR ( ) + ++ -* / % + DESCRIPCION Agrupacin Menos unitario Ms unitario Incremento Decremento Multiplicacin Divisin Modulo Suma Resta EJEMPLO (3+5) -3 +3 a++ a-4*3 4/3 4%3 4+3 4-3 OBSERV. PRECEDENCIA 1 2 2 2 2 3 3 3 5 5
a=a+1 a=a-1
Cuando el operador de divisin se aplica a un operando de tipo entero el resultado es de tipo entero, ejemplo 3/2 es igual a 1. Para obtener la parte fraccionaria
es necesario que uno de los operandos sea de tipo flotante, ejemplo 3/2.0 3.0/2 es igual a 1.5. El operador modulo es equivalente a decir el residuo de dividir el primer operando entre el segundo, ejemplo 5%2 es igual a 1. Slo es aplicado a datos de tipo entero. El operador ++ o -- puede ir delante o despus del operando. Cuando va delante del operando primero incrementa o decrementa y luego utiliza el nuevo valor del operando. Cuando va despus del operando primero utiliza el valor del operando y luego lo incrementa o decrementa. Ejemplo del uso de ++ antes del operando: a=3; x=++a+3; a toma el valor de 4, a este nuevo valor se le suma 3, por lo tanto x=7. Es lnea es equivalente a: a = a + 1; x = + + a + 3; x = a + 3; Ejemplo del uso de ++ despus del operando: a=3; y=a+++2; // y toma el valor del resultado de a (utilizando su valor 3) + 2 igual a 5, luego a toma el valor de 4. Su equivalencia es: y = a + 2; y = a + + + 2; a = a + 1;
4.2. OPERADOR DE ASIGNACIN

Estos operadores son utilizados para asignar un valor a una variable y pueden ser:
GamarraMorenoADJ 23
4.2.1. IGUAL (=)

Variable = <Valor>; El valor puede ser una variable o una expresin. Ejemplos: saldo = 567.89; car = A; edad = 20; constante, una
4.2.2. ASIGNACIN MLTIPLE

Permite asignar un valor o expresin a ms de una variable. variable_1=variable_2= =variable_N=expresin; Ejemplo: x=y=3*2;
4.2.3. ASIGNACIN RELATIVA

variable <operador> = Expresin El operador puede ser cualquier aritmtico y es equivalente a: variable = variable operador expresin; OPERADOR += -= *= /= %= Ejemplo: x += 5; y -= 3; z = 2; //Equivalente a x=x+5; //Equivalente a y=y+3; //Equivalente a z=z*2; EJEMPLO x+=5; x-=5; x*=5; x/=5; x%=5; OBSERVACIONES x=x+5; x=x-5; x=x*5; x=x/5; x=x%5; operador
GamarraMorenoADJ 24
4.3. OPERADORES DE RELACIN

Los operadores relacionales dan como resultado verdadero o falso. En "C++" todo numero diferente de cero es verdadero, y cero es equivalente a falso. OPERADOR > >= < <= == != DESCRIPCION mayor que mayor o igual que menor que menor o igual que igual que diferente de EJEMPLO 4>12 4>=12 4<12 4<=12 4==12 4!=12 PRECEDENCIA 1 1 1 1 2 2
4.4. OPERADORES LGICOS

Los operadores lgicos dan como resultado verdadero o falso. Recuerde que en "C++" todo numero diferente de cero es verdadero y cero es falso. OPERADOR ! && || DESCRIPCION No lgico y lgico o lgico EJEMPLO !(4>12) (4>12)&&(8>12) (4>12)||(8>12) PRECEDENCIA 1 2 3
El resultado de los operadores lgicos se resume en la siguiente tabla: p 1 1 0 0 q 1 0 1 0 !p 0 0 1 1 !q 0 1 0 1 p&&q 1 0 0 0 p||q 1 1 1 0
GamarraMorenoADJ 25
CAPITULO 5 SALIDA / ENTRADA ESTNDAR

5.1. SALIDA/ENTRADA ESTNDAR EN C++
5.1.1. SALIDA CON cout
El flujo de salida se representa por el identificador cout, que es en realidad un objeto. El operador << se denomina operador de insercin o de poner en. Dirige el contenido de la variable situada a su derecha al objeto situado a su izquierda. Su formato es: cout << expr_1<< expr_2<< ... << expr_n; Ejemplo 1: //Permite usar el cout #include <iostream.h> main() { cout<< "primer programa"; //lee un carcter del teclado }
Ejemplo 2 //programa que suma dos nmeros #include <iostream.h> main() { int x=1,y=3,suma; suma=x+y; cout<< "\n la suma de "<< x << " mas " <<y << " es " << suma; }
5.1.2. ENTRADA CON CIN

El C++ permite la entrada de datos a travs del flujo de entrada cin. El objeto cin es un objeto predefinido en C++ que corresponde al flujo de entrada estndar. Este flujo representa datos que proceden del teclado. El operador >> se denomina tambin de extraccin o de lectura de. Toma el valor del objeto flujo de su izquierda y lo sita a en la variable situada a su derecha. Su formato es: cin >>variable_1>>variable_2>>>>variable_n; Ejemplo 1: /* Programa que suma dos nmeros leidos del teclado */ #include <iostream.h> main() { int x,y,suma; cout << "Ingrese dos nmeros : "; cin >> x >> y; suma=x+y; cout<< "\n la suma de "<< x <<" mas " <<y <<" es " <<suma; }
GamarraMorenoADJ 27
Ejemplo 2: /* Programa que suma convierte de Farenheit a Celsius */ #include <iostream.h> main() { int f,c; cout << "Ingrese temperatura farenheit : "; cin >> f; c=(f-32)*5/9; cout<< "Su equivalente en celsius es "<< c; }
GamarraMorenoADJ 28
CAPITULO 6 SENTENCIAS DE CONTROL

Las sentencias de control son una parte imprescindible dentro de un lenguaje de programacin. Son aquellas que determinan secuencia de las sentencias a ejecutar.
6.1. SENTENCIA if
E xpr
SI N0 S e n te n c ia
Si la expresin es diferente de CERO ejecuta la sentencia y continua con la sentencia que sigue a if. if (expresin) sentencia; Ejemplo 1 : El siguiente programa determina el nmero mayor de dos nmeros ingresados por el teclado.
GamarraMorenoADJ 29
#include <iostream.h> void main(){ float num1,num2,mayor; cout <<"Ingrese dos nmeros : "; cin >> num1 >> num2; mayor=num1; if(num2>num1) mayor=num2; cout <<"El mayor es : "<<mayor<<endl; } Explicacin Despus del ingreso de los dos nmeros se asume que el mayor es num1, pero la condicin de la sentencia if evala si num2 es mayor que num1 y si la condicin es verdadera el mayor es num2.
Ejemplo 2
El siguiente programa valor absoluto.

#include <iostream.h> void main(){ float num;
determina
el
cout <<"Ingrese el nmero : "; cin >> num; if(num<0) num=-num; cout <<"El valor absoluto : "<<num<<endl; } Explicacin El numero ingresado se evala para determinar si es negativo, un numero es negativo si es menor que cero. Si es negativo se le cambia de signo para obtener su valor absoluto.
Ejemplo 3
Programa que imprime en orden ascendente los tres nmeros ingresados.

#include <iostream.h> void main(){ int a,b,c,t; cout<<"Tres nmeros enteros : "; cin >> a >> b >> c; if (a>b) { t=a; a=b; b=t;} if (b>c) { t=b; b=c; c=t;} if (a>b) { t=a; a=b; b=t;} cout <<a<<\t<<b<<\t<<c; } Explicacin
GamarraMorenoADJ 30
Los nmeros ingresados son a, b y c. Utilizando el algoritmo de la burbuja para tres nmeros, que consiste: En comparar si el primer numero es mayor que el segundo numero, si el segundo numero es mayor que el tercer numero, y finalmente, si el primer numero es mayor que el segundo numero. Si se cumple la condicin se intercambian sus valores. Al final a, b y c contienen los valores ordenados ascendentemente de los nmeros ingresados. Para intercambiar los valores de num1 y num2 se utiliza el siguiente algoritmo: t=num1; num1=num2; num2=t; Usando la variable t (temporal) se consigue que no se pierda el valor de num1. Si los nmeros son: num1=10 y num2=5; la prueba de escritorio es: //t toma el valor de num1 (10) t=10; //num1 toma el valor de num2 (5) num1=5; //num2 toma el de t (10) num2=10; Al finalizar la ejecucin de las tres sentencias se tiene: num1=5 y num=10; lo que nos confirma que el algoritmo ha intercambiado sus valores originales. Note que en el programa las tres sentencias que realizan el intercambio estn encerrado entre llaves formando un bloque de sentencias.
SI
E xpr
NO
S e n te n c ia _ 1
S e n te n c ia _ 2
Si la expresin es diferente de CERO ejecuta la sentencia_1, sino ejecuta la sentencia_2. En ambos casos continua con el flujo del programa.
GamarraMorenoADJ 31
if (expresin) sentencia_1; else sentencia_2; Ejemplo 1 : Programa que determine el salario semanal a pagar a un trabajador. Por trabajar ms de 40 horas durante la semana se hace acreedor a una pago extraordinario que consiste: en pagar por cada hora extra 50% mas que una hora normal. En este programa se ingresan: el numero de horas trabajadas y el pago por hora normal.
#include <iostream.h> void main(){ int horas; float pago,p_h; cout<<"Numero de horas trabajadas:"; cin>>horas; cout<<"Pago por hora normal:"; cin>>p_h; if(horas>40) pago=(horas-40)*1.5*p_h+40*p_h; else pago=horas*p_h; cout<<"\n\nPago semanal:"<<pago; cout<<endl; } Explicacin La sentencia if evala si el trabajador tiene mas de 40 horas (horas>40) para determinar si tiene horas extras. Si tiene horas extras calcula su pago debido a las horas extras ((horas-40)*1.5*p_h) y su pago normal por las 40 horas (40*p_h). Si no tiene horas extras para calcular su pago se multiplica simplemente el nmero de horas trabajas por pago por hora (horas*p_h).
Ejemplo 2
Programa que determina si un ao es bisiesto. Un ao es bisiesto si es mltiplo de 4. Los aos mltiplos de 100 no son bisiestos salvo que lo sean tambin de 400; por ejemplo: 1984 y 2000 son bisiestos, pero 1800 no es bisiesto.
#include <iostream.h> void main(){ int anno,sw=0; cout<<"Ao : ";
GamarraMorenoADJ 32
cin>>anno; if(anno % 4==0){ sw=1; if(anno%100==0&&anno%400!=0) sw=0; } if(sw) cout <<"Ao bisiesto"; else cout<<"Ao no bisiesto"; cout<<endl;
Explicacin: En el programa sw=0 significa que el ao no es bisiesto y sw=1 significa ao bisiesto. Se asume que el ao es no bisiesto (sw=0) y si es mltiplo de cuatro (anno % 4==0) sw cambia a 1, lo que significa que el ao es bisiesto. Los aos mltiplos de 100 tambin son mltiplos de cuatro, pero no son bisiestos. Por esa razn, cuando los aos son mltiplos de 100 y no lo son de cuatrocientos (anno%100==0 && anno%400! =0) sw cambia a 0, lo significa que no es bisiesto.
Ejemplo 3
Programa que calcula el permetro de un tringulo si se ingresan las medidas sus tres lados a, b y c. Para que los tres lados del tringulo cierren se debe cumplir: a<b+c, b<a+c y c<a+b.
#include <iostream.h> void main(){ float a,b,c,p; cout <<"Ingrese los lados : "; cin >> a >> b >> c; if(a<b+c && b<a+c && c<a+b){ p=a+b+c; cout << "Perimetro= " << p; } else { cout<< "No forman un triangulo"; }
Explicacin: Antes de calcular el permetro se evala si los tres lados forman el tringulo.
GamarraMorenoADJ 33
e x p r = = c o n s t_ 1
SI
NO
S e n te n c ia _ 1
e x p r = = c o n s t_ 2
SI
NO
S e n te n c ia _ 2
e x p r = = c o n s t_ 3
SI
... ... ...
S e n te n c ia _ 3
e x p r = = c o n s t_ N
SI
NO
S e n te n c ia _ N
S e n te n c ia _ x
if (expresin_1) sentencia_1; else if (expresin_2) sentencia_2; else if (expresin_3) sentencia_3; ... ... else if (expresin_n) sentencia_n; [else sentencia_x;] Ejemplo 1

La comisin sobre las ventas totales de un empleado es como sigue:
Si ventas < 50.00 unidades monetarias (u.m.) entonces no hay comisin. Si esta entre 50.00 u.m. y 500.00 u.m. incluidos, entonces la comisin es 10% de las ventas. Si las Ventas > 500.00, entonces la comisin es 50.00 u.m. mas 8% de las ventas superiores a 500.00. El programa calcula ingresa las ventas. la comisin cuando se
GamarraMorenoADJ 34
#include <iostream.h> void main(){ float ventas,comision; cout<<"Ventas totales : "; cin>>ventas; if(ventas<50) comision=0; else if(ventas>=50&&ventas<=500) comision=ventas*0.10; else if(ventas>500) comision=50+(ventas-500)*0.08; cout<<"Comisin: " << comision<<endl; }
Ejemplo 2
Programa que calcula el monto a pagar por el consumo de energa elctrica, si durante su ejecucin se ingresa el consumo y el tipo de tarifa. Las tarifas son: TIPO DE TARIFA 1 2 3 4 5 COSTO (U.M./Kw-h) 2.30 8.25 6.42 5.80 9.65
#include <iostream.h> void main(){ float consumo,tarifa,monto; int tipo; cout<<"Consumo (kw-h):"; cin>>consumo; cout<<"Tipo de tarifa(1 al 5): "; cin<<tipo; if (tipo==1) tarifa=2.30; else if (tipo==2) tarifa=8.25; else if (tipo==3) tarifa=6.42; else if (tipo==4) tarifa=5.80; else if (tipo==5) tarifa=9.65; else tarifa=0; if(tarifa){ monto=cons*tarifa; cout<<"\nMonto a pagar: "<<monto; } else cout<<"\nLa tarifa no existe";
Explicacin: En el programa segn determina la tarifa

el tipo de tarifa correspondiente y
se al
GamarraMorenoADJ 35
multiplicar el tipo de tarifa por el consumo se obtiene el monto a pagar. Adems, si el tipo de tarifa es diferente de 1 a 5 se le asigna a la variable tarifa cero, lo que significa que la tarifa no existe, slo si la tarifa existe se calcula e imprime el monto a pagar, caso contrario se imprime La tarifa no existe.
6.2. SENTENCIA switch
E xpr C o n s ta n te _ 1 C o n s ta n te _ 2 C o n s ta n te _ n d e f a u lt
S e n te n c ia _ 1
S e n te n c ia _ 2
.....
S e n te n c ia _ n
S e n te n c ia _ x
El switch es una forma sencilla de evitar largos, tediosos y confusos anidamientos de else-if, esta sentencia proporciona una estructura lgica y clara para bifurcacin mltiple. switch(expresin){ case constante_1 case constante_2 case constante_3 . . case constante_n [default } : sentencia_1; break; : sentencia_2; break; : sentencia_3; break; : sentencia_n; break; : sentencia_x;]
La sentencia switch evala el valor de la expresin y segn ese valor determina el flujo del programa. Si el valor de la expresin es igual a la constante_1 ejecuta la sentencia_1, si el valor es igual a la constante_2 ejecuta la sentencia_2, as sucesivamente. Si el valor de la expresin es diferente a las constantes indicadas en la sentencia switch ejecuta la sentencia_x correspondiente a default. Si al final de cada case no se incluye break esto ocasionara que todas las sentencias que estn debajo
de la constante que tome el valor de la expresin ejecuten hasta encontrar un break o el final switch; por ejemplo: si la expresin es igual a constante_2 se ejecutaran la sentencia_2, sentencia_3, as sucesivamente hasta encontrar break o el final de la sentencia switch. Ejemplo 1 :
se de la la un
Programa que calcula el monto a pagar por el consumo de energa elctrica, si durante su ejecucin se ingresa el consumo y el tipo de tarifa. Las tarifas son: TIPO DE TARIFA 1 2 3 4 5 COSTO (U.M./Kw-h) 2.30 8.25 6.42 5.80 9.65
#include <iostream.h> void main(){ float consumo,tarifa,monto; int tipo; cout<<"Consumo:"; cin>>consumo; cout<< "Tipo de tarifa(1 al 5):"; cin>>tipo; switch(tipo){ case 1:tarifa=2.30;break; case 2:tarifa=8.25;break; case 3:tarifa=6.42;break; case 4:tarifa=5.80;break; case 5:tarifa=9.65;break; default:tarifa=0; } if(tarifa){ monto=consumo*tarifa; cout<<"\nMonto a pagar:"<<monto; } else cout<<"\nTarifa incorrecta"<<endl; }
Ejemplo 2
Programa donde se ingresan el sueldo de un trabajador, su categora (A,B,C) y su ao de ingreso. Luego calcula su nuevo sueldo, segn:
GamarraMorenoADJ 37
Categora "A": 15% para los que ingresaron antes de 1980 y 12% para el resto. Categora "B": 20% para los que ingresaron antes de 1980 y 17% para el resto. Categora "C": 25% para los que ingresaron antes de 1980 y 22% para el resto. #include <iostream.h> void main(){ int anno; float sueldo; char cat; cout<<"Ingrese Sueldo:; cin>>sueldo; cout<<"Ingrese Ao:; cin>>anno; cout<<"Ingrese Categora:; cin>>cat; switch(cat){ case 'A': case 'a': if(anno>1980) sueldo=1.15*sueldo; else sueldo=1.12*sueldo; break; case 'B': case 'b': if(anno>1980) sueldo=1.20*sueldo; else sueldo=1.17*sueldo; break; case 'C': case 'c': if(anno>1980) sueldo=1.25*sueldo; else sueldo=1.22*sueldo; break; } cout<<"Nuevo sueldo: "<<sueldo<<endl;
6.3. SENTENCIAS REPETITIVAS O BUCLES

Una sentencia repetitiva o bucle permite ejecutar repetidamente una sentencia o un bloque de sentencias mientras se cumple una determinada condicin, pero si el bucle se ejecuta indefinidamente se forma un bucle infinito. Un bucle infinito se forma generalmente por un error lgico de programacin.
Las sentencias repetitivas en C++ son: while, do while y for.
6.4. SENTENCIA while
E xpr
SI N0 S e n te n c ia
Primero evala la expresin (expr), si la condicin es verdadera (diferente de cero) entonces la sentencia es ejecutada, caso contrario pasa el control a la sentencia que sigue a la sentencia while. Despus de la ejecucin de la sentencia la condicin nuevamente es evaluada y se procede como en el caso anterior. Para que la sentencia se ejecute por lo menos una vez la condicin por lo menos una vez debe ser verdadera. while (expresin) sentencia; Ejemplo 1 : Programa que consecutivos. imprime los n nmeros
#include <iostream.h> void main(){ int n,i; cout<<"Ingrese el valor de n: "; cin >> n; i=0; while (n>i){ i++; cout<<i<<"\n"; }
Explicacin:
Para comprender el funcionamiento del programa es conveniente hacer la prueba de escritorio, para lo cual hacemos n=3. Ingresar el valor de n=3 Hacer i=0 La condicin de while n>i, 3>0 se cumple por lo: Hacer i=1 Imprimir el valor de i=1 y un cambio de lnea La condicin de while n>i, 3>1 se cumple por lo: Hacer i=2 Imprimir el valor de i=2 y un cambio de lnea La condicin de while n>i, 3>2 se cumple por lo: Hacer i=3 Imprimir el valor de i=3 y un cambio de lnea La condicin de while n>i, 3>3 no se cumple Fin del programa
Ejemplo 2
Programa que imprime los divisores de un numero natural

#include <iostream.h> void main(){ int n,i; cout<<"Ingrese un numero entero : "; cin >> n; i=1; while (n/2>=i){ if (n % i==0) cout<<i<<"\n"; i++; }
Explicacin: Para determinar los divisores de n: se divide n entre los nmeros consecutivos de 1 hasta aproximadamente la mitad de n. Si al dividir n entre uno de los nmeros consecutivos el residuo es cero significa que este numero consecutivo es divisor de n. Es decir por cada numero consecutivo se debe determinar si es divisor de n. En el programa en la variable i se generan los nmeros consecutivos y con la sentencia if (n %i==0) se determina si i es divisor, la
condicin determina si n entre i tiene residuo cero.
Ejemplo 3
Programa que determina si un numero natural es primo. Un numero es primo si slo es divisible por la unidad y por si mismo.
#include <iostream.h> void main(){ int n,d; cout <<"Numero cin >> n; d=2; while(d*d<n && if (d*d>n) cout<< "Es else cout<< "No natural : "; n%d!=0) d++; primo"<<endl; es primo"<<endl;
Ejemplo 4
Programa que imprime los primos de un numero natural.

#include <iostream.h> void main(){ int n,d=2;
factores
cout<<"Ingrese un numero entero : "; cin >> n; while (n>=d){ while (n%d!=0) d++; cout<<d<<"\n"; n/=d; }
Ejemplo 5
Programa que imprime la cantidad de nmeros primos indicados comenzando de 1. El valor de n es ingresado.
#include <iostream.h> void main(){ int n,d,i,cant; cout<<"Cantidad de nmeros primos:"; cin>>cant; n=i=0; while (cant>i) { n++; d=2; while(d*d<n && n % d !=0) d++; if (d*d>n){ cout<< n << " "; i++; }
GamarraMorenoADJ 41
} }
6.5. SENTENCIA do while
S e n te n c ia SI
E xpr
NO
La sentencia se ejecuta mientras verdadera (diferente de cero). evaluada despus que se ejecuta diferencia fundamental entre while la segunda se ejecuta por lo menos sea el resultado de expresin.
la expresin sea La expresin es la sentencia. La y do while es que una vez, sea cual
do sentencia while(expr); Ejemplo 1 : Programa que obtiene el producto de dos nmeros enteros positivos mediante sumas.
#include <iostream.h> void main(){ int n1,n2,acum=0; cout<<"Primer entero positivo:"; cin>>n1; cout<<"Segundo entero positivo:"; cin>>n2; do{ acum=acum+n2; n1=n1-1; }while(n1); cout<<"Producto=<<acum<<endl; }
Ejemplo 2
Programa que calcula el Mximo Comn Divisor (MCD) de dos nmeros naturales utilizando el algoritmo de euclides.
GamarraMorenoADJ 42
El algoritmo consiste: los nmeros a dividir se ubican en la parte central, el cociente se ubica en la parte superior y el residuo en la parte inferior. Se dividen los dos nmeros si el residuo es diferente de cero, el divisor pasa a ser el dividendo y el residuo viene a ser el divisor, se continua con este proceso hasta que el residuo sea cero. El mximo comn divisor es igual al ltimo divisor, por ejemplo:
MCD(70,12)=2 5 1 5 70 12 10 10 2 0
#include <iostream.h> void main(){ int n1,n2,mcd,res;
MCD(60,36)=12 1 1 2 60 36 24 12 14 12 0
cout<<"Ingrese 2 nmeros enteros: "; cin>>n1>>n2; do{ res=n1%n2; n1=n2; n2=res; }while(n2); mcd=n1; cout<< "El MCD es "<<mcd<<endl;
6.6. SENTENCIA for
E x pr_1
E x pr_2
SI S e n te n c ia N0
E x pr_3
GamarraMorenoADJ 43
La sentencia for se ejecuta repetidamente hasta que el valor de la expr_2 sea falso (CERO). Generalmente la exp_1 es el valor inicial del bucle, y es evaluado antes de la primera ejecucin de la sentencia. La expr_3 es comnmente el contador del bucle y es ejecutado despus de la ejecucin de la sentencia. Tanto expr_1, expr_2 y expr_3 pueden contener ms de una expresin separados por comas. for(expr_1;expr_2;expr_3) sentencia; No es imprescindible indicar las TODAS las expresiones dentro del parntesis del for, pudiendose dejar en blanco algunas de ellas, por ejemplo:
for (;expr_2;expr_3) sentencia; for (expr_1; ; ) sentencia; for ( ; ; ) sentencia;
La sintaxis de las dos ltimas sentencias producen bucles infinitos. Ejemplo 1 : Programa que calcule la suma de los n trminos de: s= 1 2 3 + + + ... 2 3 4
#include <iostream.h> void main(){ int i,n; float s; cout<<"Cantidad de trminos: "; cin>>n; s=0; for(i=1;i<=n;i++) s=s+i/(i+1.0); cout<<"Suma =<<s<<endl; }
Ejemplo 2
Programa que calcula la suma de: s = 1+ 1 1 1 1 + + + ... 2 3 4 n
#include <iostream.h> void main(){ int n,i; float s; cout<<"Cantidad de trminos: "; cin>>n; s=0;
for(i=1;i<=n;i++) s=s+1.0/i; cout<<"Suma="<<s<<endl; }
Ejemplo 3
Programa que calcula la suma de los n trminos de: 1 1 1 s = 1 + + ... 2 3 4

#include <stdio.h> #include <conio.h> #include <iostream.h> void main(){ int n,i; float s,t; clrscr(); cout<<"Cantidad de trminos: "; cin>>n; s=0; t=-1.0; for(i=1;i<=n;i++){ t=-t; s=s+t/i; } cout<< "Suma ="<<s; getch();
Ejemplo 4
Programa que calcula la suma de: s= 1 1 1 1 + + + ... 1+ A 1 + 2 A 1+ 3A 1+ n * A
#include <iostream.h> void main(){ int n,i; float s,t,a; cout<<"Cantidad de trminos: "; cin>>n; cout<<"Valor de A: "; cin>>a; s=0; for(i=1;i<=n;i++){ t=1/(1+i*a); s=s+t; } cout<< "Suma = "<<s<<endl;
Ejemplo 5
Programa que imprime los trminos de la serie de fibbonacci menores que n.

GamarraMorenoADJ 45
Los trminos de la serie de fibbonacci se obtienen sumando los dos trminos que le antecedentes as: 1, 2, 3, 5, 8, 13, ... Los trminos 1 y 2 son los nmeros iniciales y partir de ellos se calculan los dems trminos. #include <iostream.h> void main(){ long int n,p,s,fib; cout<<"Limite : "; cin>>n; fib=1; for(p=0,s=1;n>=fib;){ cout<<fib<<\t; p=s; s=fib; fib=p+s; }
6.7. SENTENCIA break

fo r ( e x p r 1 ; e x p r 2 ; e x p r 3 ) { s e n te n c i a _ 1 ; s e n te n c i a _ 2 ; ... bre a k; s e n te n c i a _ n ; } s e n t e n c i a _ s i g u i e n te ; La sentencia break es usada dentro de un bloque while o do while o for o switch, y fuerza la finalizacin de la sentencia donde es usada. Ejemplo : Programa que lee un nmero de punto flotante y lo imprime redondeado a dos decimales. El usuario decide si quiere continuar.
#include <iostream.h> void main(){ double num; char resp; while(1){ cout<<"Numero : "; cin>>num; num=((long int) (num*100+0.5))/100.0; cout<<"Numero Redondeado:"<<num;
} }
cout<<"\nContinuar (S/N)?\n"; cin>>resp; if ((resp=='N') || (resp=='n')) break;
6.8. SENTENCIA continue
fo r ( e x p r 1 ; e x p r 2 ; e x p r 3 ) { s e n te n c i a _ 1 ; s e n te n c i a _ 2 ; ... c o n tin u e ; s e n te n c i a _ n ; } s e n te n c i a _ s i g u i e n te ; La sentencia continue es usada dentro de un bloque While o do while o for, y fuerza el flujo del programa al inicio de la sentencia donde es usada. Ejemplo : Programa que imprime los nmeros pares comprendidos de 1 a 20.
#include <iostream.h> void main(){ int i; for( i=1 ; i <=20 ; i++ ){ if (i % 2) continue; cout<<i<<\t; }
6.9. SENTENCIA goto

La sentencia goto transfiere el flujo del programa a una sentencia precedida por una etiqueta seguida de dos puntos (:) dentro de un mismo bloque. goto etiqueta; La etiqueta tiene las mismas restricciones que un identificador. Esta sentencia esta en desuso en la programacin estructurada.
GamarraMorenoADJ 47
Ejemplo
Programa que suma los nmeros ingresados, el ingreso termina cuando el ingreso es cero.
#include <iostream.h> void main(){ int n,s=0; inicio: cout<<"Ingrese un nmero : "; cin>>n; s+=n; if(n) goto inicio; cout<<"La suma es: "<<s<<endl;
Explicacin: Si n!=0 (verdadero) vuelve a sentencia a la etiqueta inicio. ejecutar la
6.10. PROGRAMAS DE APLICACIN

Ejemplo 1 : Programa que lee 3 nmeros imprime en orden descendente.
#include <iostream.h> void main(){ int a,b,c; cout<<"Ingrese 3 nmeros enteros:"; cin>>a>>b>>c; if (a>b) if (a>c) if (b>c) cout<<a<<\t<<b<<\t<<c; else cout<<a<<\t<<c<<\t<<b; else cout<<c<<\t<<a<<\t<<b; else if (b>c) if (a>c) cout<<b<<\t<<a<<\t<<c; else cout<<b<<\t<<c<<\t<<a; else cout<<c<<\t<<b<<\t<<a; }
los
Ejemplo 2
Programa que resuelve una ecuacin de segundo grado de la forma: ax 2 + bx + c = 0
GamarraMorenoADJ 48
La discriminante es:
d = b 2 4ac
Si la discriminante es mayor o igual que cero (d>=0) tiene races reales, caso contrario tiene races complejas. Las races se obtienen con:
#include <iostream.h> #include <math.h> void main(){ float a,b,c,r,r1,r2,d; cout<<"Ingrese a, b y c: "; cin>>a>>b>>c; d=b*b-4*a*c; r=sqrt(abs(d)); if (d>=0){ r1=(-b+r)/(2*a); r2=(-b-r)/(2*a); cout<<"r1=<<r1<<\n; cout<<"r2=<<r2<<\n; } else { cout<<r1=<<-b/(2*a)<<+ <<r/(2*a)<<i\n; cout<<r1=<<-b/(2*a)<<- <<r/(2*a)<<i\n; } cout<<endl; }
b b 2 4ac x= 2a
Ejemplo 3
Programa que permita jugar a las adivinanzas. El usuario tiene que elegir un entero de un solo dgito. El programa tiene que pedir si el numero es par o impar (0 o 1), y el resto cuando el numero se divide entre 5. A partir de esa informacin se debe determinar el nmero.
#include <iostream.h> void main(){ int numa,par,res; cout<<"Piense en un numero de\n; cout<<una sola cifra\n\n; cout<<"Ingrese:\n; cout<<"1 si el numero es par\n; cout<<"2 si el numero es impar\n; cin>>par; cout<<"Ingrese el residuo de\n; cout<<" dividir el numero\n;
GamarraMorenoADJ 49
cout<<pensado entre 5:\n; cin>>res; if(par==1){ if(res % 2) numa=res+5; else numa=res; } else { if(res % 2) numa=res; else numa=res+5; } cout<<"El numero pensado es:"<<numa<<endl; }
Ejemplo 4
Un profesor ha establecido la siguiente calificacin entre sus alumnos:

Notas de 14 a 20 BUENO Notas de 07 a 13 REGULAR Notas 00 a 06 DESAPROBADO
ALGORITMO: Si se divide la nota entre 7 se deduce: Nota de 00 a 06 cociente 0, Nota de 07 a 13 cociente 1, Nota de 14 a 20 cociente 2. #include <iostream.h> void main(){ int nota,cociente; cout<<"Ingrese nota de 0 a 20 :"; cin>>nota; /*Si la nota es positiva realiza calificacion */ if (nota>=0){ /* divide la nota entre 7 */ cociente=nota / 7; switch(cociente){ case 0: cout<<"DESAPROBRADO"; break; case 1: cout<<"REGULAR"; break; case 2: cout<<"BUENO"; break; default: cout<<"NOTA INCORRECTA"; } } cout<<endl; }
Ejemplo 5
Programa que verifica si (dd/mm/aaaa) es correcta.
una
fecha
#include <iostream.h> void main(){ int anno,mes,dia,ok=0,bisiesto=0;

cout<<"Fecha (dd mm aaaa):"; cin>>dia>>mes>>anno; //Determina si el ao es bisiesto if(anno % 4==0){ bisiesto=1; if(anno%100==0&&anno%400!=400) bisiesto=0; } //En funcin al mes verifica si el //numero de das es correcto switch(mes){ case 1: case 3: case 5: case 7: case 8: case 10: case 12: if(dia>=1&&dia<=31) ok=1; break; case 4: case 6: case 9: case 11: if(dia>=1&&dia<=30) ok=1; break; case 2: if(bisiesto){ if(dia>=1&&dia<=29) ok=1; } else if(dia>=1&&dia<=28) ok=1; break; } if(ok) cout<<"\nFecha Correcta"<<endl; else cout<<"\nFecha incorrecta"<<endl;
Ejemplo 6
Programa que imprima los enteros positivos desde 1 hasta 300, de manera que en la salida aparezcan tres nmeros en un lnea, as:
1 2 3 4 5 6 ... ... 97 98 99 #include <iostream.h> void main(){ int i; for(i=1;i<=99;i++){ cout<<i<<\t; if(!(i%3)) cout<<"\n"; } }
Ejemplo 7
Programa donde se ingresa un numero del 1 al 99 y luego lo imprima en letras.

#include <string.h>
GamarraMorenoADJ 51
#include <stdlib.h> #include <iostream.h> void main(){ int numero; int unidad,decena; char dec_le[9],uni_le[6]; cout <<"Numero (1..99):"; cin >> numero; unidad=numero%10; decena=numero/10; switch (decena) { case 0: strcpy(dec_le,"");break; case 1: strcpy(dec_le,"diez");break; case 2: strcpy(dec_le,"veinte");break; case 3: strcpy(dec_le,"treinta"); break; case 4: strcpy(dec_le,"cuarenta"); break; case 5: strcpy(dec_le,"cincuenta"); break; case 6: strcpy(dec_le,"sesenta"); break; case 7: strcpy(dec_le,"setenta"); break; case 8: strcpy(dec_le,"ochenta"); break; case 9: strcpy(dec_le,"noventa"); break; default: cout << "Fuera de rango"<<endl; exit(0); } if(decena==1){ strcpy(dec_le,""); switch(unidad){ case 0: strcpy(uni_le,""); break; case 1: strcpy(uni_le,"once"); break; case 2: strcpy(uni_le,"doce"); break; case 3: strcpy(uni_le,"trece"); break; case 4:
strcpy(uni_le,"catorce"); break; case 5: strcpy(uni_le,"quince"); break; } } else{ if (decena) strcat(dec_le," y "); switch(unidad){ case 0: strcpy(uni_le,"");break; case 1: strcpy(uni_le,"uno");break; case 2: strcpy(uni_le,"dos");break; case 3: strcpy(uni_le,"tres"); break; case 4: strcpy(uni_le,"cuatro"); break; case 5: strcpy(uni_le,"cinco"); break; } } switch (unidad) { case 6: strcpy(uni_le,"seis");break; case 7: strcpy(uni_le,"siete");break; case 8: strcpy(uni_le,"ocho");break; case 9: strcpy(uni_le,"nueve");break; } strcat(dec_le,uni_le); cout << dec_le<<endl; }
Ejemplo 8
Programa que imprima las poblaciones de las ciudades A y B hasta que la poblacin A sea mayor que B, si sus tasas de crecimiento son: 6% y 4% respectivamente. En la actualidad, las ciudades A y B tiene 85 millones y 45 millones de habitantes respectivamente.
#include <iostream.h> void main(){ float pa,pb,ta,tb; int i; //Poblacion A pa=52e+6; //Poblacion B
GamarraMorenoADJ 53
pb=85e+6; //Tasa de crecimiento A ta=0.06; //Tasa de crecimiento B tb=0.04; i=0; while (pa<=pb) { i++; pa=pa*(1+ta); pb=pb*(1+tb); cout <<i<<"\t"<<pa/1000<<"\t" <<pb/1000<<"\n"; } }
Ejemplo 9
Programa donde se ingresa un nmero en base 2 y luego imprima su equivalente en decimal. Durante el ingreso solo se lee los dgitos 0 y 1, otro dgito es ignorado.
#include <iostream.h> void main(){ long int n,n_ok=0,nc=0; int digito,factor=1,res; //Ingreso del numero binario do{ cout<<"Numero en base 2: "; cin>>n; }while(n>2147483647||n<0); while (n>=10){ digito=n%10; if (digito>=0 && digito<=1){ n_ok+=(digito*factor); factor*=10; } n/=10; } if (n>=0 && n<=1) n_ok+=(n*factor); //Numero correcto n_ok //Conversin a base 10 en nc factor=1; //Guarda el valor de n_ok n=n_ok; while(n>=10){ res=n % 10; nc+=(res*factor); n/=10; factor*=2; } nc+=(n*factor); cout<<"En base 2 : "<<n_ok<<"\n"; cout<<"En base 10: "<<nc<<"\n";
GamarraMorenoADJ 54
Ejemplo 10 :
Programa que imprime los n primeros nmeros perfectos, si n es ingresado. Un numero perfecto es un entero positivo que es igual a la suma de sus divisores, excluido si mismo.
#include <iostream.h> void main(){ long int i=1,d,suma; int c=0,n; cout<<"Cantidad de numeros: "; cin >> n; i=0; while(n>c){ i++; d=1; suma=0; while (i>d){ if (i % d==0) suma+=d; d++; } if(suma==i){ cout<<i<<"\n"; c++; } } }
Ejemplo 11 :
Programa donde se ingresa la fecha actual y la fecha de nacimiento de una persona; luego calcula y visualiza la edad del individuo en aos, meses y das.
#include <iostream.h> void main(){ int dia_n,mes_n,anno_n,dia_a,mes_a; int anno_a,bisiesto,diam,edad_a; int edad_m,edad_d; cout<<"Hoy es (dd mm aaaa):"; cin>>dia_a>>mes_a>>anno_a; cout<<"Naci el (dd mm aaaa):"; cin>>dia_n>>mes_n>>anno_n; if(mes_a>=mes_n){ if(dia_a>=dia_n){ edad_a=anno_a-anno_n; edad_m=mes_a-mes_n; edad_d=dia_a-dia_n; }else{ edad_a=anno_a-anno_n; edad_m=mes_a-mes_n; if(anno_n%4==0){ bisiesto=1;
GamarraMorenoADJ 55
if(anno_n%100==0 && anno_n%400!=0) bisiesto=0; } switch(mes_n) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: diam=31; break; case 4: case 6: case 9: case 11: diam=30; break; case 2 : if(bisiesto) diam=29; else diam=28; break; } edad_d=dia_a+diam-dia_n;
} }else{ if(dia_a>=dia_n){ edad_a=anno_a-anno_n-1; edad_m=12+mes_a-mes_n; edad_d=dia_a-dia_n; } else{ edad_a=anno_a-anno_n-1; edad_m=12+mes_a-mes_n-1; if(anno_a%4==0){ bisiesto=1; if(anno_a%100==0 && anno_a%400!=0) bisiesto=0; } switch(mes_a-1) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: diam=31; break; case 4: case 6: case 9: case 11: diam=30; break; case 2 : if(bisiesto) diam=29; else diam=28; break; } edad_d=dia_a+diam-dia_n; } } if (edad_a>=0 && edad_m>=0 && edad_d>=0){ cout<<"Tiene "<<edad_a<<" aos"; cout <<" y "<<edad_m<<" meses"; cout <<" y "<<edad_d<<" dias\n"; } else cout<<"Error en el ingreso\n";
GamarraMorenoADJ 56
Ejemplo 12 :
Programa que imprime todos los nmeros de tres dgitos CDU, tales que si se invierte el orden de sus cifras aumentan en 297.
#include <iostream.h> void main(){ int num,num_i,n; for(num=100;num<=999;num++){ num_i=0; n=num; while(n>=10){ num_i=num_i*10+n%10; n/=10; } num_i=num_i*10+n; if(num_i-num==297) cout << num <<"\t"; } }
Ejemplo 13 :
En una reunin hubo 820 apretones de mano. Sabiendo que cada persona saluda a otra sola una vez y a todas las dems. Este programa determina cuantas personas asistieron a la reunin.
#include <iostream.h> void main(){ int s,i; s=0; i=0; do s+=++i; while(s!=820); cout<<"Asistieron:"<<i+1<<endl;
Ejemplo 14 :
Programa que lee un numero entero y luego lo imprime sin los dgitos mayores a 5. Por ejemplo, si se ingresa 456712 se imprime 4512.
#include <iostream.h> void main(){ long int n,n_ok=0; int digito,factor=1; do{ cout<<"Numero: "; cin>>n; }while(n>2147483647||n<0); while (n>=10){ digito=n%10;
GamarraMorenoADJ 57
if (digito>=0 && digito<=5){ n_ok+=(digito*factor); factor*=10; } n/=10; } if (n>=0 && n<=5) n_ok+=(n*factor); cout<<"El numero depurado es:; cout<<n_ok<<"\n";
Ejemplo 15 :
En una cuenta de ahorros se deposita un capital a una tasa de inters compuesto por un tiempo de "n" aos. Cada "x" aos se deposita un mismo monto de dinero p y cada "y" aos se retira un mismo monto de dinero q. Tanto el deposito como el retiro se realizaran al finalizar el ao. Programa que imprime el ao y el capital acumulado al final del ao considerando el deposito y/o retiro efectuado.
#include <iostream.h> void main(){ int i,n,per_dep,per_ret; float capital,tasa,deposito,retiro; cout<<"Capital :"; cin>>capital; cout<<"Tasa :"; cin>>tasa; cout<<"Tiempo (annos):"; cin>>n; cout<<"Deposito:"; cin>>deposito; do{ cout<<"Periodo del deposito :"; cin>>per_dep; }while(per_dep>n || per_dep<1); cout<<"Retiro:"; cin>>retiro; do{ cout<<"Periodo del retiro :"; cin>>per_ret; }while(per_ret>n || per_ret<1); cout<<"\n\nAnno\tCapital\n"; for(i=1;i<=n;i++){ capital+=capital*tasa; if (i%per_dep==0) capital+=deposito; if (i%per_ret==0) capital-=retiro; cout<<i<<"\t"<<capital<<"\n"; }
GamarraMorenoADJ 58
Ejemplo 16 :
Programa que imprime los nmeros capicas comprendidos entre 0 y 1000. Un numero es capica si al invertir sus cifras sigue siendo el mismo numero. Por ejemplo, 121 es capica porque al invertir sus cifras sigue siendo 121.
#include <iostream.h> void main(){ int num,num_i,n; for(num=1;num<=1000;num++){ num_i=0; n=num; while(n>=10){ num_i=num_i*10+n%10; n/=10; } num_i=num_i*10+n; if(num_i==num) cout<<num<<"\t"; } }
Ejemplo 17 :
Programa que calcula el producto de dos nmeros enteros positivos mediante el "algoritmo ruso del producto". El algoritmo consiste en duplicar el primer factor y tomar la parte entera del cociente del segundo factor entre 2, si el segundo factor es impar se acumula el primer factor donde se va obtener el resultado. El proceso termina cuando el segundo factor se hace CERO. por ejemplo para multiplicar 30 por 12:
segundo factor 12 6 3 1 0 acumulador 0 0 120 360 360
primer factor 30 60 120 240 480
#include <iostream.h> void main(){ int f1,f2,producto=0; cout << "Ingrese dos numeros: "; cin >> f1 >> f2; while(f2){ if(f2 % 2) producto+=f1;
} cout << "Producto=" << producto<<endl;
f1*=2; f2/=2;
Ejemplo 18 :
Programa que visualiza el cuadrado mgico de orden impar n, comprendido entre 3 y 17. Un cuadrado mgico se compone de nmeros enteros comprendidos entre 1 y n2. La suma de los nmeros que figura en cada lnea, cada columna y cada diagonal son idnticas.
Regla de construccin: El nmero 1 se coloca en la casilla central de la primera fila. Cada nmero siguiente se coloca en la fila anterior y columna siguiente. Despus de ubicar un nmero mltiplo de N no se aplica la regla anterior, sino se coloca en la fila siguiente y misma columna. Se considera que la fila anterior a la primera es la ultima, y la columna posterior a la ultima es la primera.
17 23 4 10 11
#include <iostream.h> void main(){ int i,n,x,y; do{
24 5 6 12 18
1 7 13 19 25
8 14 20 21 2
15 16 22 3 9
cout<<"Dimensin impar y <=17:"; cin>>n; } while(n % 2==0 || n>17 || n<0); clrscr(); i=0; x=n / 2+1; y=1; while(i<n*n){ i++; gotoxy(5*x,y); cout<<i; if(i % n){ if(y==1) y=n; else y--; if(x==n) x=1; else x++; } else y++; if(x>n) x=1;
if(y<1) y=n; } }
Ejemplo 19 :
Programa donde se ingresan los tres lados de un tringulo y determina el tipo de tringulo.
#include <iostream.h> #include <math.h> #define ERROR 0.1 void main(){ float a,b,c,p; cout <<"Ingrese los lados: "; cin >> a >> b >> c; if(a<b+c && b<a+c && c<a+b){ cout << "El tringulo es "; if(a==b && b==c) cout << "equiltero"; else { if (a==b || a==c || b==c) cout<<"issceles"; else cout<<"escaleno"; if(abs(a*a-(b*b+c*c))<=ERROR|| abs(b*b-(a*a+c*c))<=ERROR|| abs(c*c-(a*a+b*b))<=ERROR) cout<<" y rectngulo \n"; else cout<<"\n"; } } else { cout<< "No forman un tringulo"; } cout<<endl;
GamarraMorenoADJ 61
CAPITULO 7 SUBPROGRAMAS
7.1. SUBPROGRAMAS O SUBRUTINAS
Un subprograma es un conjunto de sentencias cuya ejecucin se invoca mediante su nombre. En la mayora de los lenguajes de programacin se dividen en: procedimientos y funciones, pero en el lenguaje C++ slo esta permitido las funciones. Al conjunto de subprogramas que vienen definidos en las libreras del compilador, se les conoce como subprogramas del sistema. Los programadores pueden crear sus propios subprogramas segn sean sus necesidades, a estos se les conoce como subprogramas definidos por el usuario. Este capitulo, trata principalmente sobre las tcnicas utilizadas en la construccin de funciones y sobre las funciones definidas por el usuario.
7.2. CUNDO UTILIZAR UN SUBPROGRAMA?

Existen dos razones importantes porque utilizar estas funciones, ellas son: a) se deben
En un programa, una parte del mismo se repite varias veces o varias partes tienen sentencias muy similares. Si este es el caso las partes repetidas o similares se reemplazan por una llamada
GamarraMorenoADJ 62
al subprograma y se crea un subprograma con las sentencias repetidas o similares. b) En un programa, una parte se encarga de un trabajo especfico. Esto se consigue aplicando las tcnicas Diseo descendente y programacin modular, que se tratan ms adelante.
7.3. DISEO DESCENDENTE (TOP DOWN)

Problema
Subproblema 1 Subproblema 2 Subproblema 3
Subproblema 2.1
Subproblema 2.2
El diseo descendente, tambin es conocido como diseo TOP DOWN, consiste en dividir un problema1 en subproblemas y estos en otros subproblemas que sean fciles de solucionar. Una vez resuelto cada parte se integran para obtener la solucin de todo el problema. En este mtodo se analiza de las caractersticas generales a caractersticas especficas (descomposicin jerrquica). A cada nivel o paso de refinamiento se le conoce como stepwise. El diseo descendente es utilizado en la solucin de problemas de gran complejidad. Para descomponer el problema, para cada subprograma se debe contestar: Qu hace? y Cmo lo hace?. Los niveles de descomposicin dependen de la complejidad del problema. Se recomienda parar la descomposicin cuando el subproblema se refiere a la solucin de algo especfico o es fcil de solucionar, el programador conforme se va familiarizando con el problema encontrar la descomposicin ptima.
7.3.1. EJEMPLO
Elaborar el diseo descendente para calcular el sueldo a pagar a un trabajador de la Empresa "Horizonte", si el trabajador percibe las siguientes bonificaciones:
1
En este caso la solucin del problema ser mediante la elaboracin del problema. GamarraMorenoADJ 63
a) b) c) d)
Por cada hora extra se le paga 25% ms que una hora normal. Bonificacin por movilidad (movil) igual a 1000. Bonificacin suplementaria (b_sup) igual al 3% del sueldo bsico (sueldo). La bonificacin total (bonif) es la suma de todas las bonificaciones que percibe. esta sujeto a los
Asimismo, el trabajador siguientes descuentos: e)
Las tardanzas y faltas se descuentan con respecto a remuneracin computable. La remuneracin computable es igual al sueldo bsico ms la suma de todas las bonificaciones excepto la bonificacin por horas extras. El total de descuentos (descuentos) se obtiene sumando todos los descuentos. ALGORITMO GENERAL
f)
I. II. III.
Ingreso de datos Clculo el sueldo a pagar Imprime boleta de pago. PRIMER REFINAMIENTO
I.
Ingreso de datos I.1. Ingreso del nombre del trabajador (nombre) y sueldo bsico (sueldo). Ingreso de das de faltas (dias_falta) y minutos de tardanzas (minutos). Ingreso de (h_extras). horas extras
I.2.
I.3. II.
Clculo el sueldo a pagar II.1. Clculo (bonif) de bonificaciones

GamarraMorenoADJ 64
II.2. Clculo de (descuentos)
descuentos
II.3. s_neto=sueldo+bonif+descuentos III. Imprimir boleta de pago. SEGUNDO REFINAMIENTO II.1. CALCULO DE BONIFICACIONES: II.1.1. Pago por horas (p_h_extras): extras
1.25*h_extras*sueldo/30/8 Para incrementar 25% a X, es suficiente multiplicar a la cantidad por 1.25 porque 100% de X + 25% de X es 125% de X que a su vez es igual a 1.25*X. El pago por una hora normal es igual al resultado de sueldo/30/8, donde sueldo es el sueldo bsico. Note que el sueldo bsico corresponde al mes y esta dividido entre 30 das que tiene el mes y este resultado es dividido entre 8 que es la cantidad de horas que se trabaja durante un da. II.1.2. II.1.3. II.1.4. II.1.5. movil=10000 b_sup=0.03*sueldo bonif=movil+b_sup+p_h_extras Remuneracin (r_computable): sueldo+movil+b_sup II.2. CALCULO DE DESCUENTOS: II.2.1. r_minima=sueldo+bonif
GamarraMorenoADJ 65
computable
II.2.2.
faltas=r_computable/30* dias_falta. Para obtener el descuento por falta: la remuneracin computable se divide entre la cantidad de das que tiene el mes, note que el mes comercial tiene 30 das.
II.2.3.
tardanzas=r_computable/ 30/8/60*minutos. Para obtener el descuento por la tardanza: la remuneracin computable se divide secuencialmente entre la cantidad de das que tiene el mes, entre la cantidad de horas trabajadas por da y entre la cantidad de minutos que tiene una hora. descuentos=faltas+tardanzas
II.2.4.
Aqu paramos la descomposicin del problema.
7.4. PROGRAMACIN MODULAR

La programacin modular se toma muchas veces como complemento del diseo descendente. La programacin modular consiste en dividir un programa en mdulos independientes, buscando un slo punto de entrada y uno de salida. Como complemento del diseo descendente proporciona mdulos funcionales (todos los elementos contribuyen a una sola tarea) y estn organizados en niveles de jerarqua.
7.4.1. MODULO
Es una parte de un programa (subprograma) que cumple con una funcin especifica, para un usuario un modulo debe ser como una caja negra donde ingrese datos y obtiene resultados, sin importarle cuales fueron las tareas que hizo el mdulo para lograr su propsito.
GamarraMorenoADJ 66
Un mdulo en el Lenguaje de Programacin Pascal o en Foxpro puede ser un procedimiento o una funcin y en Lenguaje C++ es una funcin. En resumen, un mdulo puede ser un subprograma.
7.4.2. CRITERIOS A CONSIDERAR EN PROGRAMACIN MODULAR

a) b) c) Debe tener una sola entrada y una sola salida. Debe realizar un trabajo especfico. Debe tener la mxima independencia y la mxima cohesin (todo lo suficiente para realizar su trabajo). Debe estar separados las funciones entrada y/o salida de las de clculo. de
d)
7.4.3. FASES DE LA PROGRAMACIN MODULAR

a) b) c) d) Dividir el problema utilizando el diseo descendente (TOP-DOWN). Analizar los parmetros a ser enviados y ha ser devueltos. Disear el mdulo. Montaje en el sistema en forma ascendente (BOTTOM-UP).
7.5. DEFINICIN DE FUNCIONES
Se compone de la cabecera de la funcin (prototipo de una funcin) seguido por el cuerpo de la funcin. Cuyo formato es:
<Tipo> Nombre_f (t1 p1, t2 p2,,tk pk) { <cuerpo de la funcin> }
Donde: <tipo> Es el tipo de valor que ha de devolver la funcin. Si la

GamarraMorenoADJ 67
funcin no retorna ningn valor entonces el tipo es void. Nombre_f t1, t2, , tk p1, p2, .., pk Es el nombre de la funcin. Son los tipos de datos de los parmetros. Son los parmetros. Un parmetro es una variable utilizado para enviar y/o recibir datos.
Si la funcin devuelve un valor debe utilizarse la sentencia return cuyo formato es:
return (expresin)
return puede situarse en cualquier punto del cuerpo de la funcin y provoca la salida inmediata de la funcin retornando el valor evaluado en la expresin. Si se omite la expresin, return retorna a la funcin que lo llamo y no devuelve ningn valor.
7.5.1. DECLARACIN DE PROTOTIPOS

El prototipo de una funcin tiene por finalidad indicar al compilador el tipo de valor que devuelve, as como el nmero y tipo de sus parmetros. En C++ por cada funcin definida por el usuario es necesario declarar su prototipo. Uno de sus formatos es:
<Tipo> Nombre_f (t1 p1, t2 p2,,tk pk);
o
<Tipo> Nombre_f (t1,t2,,tk);
Donde: <tipo> Es el tipo de valor que ha de devolver la funcin. Si la funcin no retorna ningn valor entonces el tipo es void. Es el nombre funcin. de la
Nombre_f
GamarraMorenoADJ 68
t1, t2, , tk p1, p2, .., pk OBSERVACIONES: a)
Son los tipos de datos de los parmetros. Son los parmetros.
Si en la definicin o el prototipo de una funcin se omite el tipo de dato que retorna entonces por defecto el compilador asume el tipo int. Si la funcin no retorna un valor se define como tipo retornado al tipo void y la funcin no necesita usar la sentencia return. Si no se usa la sentencia return la funcin se ejecuta todo el cuerpo de la funcin y retorna a la siguiente lnea de donde fue llamado.
b)
c)
7.5.2. LLAMADA A UNA FUNCIN:

En cualquier lugar del programa se puede llamar a la funcin, incluso puede llamarse a si mismo. Para llamar a una funcin se utiliza el siguiente formato:
Nombre_f(E1, E2,, Ek)
Donde: E1, E2, ,Ek Son expresiones que proporcionan los valores a los parmetros, en el orden indicado.
La lista de parmetros debe estar de acuerdo al tipo y cantidad de parmetros definidos en la funcin. El primer parmetro de la lista corresponde al primer parmetro de la definicin, el segundo parmetro de la lista al segundo parmetro de la definicin, as sucesivamente. Ejemplo 1 : Programa que imprime los nmeros primos que existen desde 1 hasta 100.
GamarraMorenoADJ 69
#include <iostream.h> //declaracion de prototipos primo(int n); void main(){ //funcin principal int n; for(n=1;n<=100;n++) if (primo(n)) cout<<n<<" es primo \n"; } primo(int n){ int r,d=2,flag=1/*se supone que es primo*/; if (n==1) return 1; if (n==2) return 1; while (1){ r=n%d;//halla el resto de n entre d if(r==0){ flag=0; break; } if ((n-1)==d) break; d++; } if (flag) return 1; else return 0;
Ejemplo 2
Programa que utiliza a la funcin hipotenusa para calcular la hipotenusa de un tringulo rectngulo si se proporcionan como parmetros los catetos.
#include <iostream.h> #include <math.h> float hipotenusa(float ,float ); void main(){ float x,y,h; cout<<"ingrese los 2 catetos ";cin>>x>>y; h= hipotenusa(x,y); cout<<"hipotenusa= "<<h<<endl;
float hipotenusa(float a,float b){ float hi; hi=sqrt(a*a+b*b); return (hi); }
GamarraMorenoADJ 70
7.5.3. PARMETROS POR VALOR

Hasta al momento solo se han utilizado parmetros por valor. Se dice que los parmetros son pasados por valor si estos son usados para suministrar datos de entrada. Esto significa que los cambios que se hacen a las variables utilizadas como parmetros que son pasados por valor solo pueden cambiar su valor momentneamente dentro de la funcin y a la salida de la funcin recuperan su valor de entrada. Cuando un parmetro es pasado por valor la funcin copia su valor y lo utiliza dentro de la funcin. Un parmetro pasado por valor puede ser una constante, una expresin, una llamada a una funcin o una variable.
7.5.4. PARMETROS POR REFERENCIA

Se dice que los parmetros son pasados por referencia si estos se utilizan para suministrar datos de entrada y/o salida indistintamente. Esto significa que la funcin puede alterar el valor de entrada de las variables que son pasados por referencia. Por lo tanto, si la funcin debe modificar el valor de la variable pasada como parmetro y que esta modificacin retorne a la funcin llamadora, entonces el parmetro debe ser pasado por referencia. En este mtodo, el compilador no pasa una copia del valor del argumento; en su lugar, pasa una referencia, que indica a la funcin donde existe la variable en memoria. La referencia que una funcin recibe es la direccin de la variable. Es decir, pasar un argumento o parmetro por referencia es, simplemente, indicarle al compilador que que pase la direccin del argumento. Una referencia se indica por el operador de direccin &. Un parmetro pasado por referencia siempre tiene que ser una variable.
Ejemplo
El siguiente programa intenta el valor de dos nmeros si el es mayor que el segundo, pero porque el parmetro pasado valor.
#include <iostream.h> void intercambiar(int x,int y); void main(){ int x,y;
cambiar primero fracasa es por
cout<<"ingrese 2 nmeros: ";cin>>x>>y; if (x>y) intercambiar(x,y); cout<<" x= "<<x<<" y= "<<y<<endl;
void intercambiar(int a,int b){ int aux; aux=a; a=b; b=aux; }
La corrida del programa es:

ingrese 2 nmeros: 5 3 x= 5 y= 3
El siguiente programa si logra intercambiar los valores de las dos variables. Observe su implementacin de la funcin intercambiar.
#include <iostream.h> void intercambiar(int &x,int &y); void main(){ int x,y; cout<<"ingrese 2 nmeros ";cin>>x>>y; if (x>y) intercambiar(x,y); cout<<" x= "<<x<<" y= "<<y<<endl; } void intercambiar(int &a,int &b){ int aux; aux=a; a=b; b=aux; }
La corrida del programa es:

ingrese 2 nmeros: x= 3 y= 5
5 3
GamarraMorenoADJ 72
7.5.5. MBITO DE UNA VARIABLE

El mbito de una variable son los lugares donde una variable es conocida. En C++ el mbito esta definido por los bloques y la ubicacin de las declaraciones. Ejemplo : Programa que permite sumar los n nmeros ingresados.
#include <iostream.h> void main(){ int n; cout<<Nro de elementos : ; cin>>n; if (n>0){ int i,num,s=0; for(i=1;i<=n;i++){ cout<<Elemento <<i<<: ; cin>>num; s+=num; } cout<<"La suma es :"<<s<<endl; } else cout<<"Error: Sin ingresos"; }
En el programa se ha definido una variable "n" de tipo int, que puede ser utilizada por cualquier bloque de la funcin main(), pero en el siguiente bloque:
if (n>0){ int i,num,s=0; for(i=1;i<=n;i++){ cout<<Elemento<<i<<: ; cin>>num; s+=num; } cout<<"La suma es :"<<s; } else cout<<"Error: Sin ingresos";
se ha definido tres variables: i, num y s; que slo pueden ser usadas dentro de este bloque. En conclusin el mbito de "n" es toda la funcin main(), el mbito de i, num y s es slo el bloque de la sentencia if.
GamarraMorenoADJ 73
7.5.6. VARIABLES LOCALES

Se dice que un variable es local cuando slo es conocido en un bloque determinado. Un bloque comienza con { y termina con }.
7.5.7. PRAMETROS FORMALES Y REALES

Los parmetros formales son variables locales usadas para definir de la funcin; por ejemplo: en la funcin mximo los parmetros formales son las variables a, b y c.
#include <iostream.h> int maximo(int a,int b,int c); void main(){ int n1,n2,n3; cout<<"Ingrese tres nmeros:"; cin>>n1>>n2>>n3; cout<<"Mximo : " << maximo(n1,n2,n3); } int maximo(int a,int b,int c) { int max; if(a>b)max=a; else max=b; if(c>max) max=c; return max; }
Los parmetros reales son los datos que son enviados a la funcin y son utilizados en la llamada a la funcin; por ejemplo: en la llamada a la funcin mximo los parmetros reales son n1, n2 y n3. Los parmetros reales tienen que coincidir con el nmero y el tipo de los parmetros formales, correspondiendo el primer parmetro real al primer parmetro formal, el segundo parmetro real al segundo parmetro formal, as sucesivamente.
7.5.8. VARIABLES GLOBALES

Se dice que una variable es global cuando es conocido en ms de dos funciones. Es
recomendable minimizar el uso de variables globales porque accidentalmente puede ser modificado por una funcin produciendo resultados inesperados. Ejemplo : El programa solicita un ngulo en grados sexagesimales en forma decimal, luego llama a la funcin radian() que convierte el ngulo a radianes y llama a la funcin sexag() que convierte la forma decimal del ngulo a grados, minutos y segundos sexagesimales. Funcin radian() Para la conversion siguiente relacion: se utiliza la
radianes=sexagesimales*(3.1416/180) Funcin sexag() Se separa la parte entera y la parte fraccionaria del ngulo que esta forma decimal. La parte grados. entera corresponde a los
Multiplicando la parte fraccionaria del ngulo por 60. Y separando en parte entera y fraccionaria de este producto, la parte entera corresponde a los minutos. Los segundos se obtienen multiplicando la parte fraccionaria obtenida en paso anterior por 60. Para el angulo 48.789 en sexagesimales: Separando el ngulo, parte entera 48 y parte fraccionaria 0.789. Grados=48
Multiplicando la parte fraccionaria por 60: 0.789*60=47.34; separando el resultado en parte entera (47) y parte fraccionaria (0.34). Minutos=47 Multiplicando la parte fraccionaria (0.34) por 60: 0.34*60=20.4 Segundos=20.4 Por lo tanto 48.789 es igual a 48 47' 20.4"
#include <math.h> #include <iostream.h> void sexag(void); void radian(void); // Variable global float angulo; void main(){ // Variables locales a main() char resp; do{ cout<<"Angulo (en sexagesimales): "; cin>>angulo; radian(); sexag(); cout<<"Continuar? (S/N)\n"; cin>>resp; }while(resp!='N' && resp!='n'); } void radian(void) { // Variable local a radian() float rad; rad=3.1416/180*angulo; cout<<"En radianes es:<<rad<<\n; } void sexag(void) { // Variables locales a sexag() double frac,grad,min,seg; frac=modf(angulo,&grad); frac=modf(frac*60,&min); seg=frac*60; cout<<Tambien en Sexageximal es:\n; cout<<Grados :<<grad<<\n; cout<<Minutos :<<min<<\n;
cout<<Segundos:<<seg<<\n; }

Ejemplo 1 : Programa que halla la hipotenusa de un tringulo.
#include <iostream.h> #include <math.h> void hipotenusa(float a,float b,float &hi); main(){ float x,y,h; cout<<"ingrese los 2 catetos ";cin>>x>>y; hipotenusa(x,y,h); cout<<" hipotenusa= "<<h<<endl; } // a y b son parmetros pasados por valor // y hi es pasado por referencia void hipotenusa(float a,float b,float &hi) { hi=sqrt(a*a+b*b); }
Ejemplo 2
La funcin distancia() calcula la distancia de dos puntos cuyas coordenadas son (x1,y1) y (x2,y2). La distancia es igual a:
( x1 x 2 ) 2 + ( x1 x 2 ) 2
#include <iostream.h> #include <math.h> double distancia(double,double,double,double); main(){ double a1,a2,b1,b2; cout<<Coordenadas del primer punto :; cin>>a1>>b1; cout<<Coordenadas del segundo punto :; cin>>a2>>b2; cout<<La distancia es: ; cout<<distancia(a1,b1,a2,b2)<<endl;
} double distancia(double x1, double y1, double x2, double y2){ double x; x=sqrt(pow(x1-x2,2)+pow(y1-y2,2)); return(x); }
GamarraMorenoADJ 77
Ejemplo 3
Programa que llama a la funcin raiz_cub e imprime la raz cbica de los nmeros del 1 al 10. La funcin raiz_cub() calcula la raz cbica de un nmero entero y a esta a su vez llama a la funcin abs que se encarga de devolver el valor absoluto de un nmero de tipo double. Algoritmo Newton-Raphson para calcular la raz cubica de n:
Hacer x=n/10 Mientras valor_absoluto(x*x*x-n)>0.0001 hacer
x = x+
n x3 3x 2
x es el valor de la raz cbica de "n" double raiz_cub(double); double abs(double); #include<iostream.h> #include<math.h> double abs(double); /* Funcin Principal */ void main(){ double i; cout<<NUMERO\t\tR.CUBICA\n; for(i=1;i<=10;i++) cout<<i<<\t\t<<raiz_cub(i)<<\n; } double raiz_cub(double n){ double x; x=n/10.0; while(abs(x*x*x-n)>0.0001) x=x+(n-x*x*x)/(3.0*x*x); return x; } double abs(double n){ if (n>=0) return n; else return -n; }
Ejemplo 4
Programa que permita verificar si una fecha (dd/mm/aaaa) es correcta

#include <stdio.h> int bisiesto(int); int fechaok(int,int,int); void main(){
GamarraMorenoADJ 78
int aa,mm,dd; do{ printf("Fecha (dd/mm/aaaa)"); scanf("%d/%d/%d",&dd,&mm,&aa); }while(fechaok(dd,mm,aa)!=0); printf("Error Fecha: %d/%d/%d\n",dd,mm,aa);
int bisiesto(int anno) { int si=0; if(anno % 4==0){ si=1; if(anno%100==0&&anno%400!=400) si=0; } return si; } int fechaok(int dia,int mes,int anno) { int ok=0; switch(mes){ case 1: case 3: case 5: case 7: case 8: case 10: case 12:if(dia>=1&&dia<=31) ok=1; break; case 4: case 6: case 9: case 11:if(dia>=1&&dia<=30) ok=1; break; case 2: if(bisiesto(anno)==1) if(dia>=1&&dia<=29) ok=1; else if(dia>=1&&dia<=28) ok=1; break; } return(ok); }
Ejemplo 5
Programa que lee tres ordena ascendentemente.

#include <iostream.h> void cambiar(int &a,int &b); void main(){ int n1,n2,n3;
nmeros
los
cout<<"Ingrese tres nmeros :"; cin>>n1>>n2>>n3; if(n1>n2) cambiar(n1,n2); if(n2>n3) cambiar(n2,n3); if(n1>n2) cambiar(n1,n2); cout<<Ordenados:<<n1<<\t<<n2<<\t<<n3; cout<<endl; } void cambiar(int &a,int &b){ int t; t=a;
a=b; b=t;
Ejemplo 6
Programa que lee un nmero en base de 2 al 9 y lo convierte a otra base de 2 al 9.

#include <iostream.h> #include <stdio.h> long long long long cnto10(long numero,int base); c10ton(long numero,int base); ingbasen(int base); cxtoy(long numero,int base1,int base2);
void main(){ long n; int b1,b2; printf("Base origen : "); scanf(%d,b1); cout<<"Base destino : "; scanf(%d,b2); n=ingbasen(b1); if(n){ n=cxtoy(n,b1,b2); printf("Numero convertido %d\n",n); }
long ingbasen(int base){ long n; char c,car; if (base>=2 && base<=10){ car=48+base; n=0; printf("Numero en base %d :",base); do{ do c=getch(); while((c<'0' || c>=car)&&c!='\r'); //printf(%c,c); if(c!='\r') n=n*10+c-48; }while(c!='\r'); printf("\n"); return n; } else{ printf(Base mayor que 9 o base ); printf(menor que 2 no esta permitido"); return 0; } } long cnto10(long numero,int base){ long n=0,factor=1,res;
while(numero>=10){ res=numero % 10; numero/=10; n+=(res*factor); factor*=base; } n+=(numero*factor); return n; } long c10ton(long numero,int base){ long n=0,factor=1,res; while(numero>=base){ res=numero % base; numero/=base; n+=(res*factor); factor*=10; } n+=(numero*factor); return n;
long cxtoy(long numero,int base1,int base2){ numero=cnto10(numero,base1); numero=c10ton(numero,base2); return numero; }
7.7. FUNCIONES DEL SISTEMA

Las funciones proporcionadas por las libreras del lenguaje C++ utilizan los archivos de cabecera (archivos con extensin H) el cual es insertado al programa con la directiva #include.
7.7.1. UTILIZACION DE LA DIRECTIVA #include

Esta directiva hace que le compilador incluya el archivo cabecera en el cdigo fuente del programa, su extensin es h (de header, cabecera en ingls). Cuyo formatos son: #include <ruta\nomfich.h>. Hace que el archivo cabecera sea buscado slo ruta indicada, si lo encuentra lo inserta, caso contrario genera un mensaje de error. #include <nomfich.h>.- Hace que cabecera sea buscado en los especificado para los archivos generalmente es el directorio
el archivo directorio cabeceras, es llamado
GamarraMorenoADJ 81
include. Si lo encuentra inserta; caso contrario genera un mensaje de error. #include "ruta\nomfich.h".- Hace que el archivo cabecera sea buscado secuencialamente en: la ruta especificada, en el directorio activo, en el directorio especificado para las cabeceras. El archivo cabecera que es encontrado primero es insertado y finaliza la bsqueda, sino lo encuentra en ninguno de los directorios genera un mensaje de error. Para llamar a una funcin de la librera del c++ es necesario utilizar la directiva #include con el nombre del archivo de la cabecera que le corresponde. Para las funciones matemticas se usa #include <math.h>, para las funciones de cadena se usa #include <string.h>, etc. Para mayor informacin recurra al manual del lenguaje de programacin.
GamarraMorenoADJ 82
CAPITULO 8 ESTRUCTURA DE DATOS: ARREGLOS

En los captulos anteriores se ha definido y utilizado los tipos de datos fundamentales con los cuales se poda manejar datos enteros, de punto flotante o carcter. Imagnese ahora la necesidad de obtener el promedio de la temperatura ambiente de esta semana en la ciudad. Si usamos tipos de datos fundamentales necesitamos por lo menos definir 7 variables; pero si la necesidad es conocer el promedio de la temperatura ambiente de todo el mes, tendramos que definir por lo menos 30 variables. Ampliando la situacin anterior supongamos el caso en que se necesite conocer el promedio de la temperatura ambiente durante 5 aos (aproximadamente 1825 das), y de acuerdo al razonamiento anterior, tendramos que utilizar una variable por da para lo cual se necesita definir 1825 variables. Ampliando su imaginacin suponga que usted comienza con la definicin de las variables dentro de su programa, utilizar demasiado tiempo en definir y escribir y utilizar sus variables; por supuesto esto es inadmisible. La estructura de datos arreglo solucionara el caso anterior. Un arreglo (array) es una coleccin de variables del mismo tipo. Usted puede trabajar con un arreglo de enteros, un arreglo con valores de punto flotante, o un arreglo de caracteres.
GamarraMorenoADJ 83
8.1. ARREGLOS UNIDIMENSIONALES: VECTORES

Un arreglo unidimensional, o simplemente un arreglo, de N variables de algn tipo de dato se declara en la forma: Tipo_de_dato identificador[N]; Donde: Tipo_de_dato : Es el tipo de dato usado en el arreglo. Identificador: Es el nombre del arreglo. N : Es el tamao del arreglo o la cantidad de elementos(variables) que se utilizar en el arreglo.
Ejemplo: int A[100]
El arreglo A consiste de la coleccin de variables A[0],A[99] de tipo int, que son referidas por el nombre del arreglo y el correspondiente subndice entre corchetes. 100 es la dimensin del arreglo cantidad de elementos- y debe ser un entero positivo constante. El arreglo A se puede representar:
A[0]
A[1]
A[2]
A[3]
...
A[96]
A[97]
A[98]
A[99]
Los arreglos en C++ comienzan con el ndice cero, siendo el ltimo ndice unidad menor al tamao del arreglo (N-1).
GamarraMorenoADJ 84
Indicaciones sobre arreglos: Los datos de las variables componentes A[0],.., A[99], se almacenan unos a continuacin de otros. Para acceder a un elemento del arreglo utilizar el siguiente formato Identificador [indce del arreglo] Ejemplo: En el arreglo A, para almacenar el valor ndice 3 usar: A[3]=5; 5 en el
Para escribir usar:
el
valor
almacenado
anteriormente
cout<<A[3]; El nombre del arreglo es igual a la direccin de la primera variable del arreglo A[0]. As A tiene el valor &A[0]. La direccin de cada componente A[i], dada por &A[i], tambin puede ser expresada por A+i
GamarraMorenoADJ 85
Ejemplo 1
Programa que lee e imprime el contenido de un vector.

#include <iostream.h> #define N 5 // N es la cantidad de elementos // del arreglo void main() { int A[N]; // definimos el arreglo A //de enteros para 5 elementos int i; //ndice del arreglo //lectura del vector for(i=0;i<N;i++) { cout<<"Ingrese elemento : "; cin>>A[i]; } //imprime el vector cout<<"El contenido del arreglo es :\n"; for(i=0;i<N;i++) cout<<A[i]<<"\n";
Explicacin: Para la lectura del vector se debe recorrer cada una de las celdas por lo cual se hace una referencia a cada celda a travs de sus ndices (se usa la variable i), que toman valores de 0 a 4 a travs de la sentencia for. Para la impresin de los elementos se debe recorrer tambin cada una de las celdas en forma similar a la lectura.
Ejemplo 2
Programa que lee el contenido de un arreglo e imprime el promedio de sus elementos.

#include <iostream.h> #define N 5 //N es la cantidad de elementos //del arreglo void main() { int A[N]; // definimos el arreglo A de // enteros para 5 elementos int i; //ndice del arreglo float prom;int s=0; // lee el vector y a la vez calcula // la suma de los elementos for(i=0;i<N;i++) { cout<<"Ingrese elemento : "; cin>>A[i]; s=s+A[i]; // s acumula la suma de // los elementos
GamarraMorenoADJ 86
} // calcula e imprime promedio prom=1.0*s/N; // multiplicar por 1.0 para //obtener la divisin como //punto flotante cout<<"El promedio del vector es : "<<prom; cout<<endl;
Explicacin: En la lectura del vector se agrega el acumulador s para guardar la suma de los elementos del arreglo. Para hallar el promedio se divide la suma acumulada en s entre la constante N; pero se debe multiplicar por 1.0 para obtener una divisin en punto flotante.
Ejemplo 3
Programa que lee el contenido de un arreglo y determina el mayor y el menor elemento y cuantas veces se repiten ambos.
#include <iostream.h> #define N 10 // N es la cantidad de elementos // del arreglo void leer_vector(int V[N]); void hallar_mayor_y_menor(int &may,int &men); int existe(int V[N], int valor); V[N], int
void main() { int A[N];// definimos el arreglo A de enteros // para 10 elementos int ma,me; // ma es el mayor elemento // me es el menor elemento leer_vector(A); hallar_mayor_y_menor(A,ma,me); cout<<"El mayor elemento es "<<ma; cout<<" y existe "<<existe(A,ma)<<" veces\n"; cout<<"El menor elemento es "<<me; cout<<" y existe "<<existe(A,me)<<" veces\n"; } void leer_vector(int V[N]) { // lee el vector int i; //indice del arreglo for(i=0;i<N;i++) { cout<<"Ingrese elemento : "; cin>>V[i];} }
GamarraMorenoADJ 87
// funcin que devuelve el mayor y el menor // para numeros entre -10000 y 10000 void hallar_mayor_y_menor(int V[N], int &may,int &men) { int i; //indice del arreglo may=-10000; // inicializamos con un valor // pequeo para el mayor men= 10000; // inicializamos con un valor // grande para el menor for(i=0;i<N;i++) { if (may<V[i]) //si el mayor es menor que //algn elemento may=V[i]; // del arreglo se toma ese //elemento como mayor if (men>V[i]) //si el menor es mayor que // algn elemento men=V[i]; // del arreglo se toma ese // elemento como menor } }// fin de la funcion hallar_mayor_y_menor // funcin que calcula cuantas veces existe un // valor en un vector int existe(int V[N], int valor) { int i,veces=0;// veces almacena la cantidad // de veces que existe //el valor buscado for(i=0;i<N;i++) if (valor==V[i]) //si el valor es igual a //algn elemento del veces++; //arreglo se incrementa // veces return(veces); } Explicacin: Para determinar el mayor y menor elemento del vector utilizamos las variables ma que contiene al mayor elemento y me que contiene al menor elemento. En la funcin main() se realiza la lectura del contenido del vector a travs de la funcin leer_vector(A), donde se enva la variable arreglo A como un parmetro por referencia. Para calcular el mayor y menor elemento usamos la funcin hallar_mayor_y_menor(A, ma, me) que enva el arreglo A y las variables enteras ma y me, siendo estas dos ltimas las que deben obtener el mayor y menor elemento al retornar del llamado a est funcin. Adems se enva el arreglo A y un valor a la funcin existe que permitir obtener cuantas veces se repite el valor en el vector. La funcin leer_vector(int V[N]), recepciona el arreglo A a travs de la variable arreglo V
como un parmetro por referencia, debe notarse que no se necesita &, para tratar a V como un parmetro por referencia; porque es un arreglo y basta mencionar su nombre para tener la direccin del primer elemento. La lectura de los elementos se realiza en la instruccin for para lo cual utilizamos el ndice del arreglo i definido como una variable local. En la funcin void hallar_mayor_y_menor(int V[N], int &may, int &men), la variable V recepciona al arreglo A, la variable may recibe a ma y men recibe a me como parmetros por referencia por lo que debe de utilizarse el &. En la funcin inicializamos may con 10000 para que tenga un valor pequeo de tal forma que se compare con los elementos del arreglo y si algn valor es mayor que may se almacena este valor en may. Al final del recorrido del vector, may almacena al mayor elemento. De la misma forma inicializamos men con 10000 para que tenga un valor grande de tal forma que se compare con los elementos del arreglo y si algn valor es menor que men se almacena este valor en men. Al final del recorrido del vector, men almacena al menor elemento. Los valores del mayor y menor se devuelven a travs de may y men que sern los mismos que ma y me respectivamente porque han sido pasados como referencia. En la funcin int existe(int V[N], int valor),V recibe al vector y la variable valor es el valor buscado. Para encontrar cuantas veces existe el valor buscado se compara la variable valor con cada elemento del arreglo incrementando el contador veces si son iguales.
Ejemplo 4
Programa que permite ingresar los n elementos de un arreglo unidimensional sin que se repita ningn elemento. El arreglo almacena datos enteros y de dimensin MAX (definido como constante).
#include <iostream.h> #define MAX 20 int ingreso(int a[MAX]); void reporte(int a[MAX],int n); int repetido(int a[MAX],int n,int x); void main(){ int x=0,vector[MAX]; x=ingreso(vector); reporte(vector,x);
GamarraMorenoADJ 89
int ingreso(int a[MAX]){ int i,cant; do{ cout<<"Cuantos elementos : "; cin>>cant; } while(cant<1 || cant>MAX); for(i=0;cant>i;i++){ do{ cout<<"elemento "<<i<<":"; cin>>a[i]; }while(repetido(a,i,a[i])); } return cant; } int repetido(int a[MAX],int n,int x){ int i,sw=0; for(i=0;n>i;i++) if(a[i]==x){ sw=1; break; } return sw;
void reporte(int a[MAX],int n){ int i; if(n){ for(i=0;n>i;i++) cout<<a[i]<<" "; cout<<"\n"; } else cout<<"Esta Vacio\n"; }
8.2. ARREGLOS MATRICES
BIDIMENSIONALES:
TABLAS
Es un conjunto de elementos, todos del mismo tipo, y se necesita especificar dos subndices para poder identificar a cada elemento del arreglo. La representacin de un arreglo bidimensional utiliza filas y columnas como se ilustra en la siguiente figura: Representamos el arreglo bidimensional M que tiene 4 filas y 5 columnas.
GamarraMorenoADJ 90
Columna 0
Columna 1
Columna 2
Columna 3
Columna 4
Fila 0 Fila 1 Fila 2 Fila 3
M[0][0] M[1][0] M[2][0] M[3][0]
M[0][1] M[1][1] M[2][1] M[3][1]
M[0][2] M[1][2] M[2][2] M[3][2]
M[0][3] M[1][3] M[2][3] M[3][3]
M[0][4] M[1][4] M[2][4] M[3][4]
En las celdas del arreglo se muestra el uso de los subndices, donde el primer subndice representa a la fila y el segundo subndice representa a la columna y M es el nombre del arreglo. Para acceder a un elemento del arreglo utilizar el siguiente formato: Identificador [fila][columna] Ejemplo: En el arreglo M, para almacenar el valor 5 en la fila 2 y la columna 3 usar: M[2][3]=5;
Para escribir usar:
el
valor
almacenado
anteriormente
Cout<< M[2][3];
Para almacenar/recuperar los elementos de un arreglo bidimensional tenemos dos formas:
GamarraMorenoADJ 91
Recorrido por filas: M[0][0] M[1][0] M[0][1] M[1][1] M[0][2] M[1][2] M[0][3] M[1][3]
Recorrido por columnas: M[0][0] M[1][0] M[0][1] M[1][1] M[0][2] M[1][2] M[0][3] M[1][3]
Ejemplo1
Programa que lee e imprime el contenido de un arreglo bidimensional.

#include <iostream.h> #define NF 2 //cant. de filas #define NC 3 //cant. de columnas void leer(int m[NF][NC]); void escribir(int m[NF][NC]); void main() { int a[NF][NC];//arreglo bidimensional leer(a); escribir(a); } void leer(int m[NF][NC]) { int f,c; for(f=0;f<NF;f++) for(c=0;c<NC;c++) { cout<<"ingrese elemento : "; cin>>m[f][c]; } } void escribir(int m[NF][NC]) { int f,c; for(f=0;f<NF;f++) { for(c=0;c<NC;c++) cout<<m[f][c]<<" "; cout<<"\n"; } }
GamarraMorenoADJ 92
Ejemplo 2
Programa que almacena en un arreglo el cuadrado latino de orden "N". Un cuadrado latino de orden "N" es una matriz cuadrada en que la primera fila contiene los "N" primeros nmeros naturales y cada una de las siguientes contiene la rotacin de la fila anterior un lugar a la derecha. A continuacin se muestra un cuadrado latino de orden 4 (N = 4).
1 4 3 2 2 1 4 3 3 2 1 4 4 3 2 1
#include <iostream.h> #define max 15 //cant. max de filas y columnas void cuadrado_latino(int a[max][max],int n); void escribir(int a[max][max], int n); void main() { int a[max][max];//arreglo bidimensional para //el cuadrado latino int n; cout<<"Ingrese orden : ";cin>>n; cuadrado_latino(a,n);//almacena los valores //del cuadrado latino escribir(a,n); } void cuadrado_latino(int a[max][max],int n) { int f,c;//fila y columna respectivamente int val=1;//valor a guardar en el arreglo for(f=0;f<n;f++) { if (f>=1) val=n-(f-1);//calcula el valor inicial de //la columna cero for(c=0;c<n;c++) { a[f][c]=val; if (val==n)//si val es igual al grado n //entonces val es cero val=0; val++; //incrementa val } } } void escribir(int a[max][max], int n) { int f,c; for(f=0;f<n;f++) { for(c=0;c<n;c++) cout<<a[f][c]<<" "; cout<<"\n"; } }
GamarraMorenoADJ 93
Ejemplo 3
Programa que suma dos matrices.de 2x3.

#include <iostream.h> #define NF 2 //cant. de filas #define NC 3 //cant. de columnas void leer(int m[NF][NC]); void escribir(int m[NF][NC]); void sumar(int x[NF][NC],int y[NF][NC],int z[NF][NC]); void main() { //arreglo bidimensionales int a[NF][NC],b[NF][NC],s[NF][NC]; //lectura de las matrices leer(a);leer(b); //obtener suma en el arreglo s sumar(a,b,s); //Escribir el contenido de los arreglos cout<<"\n Las matrices leidas son:\n"; escribir(a);escribir(b); cout<<"\n La suma de las matrices es:\n"; escribir(s); } void leer(int m[NF][NC]) { int f,c; cout<<"\n ingrese elementos de la matriz:\n"; for(f=0;f<NF;f++) for(c=0;c<NC;c++) { cout<<"ingrese elemento : "; cin>>m[f][c]; } } void escribir(int m[NF][NC]) { int f,c; cout<< "\n Contenido de la matriz:\n"; for(f=0;f<NF;f++) { for(c=0;c<NC;c++) cout<<m[f][c]<<" "; cout<<"\n"; } } void sumar(int x[NF][NC],int z[NF][NC]) { int f,c; for(f=0;f<NF;f++) for(c=0;c<NC;c++) z[f][c]=x[f][c]+y[f][c]; } y[NF][NC],int
GamarraMorenoADJ 94
CAPITULO 9 REGISTROS
Frecuentemente en nuestras actividades diarias empleamos datos que guardan alguna relacin entre ellos, por ejemplo si soy un vendedor y tengo la necesidad de ubicar a un cliente determinado entre los tantos que pueda tener para ofrecerle algn producto, me importara determinar quin es mi cliente, lo puedo hacer a travs de su nombre, si le asign un cdigo tambin podra identificarlo a travs de este, para visitarlo necesito su direccin y si deseo llamarlo pues necesito su nmero telefnico; adicionalmente podra tambin tener otros datos relativos a este cliente, como podra ser la fecha de su cumpleaos para enviarle una tarjeta, etctera. Al juntar todos los datos de este cliente, pues se tiene un conjunto de datos de este cliente, se ha registrado a este cliente. De igual forma se puede registrar a otros clientes. Un registro es una coleccin de datos o campos (cdigo, nombre, direccin, nmero telefnico, fecha de nacimiento, etc.) acerca de una entidad (cliente), estos en conjunto pueden ser tratados como una unidad de informacin. Cada dato de un cliente (por ejemplo el nombre) es un campo. Los registros en conjunto, uno por cada cliente hace una tabla de datos de la entidad cliente. Si manejamos adicionalmente tablas de datos acerca de los vendedores, productos, etctera, tenemos una Base de Datos.
GamarraMorenoADJ 95
9.1. REPRESENTACIN DE REGISTROS

En el C++ para representar los registros empleamos en muchas ocasiones las estructuras y las uniones. La estructura es bsica para la representacin de los registros de una tabla de una base de datos y las uniones en una celda de una hoja de clculo. Una estructura a diferencia de un array o arreglo permite mantener datos de distintos tipos. As para mantener los registros acerca de los alumnos de una clase donde queramos mantener su nombre, edad en aos y talla; es necesario un arreglo de caracteres para su nombre, un dato tipo entero para su edad y un dato tipo real para su talla.
char Nombre[20]; int Edad; float talla;
Una unin permite almacenar diferentes tipos de datos en una misma posicin de memoria. Si por ejemplo tenemos cierto componente electrnico que podamos identificarlo a travs de un nmero que tiene asignado o a travs de su color (para cada color existe un equivalente numrico), entonces sera lo mismo identificarlo por su color o por su equivalente numrico (sera ilgico hacerlo por ambos); en consecuencia se puede utilizar una unin para ello, donde empleamos alternadamente el equivalente numrico o su color, pero no ambos.
9.2. ESTRUCTURAS
La estructura es una unidad que agrupa a una o ms variables del mismo tipo o de tipos diferentes. La sintaxis para crear una estructura es la siguiente struct identificador{ tipo1 miembro1; tipo2 miembro2; . . tipoN miembroN; };
GamarraMorenoADJ 96
Como se puede observar para definir una estructura disponemos de la palabra reservada struct, y entre llaves se definen todos los miembros de la estructura. Para hacer referencia a un miembro de una estructura se emplea el punto (.). Ejemplo : Desarrolle un programa que permita almacenar un registro en una estructura, acerca de un alumno de una clase donde se almacene el nombre, edad en aos y talla de este alumno. Luego el programa debe mostrar los datos de dicho alumno.
//Registra a un //estructura #include<stdio.h> struct estalumno{ char nombre[38]; int edad; float talla; }; void main() { struct estalumno alumno; printf("Ingrese el nombre: "); gets(alumno.nombre); printf("\nIngrese la edad (aos): "); scanf("%d",&alumno.edad); printf("\nIngrese la talla (metros): " ); scanf("%f",&alumno.talla); printf("\n"); printf("El alumno %s tiene ", alumno.nombre); printf(" %d aos de edad ", alumno.edad); printf(" y mide %5.2f metros\n",alumno.talla); } alumno empleando una
El lector debe advertir que a pesar de haber definido la estructura, a la variable alumno se le asigna el tipo estructura estalumno empleando la palabra struct, as tenemos:
struct estalumno alumno;
Si ingresamos los siguientes datos al programa:

Ingrese el nombre: Fidel Fernndez Ingrese la edad (aos): 20
Ingrese la talla (metros): 1.78
La salida ser:
El alumno Fidel Fernndez tiene 20 aos de edad y mide 1.78 metros.
Note que para ingresar la cadena empleamos la funcin gets(). Esta funcin permite ingresar una cadena de caracteres hasta que se ingrese el equivalente a nueva lnea (retorno de carro).
9.3. UNIONES
La unin en una misma posicin de memoria de memoria puede almacenar diferentes tipos de datos, pero en un momento dado puede ser de un solo tipo, el tamao de la unin es el mismo que se tiene para el tipo de dato mayor entre los diferentes tipos de la unin. La sintaxis para crear una unin es la siguiente union identificador{ tipo1 ide1; tipo2 ide2; . . tipoN ideN; };
Como podemos observar, para definir la unin disponemos de la palabra reservada union, y entre las llaves se definen todos los tipos alternativos de la unin. Ejemplo : Desarrolle un programa que demuestre que una unin puede manejar un solo tipo de dato a la vez. Tome como base para este programa el registro de un componente electrnico que se puede identificar a travs de un nmero que tiene asignado o a travs de su color (para cada color existe un equivalente numrico), es lo mismo identificarlo
GamarraMorenoADJ 98
por su color numrico.
por
su
equivalente
//Registra la identificacin de un //componente empleando una unin #include<stdio.h> union unicomp{ char color[20]; int numero; }; main() { union unicomp componente; printf("Ingrese color del componente: "); gets(componente.color); printf("\nColor del componente: %s", componente.color); printf("\nNmero del componente: %d", componente.numero); printf("\n\nIngrese nmero del componente: "); scanf("%d", &componente.numero); printf("\nColor del componente: %s", componente.color); printf("\nNmero del componente: %d\n", componente.numero); return 0; }
La forma de definir una unin es similar a la de una estructura. Si al programa ingresamos los siguiente datos tenemos:
Ingrese color del componente: AZUL Color del componente: AZUL Nmero del componente: 23105 Ingrese nmero del componente: 560 Color del componente: 0UL Nmero del componente: 560
A la primera peticin de ingreso acerca del color del componente respondemos con la palabra AZUL, en este caso tenemos la salida correcta para el color y en el caso del nmero obtenemos un valor no predecible. A la segunda peticin de ingreso acerca del nmero del componente respondemos con el nmero 560, ahora tenemos la salida correcta para el nmero y en el caso del color obtenemos un valor no predecible.
Esto es debido a que en un momento dado solo podemos emplear uno de los tipos propuestos para esta variable.
9.4. OPERACIONES CON ESTRUCTURAS

9.4.1. PASO DE ESTRUCTURAS A FUNCIONES
El paso de las estructuras lo podemos hacer de 2 formas, por valor y por variable (o referencia). El paso de parmetros por valor se tiene en la definicin de la funcin la siguiente forma: nom_funcion(struct tipo_estru par_var); donde nom_function es el nombre que le damos a la funcin, struct es la palabra reservada para las estructuras, tipo_estru es variable tipo estructura que hemos creado y par_valor es un parmetro que se pasa por valor. Para llamar a la funcin se aplica: nom_funcion(var_estru); donde var_estru es la variable estructura que se pasa por valor. Ejemplo : tipo
Desarrolle un programa que permita almacenar un registro en una estructura, acerca de un alumno de una clase donde se almacene el nombre, edad en aos y talla de este alumno. Luego el programa debe mostrar los datos de dicho alumno empleando para ello una funcin.
//Registra a un alumno empleando //una estructura y la pasa a //una funcin para su salida #include<stdio.h>
GamarraMorenoADJ 100
struct estalumno{ char nombre[38]; int edad; float talla; }; void impr_alu(struct estalumno cual_alu); void main() { struct estalumno alumno; printf("Ingrese el nombre: "); gets(alumno.nombre); printf("\nIngrese la edad (aos): "); scanf("%d",&alumno.edad); printf("\nIngrese la talla (metros): "); scanf("%f",&alumno.talla); impr_alu(alumno); } void impr_alu (struct estalumno cual_alu) { printf("El alumno %s",cual_alu.nombre); printf(" tiene %d",cual_alu.edad); printf(" aos de edad y "); printf("mide %5.2f",cual_alu.talla); printf(" metros\n"); }
Para el paso de parmetros por variable o referencia se tiene en la definicin de la funcin la siguiente forma: nom_funcion(struct tipo_estru &par_ref); donde nom_function es el nombre que le damos a la funcin, struct es la palabra reservada para las estructuras, tipo_estru es variable tipo estructura que hemos creado y par_ref es un parmetro que se pasa por referencia. Para llamar a la funcin se aplica: nom_funcion(var_estru); donde var_estru es la variable estructura que se pasa por valor. Ejemplo : Modifique el ejemplo anterior de manera que el almacenamiento tipo
tal del
registro funcin.
se
haga
travs
de
una
//Registra a un alumno empleando //una estructura en una funcin //y la pasa a otra funcin para su salida #include<stdio.h> struct estalumno{ char nombre[38]; int edad; float talla; }; void ingr_alu(struct estalumno &cual_alu); void impr_alu(struct estalumno cual_alu); void main() { struct estalumno alumno; ingr_alu(alumno); printf("\n\n"); impr_alu(alumno);
void ingr_alu(struct estalumno &cual_alu) { printf("Ingrese el nombre: "); gets(cual_alu.nombre); printf("\nIngrese la edad (aos): "); scanf("%d",&cual_alu.edad); printf("\nIngrese la talla (metros): "); scanf("%f",&cual_alu.talla); } void impr_alu(struct estalumno cual_alu) { printf("El alumno %s",cual_alu.nombre); printf(" tiene %d",cual_alu.edad); printf(" aos de edad y "); printf("mide %5.2f",cual_alu.talla); printf(" metros\n"); }
9.4.2. ANIDAMIENTO DE ESTRUCTURAS

El anidamiento de una estructura significa que una estructura forma parte de otra estructura.
Ejemplo
Defina un algoritmo que permita registrar la fecha y hora de nacimiento de una persona. Respecto a la fecha se desea saber el da, mes y ao de nacimiento. Sobre la hora se desea registrar la hora, los minutos y los segundos.
//Almacena fecha y hora de nacimiento //en una estructura anidada #include<iostream.h> struct estruFecha { int dia; int mes; int anno; }; struct estruTiempo { int hora; int minuto; int segundo; }; struct fechaTiempo{ struct estruFecha LaFecha; struct estruTiempo ElTiempo; }; main() { struct fechaTiempo Nacimiento; cout<<"Ingrese dia de nacimiento: "; cin>>Nacimiento.LaFecha.dia; cout<<"Ingrese mes de nacimiento: "; cin>>Nacimiento.LaFecha.mes; cout<<"Ingrese ao de nacimiento: "; cin>>Nacimiento.LaFecha.anno; cout<< "Ingrese durante que hora nacio: "; cin>>Nacimiento.ElTiempo.hora; cout<<"Cuantos minutos? "; cin>>Nacimiento.ElTiempo.minuto; cout<<"Cuantos segundos? "; cin>>Nacimiento.ElTiempo.segundo; cout<<"\n\n"; cout<< "La fecha de nacimiento es el dia " <<Nacimiento.LaFecha.dia<<"/" <<Nacimiento.LaFecha.mes<<"/" <<Nacimiento.LaFecha.anno; cout<<"\nLa hora de nacimiento es: " <<Nacimiento.ElTiempo.hora <<" horas, " <<Nacimiento.ElTiempo.minuto
<<" minutos y " <<Nacimiento.ElTiempo.segundo <<" segundos\n"; return 0;
9.5. ARREGLOS DE REGISTROS

La forma ms adecuada de aprovechar las estructuras es emplendolo dentro de arreglos Para un arreglo de estructuras, se define la variable estructura como un arreglo. As por ejemplo tenemos
struct persona { char[10] nom; float sueldo; };
main() { struct persona empleado[10]; //arreglo de estructuras elementos ............. } //empleado de 10
Se accede a un elemento del arreglo de estructuras usando el ndice del arreglo para la variable empleado y el operador punto (.)
empleado[indice].sueldo=500;
Ejemplo
Desarrolle un programa que permita leer el nombre y la edad de 10 empleado y luego imprima los datos ingresados
//Programa que lee e imprime el //contenido de un arreglo de //estructuras #include <stdio.h> #define max 10 struct datos { char nomb[20]; //nombre int edad; }; void leer(struct datos pe[max]);
void escribir(struct datos pe[max]); void main() { struct datos p[max]; leer(p); escribir(p); } void leer(struct datos pe[max]) { int i; for(i=0;i<max;i++) { flushall(); printf("Ingrese nombre:==> "); gets(pe[i].nomb); printf("Ingrese edad ==> "); scanf("%d",&pe[i].edad); } } void escribir(struct datos pe[max]) { int i; for(i=0;i<max;i++) { printf("Nombre ==> %s \n",pe[i].nomb); printf("Edad ==> %d \n",pe[i].edad); } }
Advierta como en este programa se leen los registros, como es un arreglo por defecto se tiene que el paso de parmetros es por variable o referencia.

EJEMPLO 1 : Escribir un programa que permite realizar operaciones con nmeros racionales. Un numero racional (p,q) donde p es el numerador y q 0 es el denominador.
Igualdad de nmeros racionales: (p, q) = (p, q) p q = p q Adicin en los racionales: (p, q) + (p, q) = (p q + pq , q q) Multiplicacin de racionales (p, q) (p, q) = (p p, q q)
#include <iostream.h> struct racional { int num; int den; }; void leer(struct racional &x); void escribir(struct racional x); void sumar(struct racional x, struct racional y, struct racional &su); void multiplicar(struct racional x, struct racional y, struct racional &mu); void simplificar(struct racional &s); void main(){ struct racional a,b,s,m; cout<<"ingrese primer racional\n"; leer(a); cout<<"ingrese segundo racional\n"; leer(b); sumar(a,b,s); multiplicar(a,b,m); cout<< "contenido del 1er racional \n"; escribir(a); cout<< "contenido del 2do racional \n"; escribir(b); cout<<"La suma es:\n"; escribir(s); cout<<"La multiplicacin es:\n"; escribir(m);
void leer(struct racional &x){ cout<<"ingrese numerador "; cin>>x.num; cout<<"ingrese denominador "; cin>>x.den; } void escribir(struct racional x){ if (x.num==x.den) cout<<x.num/x.den<<"\n"; else cout<<x.num<<"/"<<x.den<<"\n"; } void sumar(struct racional x, struct racional y, struct racional &su){
su.num=x.num*y.den+x.den*y.num; su.den=x.den*y.den; simplificar(su); } void multiplicar(struct racional x, struct racional y, struct racional &mu){ mu.num=x.num*y.num; mu.den=x.den*y.den; simplificar(mu); } void simplificar(struct racional &s){ int d; //d divisor comn usado // para simplificar if (s.num>s.den) d=s.num; else d=s.den; //simplifica la fraccin while(1){ if ( (s.num%d)==0 && (s.den%d)==0 ){ s.num=s.num/d; s.den=s.den/d;} else d--; if (d==2) break;//divisor = 2 } }
EJEMPLO 2
Escribir un programa que permita registrar a las personas que visitan una empresa. Se debe registrar el nombre y la edad de la persona; el da, mes y ao de la visita, as como tambin la hora, minuto y segundos en la que se realiz la visita. El programa debe mostrar luego un reporte de las visitas.
#include <stdio.h> #define max 2 struct estruFecha { int dia; int mes; int anno; }; struct estruTiempo { int hora; int minuto; int segundo; }; struct datos { char nomb[20]; //nombre
int edad; struct estruFecha LaFecha; struct estruTiempo ElTiempo; }; void leer(struct datos pe[max]); void escribir(struct datos pe[max]); void main() { struct datos p[max]; leer(p); escribir(p); } void leer(struct datos pe[max]) { int i; for(i=0;i<max;i++) { flushall(); //limpia el buffer //del teclado printf("Ingrese nombre: "); gets(pe[i].nomb); printf("Ingrese edad: "); scanf("%d",&pe[i].edad); printf("Ingrese dia: "); scanf("%d",&pe[i].LaFecha.dia); printf("Ingrese mes: "); scanf("%d",&pe[i].LaFecha.mes); printf("Ingrese ao: "); scanf("%d",&pe[i].LaFecha.anno); printf("Ingrese la hora: "); scanf("%d",&pe[i].ElTiempo.hora); printf("minutos? "); scanf("%d",&pe[i].ElTiempo.minuto); printf("segundos? "); scanf("%d",&pe[i].ElTiempo.segundo); printf("\n"); } } void escribir(struct datos pe[max]) { int i; for(i=0;i<max;i++) { printf("%s",pe[i].nomb); printf(" de %d aos \n",pe[i].edad); printf("visit la empresa el dia "); printf("%d/",pe[i].LaFecha.dia); printf("%d/",pe[i].LaFecha.mes); printf("%d\n",pe[i].LaFecha.anno); printf("a las: "); printf("%d horas, ",pe[i].ElTiempo.hora); printf("%d minutos y ",
} }
pe[i].ElTiempo.minuto); printf("%d segundos", pe[i].ElTiempo.segundo); printf("\n\n\n");
CAPITULO 10 PUNTEROS
En este captulo analizamos una de las caractersticas ms poderosas del C++, el puntero (o apuntador), que son las capacidades ms difciles de dominar. Los punteros permiten simular las llamadas por referencia (uso de parmetros por referencia), crear y manipular estructuras de datos como son las listas enlazadas, colas, pilas y rboles; utilizando la asignacin dinmica de la memoria.
10.1. CONCEPTOS BASICOS

Un puntero o apuntador es una variable que contiene la direccin de otra variable. Puesto que un puntero contiene la direccin de un objeto, se puede acceder al objeto, "indirectamente" a travs de l. Si x es una variable de tipo int, y px es un apuntador. El operador unario de direccin & devuelve la direccin de un objeto, por lo que la proposicin px = &x ; asigna la direccin de x a la variable px y se dice que px "apunta a" x. El operador & slo se puede aplicar a variables y a elementos de un arreglo.
px = &x; se puede representar de la siguiente forma:

px direc de x Variable x valor
o en forma simplificada
px Variable x valor
El operador unario de indireccin * toma su operando como una direccin y accesa a esa direccin para obtener su contenido. Para realizar que la proposicin px = &x, es necesario declarar las variables que intervienen en el ejemplo como se muestra a continuacin. int x; int *px; La declaracin de x ya la hemos visto anteriormente. La declaracin del apuntador px es nueva int *px; significa que px es una variable direccin de una variable entera. que contiene la
Ejemplo 1
Uso de una variable puntero.

#include <conio.h> #include <iostream.h> void main() { int *px,x; cout <<"x=5\n"; cout <<"px=&x\n"; x=5; px=&x; cout <<"*px es "<<*px; cout << " y x es "<<x<<"\n\n";
cout <<"*px=10\n"; *px=10; cout <<"*px es "; cout <<*px<< " y x es cout <<"px es "; cout <<px<< " y &x es } Explicacin:
"<<x<<"\n\n"; "<<&x<<"\n";
Las instrucciones: x=5; px=&x; se representan de la siguiente manera: Variable x px dir x 5
donde px "apunta a" x y *px es 5.
10.2. CADENAS Y CARACTERES

En C++ una cadena es un arreglo de caracteres que termina con el carcter nulo (\0). En la memoria los caracteres de una cadena son almacenados uno detrs del otro como se muestra en la figura: La siguiente proposicin char cad[10]=Mi Per; genera el siguiente arreglo de caracteres. [0] M [1] i [2] [3] P [4] e [5] r [6] [7] \0 Nulo Sin usar [8] [9]
Caracteres
Para acceder a sus elementos se realiza como se hizo con un vector; pero se debe tener en cuenta que el contenido de cada elemento es un carcter.
Ejemplo 1
Escribir un programa donde se ingrese un texto y luego determine el nmero de palabras con longitud es par.
#include <string.h> #include <stdio.h> #include <ctype.h> void main(){ char texto[80]; int cpal,i,lpal; printf("Ingrese texto: "); gets(texto); cpal=0;i=0; while(texto[i]!='\0'){ lpal=0; while (isalpha(texto[i]) && texto[i]!='\0'){ lpal++; i++; } if (lpal % 2==0 && lpal) cpal++; while (!isalpha(texto[i]) && texto[i]!='\0') i++; } printf("Cantidad de palabras: %d\n",cpal); }
Ejemplo 2
Escribir un un texto y palabras que longitud sea
programa donde se ingrese luego imprima todas las inicien en una vocal y su impar.
#include <stdio.h> #include <ctype.h> int esvocal(int c); void main(){ char texto[80],palabra[80]; int i,lpal; printf("Ingrese texto: "); gets(texto); i=0; while(texto[i]!='\0'){ lpal=0; palabra[lpal]='\0'; while (isalpha(texto[i]) && texto[i]!='\0'){ lpal++;
palabra[lpal-1]=texto[i]; palabra[lpal]='\0'; i++; } if (lpal % 2!=0 && esvocal(palabra[0])) printf("%s\n",palabra); while (!isalpha(texto[i]) && texto[i]!='\0') i++; } }
int esvocal(int c){ if(islower(c)) c-=32; if (c=='A') return 1; else if (c=='E') return else if (c=='I') return else if (c=='O') return else if (c=='U') return else return 0; }
1; 1; 1; 1;
Otro forma de declarar una cadena es: Char cad[]=Mi Per; o char *cad=Mi Per; o char cad[]={M,i, ,P,e,r,,\0}; que genera el siguiente arreglo de caracteres. [0] M [1] i [2] [3] P [4] e [5] r [6] [7] \0 Nulo
Caracteres
La diferencia de estas tres declaraciones con: char cad[10]=Mi Per; es que el tamao del arreglo se ajusta a la cantidad de caracteres de la cadena ms el carcter nulo.
En C++ es apropiado decir que una cadena es un puntero, de hecho es un puntero al primer carcter de una cadena.
Ejemplo 3
Escribir un programa donde se ingresen dos textos, luego imprima cuantas veces se encuentra el contenido del segundo texto en el primer texto. Por ejemplo: Si el primer texto es Sistemas operativos modernos y el segundo es os el resultado es 2.
#include <stdio.h> int contarsub(char *cad,char *sub); void main(){ char cadena[80],subcad[80]; printf("Ingrese la cadena: "); gets(cadena); printf("Ingrese la subcadena: "); gets(subcad); printf("Numero de veces contenida: %d\n" ,contarsub(cadena,subcad)); } int contarsub(char *cad,char *sub){ int i,j,k,c=0; for(i=0;cad[i]!='\0';i++) for(j=i,k=0;sub[k]==cad[j];k++,j++) if(sub[k+1]=='\0'){ c++; break; } return c; }
Ejemplo 4
Programa que imprime una cadena usando un puntero.

#include <iostream.h> void main() { char x[]="hola amigo",*p;int i; i=0; p=x; while(*(p+i)!= 0) {cout<<*(p+i); i++; }cout<<"\n"; }
Ejemplo 5
Se tiene una cadena de caracteres se pide hacer un programa para contar cuantas palabras en total existen, adems el programa debe calcular cuantos caracteres tiene la palabra ms grande y la ms corta. Para hacer el recorrido deber usar slo punteros a arreglos. Por ejemplo
Si se tiene la cadena : "AQU UNA CADENA CORTA ESTA PRESENTE" El programa imprimir que existen 6 palabras en total, la palabra ms corta consta de 3 caracteres y la ms grande consta de 8 caracteres. #include <iostream.h> void contar(char *c,int &can,int &may, int &men); void main() { int veces=0;//cuantas palabras hay int ma=0,me=10000;//caract de mayor y menor //respectivamente char cad1[45]="AQUI UNA CADENA CORTA ESTA PRESENTE"; contar(cad1,veces,ma,me); cout<<"La cadena "<<cad1<<" tiene \n"<<veces; cout<<" palabras, la palabra mayor tiene "<<ma<<" caracteres\n"; cout<<"y la palabra menor tiene "<<me<<" caracteres"<<endl; } void contar(char *c, int &can, int &may, int &men) { int cont=1;//contador de caracteres //de cada palabra while(*c!=0) { if (*c==' ') { can++; if (may<cont-1) may=cont-1; if (men>cont-1) men=cont-1; cont=0; } c++;cont++; } can++;//la ultima palabra no acaba //en espacio if (may<cont-1) may=cont-1; if (men>cont-1) men=cont-1; }
10.3. PUNTEROS A ESTRUCTURAS

Dada la declaracin
struct ns { T1 C1; ..... TK CK; } *p, q;
si p=&q; especifica que p es una variable apuntador a la variable de estructura q, que se representa de la siguiente manera:
Variable q dir q p C1 ... CK
Para acceder al campo de una variable estructura a travs del puntero a estructura usar: p->C1, ... , p->CK El uso ms difundido de una variable estructura es en las estructuras de asignacin dinmica de la memoria los estudian en los siguientes items. puntero a datos con cuales se
10.4. LISTAS ENLAZADAS

Una lista enlazada es una coleccin lineal de estructuras autorreferenciadas llamadas nodos, conectadas por enlaces de punteros, por lo que se le llama lista enlazada. Se tiene el acceso a una lista enlazada va un puntero al primer nodo de la lista. Se puede tener acceso a los nodos subsecuentes va el puntero de enlace almacenado en cada nodo. Para marcar el fin de la lista, el puntero de enlace del ltimo nodo apunta a NULL(0).
NULL
Nodos
La estructura de datos en C++ usada puede ser: struct nodo

{ int info;//guarda la informacin del nodo struct nodo *sig; //puntero que apunta al siguiente // nodo };
Si definimos una lista como elementos de un conjunto E. Se tiene que: Una lista sobre E es una secuencia ordenada L de cero o ms elementos de E: a1, a2, ...., an Si n=0, L no tiene elementos y ser llamada la lista nula o vaca. Si n>=1, L tiene longitud es n. n elementos y diremos que su
a1 es el primer elemento de L y an es el ltimo elemento de L. Para i= 1, 2, , n-1, ai Para i= 2, 3, , n, ai precede a ai+1 sigue a ai-1
El orden en la secuencia determina la posicin de cada elemento. Ahora se mencionan las caractersticas de algunas operaciones que vamos a implementar para la lista enlazada con punteros. Operaciones bsicas con una lista
Suponemos que L es una lista. Adems conviene postular la existencia de una posicin especial: FIN(L), la cual sigue a la posicin del ltimo elemento de L que es (NULL). ANULA(L) : Funcin que convierte a L en la lista vaca o nula y retorna la posicin FIN(L). LOCALIZA(x,L) : Funcin que retorna la posicin del primer elemento de L que es igual a x o FIN(L), si tal elemento no existe. RECUPERA(p,L) : Funcin que retorna al elemento que est en la posicin p en L. No esta definida si p=FIN(L) o si no hay una posicin p en L. SUPRIME(p,L) : Funcin que suprime al elemento de la posicin p en L; esto es, si L es a1, , ap1, ap, ap+1, ,an antes; despus L es a1, , ap-1, ap+1, ,an. El resultado no esta definido si p=FIN(L) o si no hay una posicin p en L. INSERTA(x,L) Funcin que inserta x en forma ordenada en la lista L.
Ejemplo 1
Programa que ejecuta las operaciones de una lista enlazada.

//programa que realiza la implementacin de la //lista con punteros. #include <iostream.h> #include <alloc.h> #define nulo 0 struct nodo { int info; struct nodo *sig; }; #define TAM sizeof(struct nodo) struct nodo * anula(struct nodo *top); struct nodo * inserta(int x,struct nodo *top); void contenido(struct nodo *top); struct nodo * suprime(int p, struct nodo *top); int localiza(int x, struct nodo *top ); int recupera(int pos,struct nodo *top); struct nodo * FIN(struct nodo *top); main() { int op,x,p;struct nodo *L; do { cout<<"MENU DE OPERACIONES DE UNA; cout<<"LISTA ENLAZADA \n"; cout<<"1. ANULA LISTA \n"; cout<<"2. SUPRIME \n"; cout<<"3. INSERTA \n"; cout<<"4. CONTENIDO DE LA LISTA \n"; cout<<"5. LOCALIZA ELEMENTO \n"; cout<<"6. RECUPERA ELEMENTO \n"; cout<<"7. SALIR \n"; cout<<"Ingrese una opcin (1-7)==> ";cin>>op; switch (op) { case 1 : L=anula(L);break; case 2 : cout<<"Digite posicin a suprimir ==> ";cin>>p; L=suprime(p,L);break; case 3 : cout<<"Digite valor a insertar ==> ";cin>>x; L=inserta(x,L);break; case 4 : contenido(L);break; case 5 : cout<<"Digite valor a localizar ==> ";cin>>x; p=localiza(x,L); if (p==-1) cout<<"no existe valor "; else cout<<"la posicin es "<<p; getch();break;
case 6 : cout<<"Digite posicin mostrar ==> ";cin>>p; x=recupera(p,L); if (x==-1) cout<<"no existe posicin"; else cout<<"el valor es "<<x; getch();break;
case 7 : break; default : cout<<" ingrese valor del 1 al 7";getch(); } } while (op!=7); } struct nodo * anula(struct nodo *top) { top=NULL; return(top); } struct nodo * inserta(int x,struct nodo *top) { struct nodo *comienzo, *nuevo, *p, *q; /*01*/ comienzo=top; /*02*/ /*crear nuevo dato*/ /*03*/ nuevo=(struct nodo *) malloc(TAM); /*04*/ nuevo->info=x; /*05*/ /* primer dato*/ /*06*/ if (comienzo==NULL) /*07*/ { comienzo=nuevo;nuevo->sig=NULL;} /*08*/ /* valor antes de comienzo*/ /*09*/ else /*10*/ if (x<comienzo->info) /*11*/ { nuevo>sig=comienzo;comienzo=nuevo;} /*12*/ else /*13*/ { /*nuevo se halla entre p y q; /*14*/ /*luego enlazarlos*/ /*15*/ q=comienzo; /*16*/ while (q!=NULL && (x>=q>info)) /*17*/ {p=q; q=q->sig;} /*18*/ p->sig=nuevo;nuevo->sig=q; /*19*/ } return(comienzo); } int recupera(int pos,struct nodo *top) { struct nodo *p;int i=1; p=top; while(p!=FIN(top) && i!=pos) {p=p->sig;i++;} if(p==FIN(top)) return(-1); //no hay posicin pos else return (p->info); } struct nodo * FIN(struct nodo *top)
// Esta implementacin de fin(L) es ineficiente (se recorre // toda la lista). Si se usa con mucha frecuencia es preferible // modificar un poco la estructura de la lista y/o el programa { struct nodo *p; p=top; while(p!=NULL) {p=p->sig;} return(p); } void contenido(struct nodo *top) { struct nodo *p; cout<<"impresin de la lista \n"; p=top; while(p!=NULL) {cout<<p->info<<" ";p=p->sig; } cout<<"\n"; getch(); } struct nodo * suprime(int pos, struct nodo *top) {struct nodo *q,*p,*comienzo;int i=1; comienzo=top;q=comienzo; if (pos==1) //la posicin es al inicio { comienzo=q->sig;free(q);} else { while (q!=FIN(comienzo) && pos!=i) {p=q; q=q->sig;i++;} if (q==FIN(comienzo)) {cout<<"posicin no encontrado o lista vaca \n";getch();} else {p->sig=q->sig; free(q);/*libera la memoria asignada al puntero q*/ } } return (comienzo); } int localiza(int x, struct nodo *top ) { struct nodo *p,*comienzo;int true,i=1; p=top; while(p!=FIN(top)) { if (x==p->info) return(i); else {p=p->sig;i++;} } /*fin de while*/ if (p==FIN(top)) return(-1); }
10.5. COLAS (FIFO)

Una cola es otro tipo especial de lista, en la cual los elementos se insertan por un extremo llamado FINAL y se suprime por el otro llamado FRENTE:
a Frente b c d e Final
Esto ocasiona que el primer elemento en entrar es el primero en salir; de aqu el nombre de lista fifo (first in, first out) que tambin se le da a una cola. Las operaciones bsicas que caracterizan a una cola son las siguientes: ANULA(C) : Funcin que convierte a la cola C en la cola vacia. VACIA(C) : Funcin que retorna 1 si la cola esta vaca y 0 en caso contrario. FRENTE(C) : Funcin que retorna el 1er. elemento de la cola C. Esta funcin no est definida si la cola es vacia. INSERTA_COLA(x,C) : Funcin que inserta al elemento x en el final de C. SUPRIME_COLA(C) : Funcin que suprime el elemento del frente de la cola C. No se realiza si la cola es vacia. Ejemplo 1 : Realizar punteros cola.
Cola 5 6
de
la implementacin las operaciones de
con una
NULL
Frente
Final
#include <iostream.h> #include <conio.h> #include <alloc.h> struct nodo { int info; struct nodo *sig; }; #define TAM sizeof(struct nodo) struct nodo * anula(struct nodo *top); struct nodo * inserta_cola(int x,struct nodo *top); void contenido(struct nodo *top); int frente(struct nodo *top); struct nodo * suprime_cola(struct nodo *top); main() { int op,x,p;struct nodo *L; do { clrscr(); cout<<"MENU DE OPERACIONES DE COLA \n"; cout<<"1. ANULA COLA \n"; cout<<"2. INSERTA COLA \n"; cout<<"3. CONTENIDO DE LA COLA \n"; cout<<"4. SUPRIME COLA \n"; cout<<"5. FRENTE \n"; cout<<"6. SALIR \n"; cout<<"Ingrese una opcin (1-6)==> ";cin>>op; switch (op) { case 1 : L=anula(L);break; case 2 : cout<<"Digite valor a insertar ==> ";cin>>x; L=inserta_cola(x,L);break; case 3 : contenido(L);break; case 4 : L=suprime_cola(L);break; case 5 : x=frente(L); if(x!=-1) cout<<"el valor es "<<x; getch();break; case 6 : break; default : cout<<" ingrese valor del 1 al 6";getch(); } } while (op!=6); } struct nodo * anula(struct nodo *top) { struct nodo *p; p=top; p=NULL; return(p); } struct nodo * inserta_cola(int x,struct nodo *top) //inserta x al final de la cola { struct nodo *comienzo, *nuevo, *p, *q; /*01*/ comienzo=top; /*02*/ /*crear nuevo dato*/ /*03*/ nuevo=(struct nodo *) malloc(TAM);
/*04*/ /*05*/ /*06*/ cola /*07*/ /*09*/ /*13*/ cola*/ /*15*/ /*16*/ /*17*/ /*18*/ /*19*/ }
nuevo->info=x; /* primer dato*/ if (comienzo==NULL)//si es vacia la { comienzo=nuevo;nuevo->sig=NULL;} else { /*nuevo se pone al final de la q=comienzo; while (q!=NULL) {p=q; q=q->sig;} p->sig=nuevo;nuevo->sig=q;
} return(comienzo);
struct nodo * suprime_cola(struct nodo *top) //suprime el 1er elemento { struct nodo *comienzo, *p, *q; comienzo=top; p=comienzo; if (p==NULL) { cout<<"cola vacia"; getch(); } else { q=p->sig; comienzo=q; free(p); } return(comienzo); } int frente(struct nodo *top) { struct nodo *p; p=top; if (p==NULL) {cout<<"cola vacia";getch(); return(-1); } else return (p->info); } void contenido(struct nodo *top) { struct nodo *p; cout<<"impresion de la lista \n"; p=top; while(p!=NULL) {cout<<p->info<<" ";p=p->sig; } cout<<"\n"; getch(); }
CAPITULO 11 ARCHIVOS
En el captulo de registros al utilizar los arreglos de estructuras se da la desventaja que los datos de los registros existen, mientras el programa este en ejecucin, perdindose cuando el programa finaliza. Para salvar esta situacin se puede guardar los datos al disco utilizando los archivos que se dan en C++, recuperandolos cuando se desee usar en alguna otra oportunidad.
11.1. ORGANIZACIN DE ARCHIVOS

Un archivo es una coleccin de datos que con un ttulo o nombre se almacenan o graban en dispositivos tales como discos, disquetes, cintas magnticas, etc. Los datos de un archivo pueden ser ledos y utilizados por otros medios. Las operaciones bsicas con un archivo son: Apertura del archivo identificarlo empleando un nombre para
Escritura de datos en el archivo Lectura de datos del archivo

Cierre del archivo Los datos de un archivo son simplemente bytes o caracteres almacenados uno a continuacin de otro que son enumerados con 0, 1,...
0 Archivo 1 2 3 4 5 6 7 8
comienzo
apuntador apunta a componente 8
Es necesario abrir un archivo antes de proceder a hacer operaciones de escritura o de lectura en l. Cuando se abre un archivo usualmente queda listo para acceder al componente 0, lo que suele decirse que el archivo apunta al comienzo. Despus de cada operacin de escritura o de lectura, el archivo apunta al componente que sigue al grupo de datos escritos o ledos: Acceso secuencial. Tambin es posible desplazar el apuntador a un componente particular dentro del archivo, empleando funciones de movimiento del apuntador: Acceso directo. Se debe cerrar un trabajar con l. archivo cuando ya no se desee
Para borrar o eliminar un archivo se funcin unlink(). Por ejemplo, mediante unlink(DATOS); se borra el archivo de nombre DATOS.
emplea
la
FUNCIONES DE ALTO NIVEL Para utilizar este grupo de funciones se debe incluir la cabecera stdio.h
El uso de las funciones requiere la declaracin de una variable puntero del tipo predefinido FILE en la forma: FILE *arch; en donde arch es un nombre o identificador . Para abrir un archivo usar la funcin fopen(), siguiente formato: arch = fopen(NOMBRE DE ARCHIVO , modo); donde modo puede ser: r w a Abre para solo lectura Crea para escritura. Si el archivo existe, este se sobreescribe Abre para escribir archivo o crea para archivo no existe. al final del escribir si el para con el
r+ w+
Abre un archivo existente actualizar (lectura y escritura).
Crea un nuevo archivo para actualizar (lectura y escritura). Si el archivo existe, este se sobreescribe Abre para aadir, abre para actualizar en el final del archivo, o crea este si no existe.
a+
Para especificar que un archivo esta siendo abierto o creado en el modo texto aadir t a la cadena (rt, w+t, etc.) Para especificar el modo binario, aadir b a la cadena (wb, a+b, etc.)
Nota: Si se tiene la cadena r+t es equivalente a rt+, sucede lo mismo con las dems combinaciones. La funcin fopen() devuelve la direccin 0 (cero o NULL) si la operacin de apertura falla, o un valor (direccin) distinto si es correcta. Si la operacin es correcta, a partir de ese instante el archivo queda referido por el apuntador arch hasta el momento en que se cierra con fclose mediante: fclose (arch);
11.2. ESCRITURA EN ARCHIVOS:

Para escribir en un archivo (abierto en los modos w o a) se pueden utilizar las funciones: fputc(c , arch): Escribe un carcter c en arch.
fwrite(s, m, n, arch): Escribe en arch n datos de tamao o longitud m (igual a m*n bytes) ubicados a partir de la direccin s.
11.3. LECTURA DE ARCHIVOS:

fgetc(arch) : Devuelve el siguiente carcter ledo en arch. fread(s, m, n, arch): Lee en arch n datos de tamao o longitud m (igual a m*n bytes) y los almacena a partir de la direccin s. feof(arch) : Sirve para comprobar si est en el final del archivo (valor distinto de cero) o n (valor cero). NOTA:
fputc() y fgetc() devuelven un valor de tipo int igual al carcter escrito o ledo o el valor EOF(-1) en caso de error. Se devuelve EOF si se lleg al final del archivo. fwrite() y fread() devuelven un valor de tipo igual al nmero de datos escritos o ledos. As fwrite() devuelve el nmero de n datos especificados o un valor menor en caso de error. Y fread() devuelve el valor n o un nmero menor, por ejemplo 0 si est en el final del archivo.
11.4. UBICACIN DIRECTO

Usar :
DEL
PUNTERO
PARA
ACCESO
fseek (arch, desp, orig);
La funcin pone o ubica el puntero del archivo en el componente cuya posicin es dada por des (tipo long) y orig, siendo desp el desplazamiento respecto del lugar indicado por el origen orig, cuyos valores son-. 0 = comienzo del archivo 1 = posicin actual 2 = final del archivo fseek() devuelve el valor 0 si el movimiento ha tenido lugar, o distinto de 0 en caso de error.
Ejemplo 1
Programa que lee archivo de texto.

#include #include #include #include <string.h> <stdio.h> <conio.h> <iostream.h>
el
contenido
de
un
int main(void) { FILE *stream; char ch; /* open a file for update */ stream = fopen("TEXTO.TXT", "r");
clrscr(); do { /* read a char from the file */ ch = fgetc(stream); /* display the character */ putchar(ch); } while (ch != EOF); fclose(stream); getch(); return 0;
Ejemplo 2
Programa que copia el contenido de un archivo de texto en otro.

#include #include #include #include <string.h> <stdio.h> <conio.h> <iostream.h>
int main(void) { FILE *p,*q; char ch,nombarch1[12]="texto.txt",nombarch2[12]="tex to1.txt"; // Copia un archivo en otro p = fopen(nombarch1, "r"); q = fopen(nombarch2, "w"); clrscr(); do {/* read a char from the file */ ch = fgetc(p); /*escribe ch en q*/ fputc(ch,q); } while (ch != EOF); fclose(p);fclose(q); clrscr(); //escribe el contenido de los archivos p = fopen(nombarch1, "r"); cout<<"contenido archivo "<<nombarch1<<"\n"; do { /* read a char from the file */ ch = fgetc(p); /*escribe ch en pantalla*/ putchar(ch); } while (ch != EOF); fclose(p); cout<<"contenido archivo "<<nombarch2<<"\n"; q = fopen(nombarch2, "r"); do { /* read a char from the file */ ch = fgetc(q); /*escribe ch en pantalla*/
putchar(ch); } while (ch != EOF); fclose(q); getch(); return 0; }
Ejemplo 3
Programa binarios
que
administra
archivos
#include <iomanip.h> #include <iostream.h> #include <conio.h> #include <stdio.h> #include <string.h> #include <process.h> struct alumno{ char nombre[20]; int edad; }; void crear(); void anadir(); void reporte(); void consulta(); void modificacion(); void eliminacion(); void ordenar(); void main(){ char resp; do{ clrscr(); cout<<"0. Salir\n"; cout<<"1. Crear\n"; cout<<"2. Anadir\n"; cout<<"3. Reporte\n"; cout<<"4. Consulta\n"; cout<<"5. Modificacion\n"; cout<<"6. Eliminacion\n"; cout<<"7. Ordenar\n"; cout<<"Ingrese Opcion :\n"; resp=getch(); switch(resp){ case '1':crear();break; case '2':anadir();break; case '3':reporte();break; case '4':consulta();break; case '5':modificacion();break; case '6':eliminacion();break; case '7':ordenar();break; } }while(resp!='0');
void crear(){ FILE *f; struct alumno r; if((f=fopen("alumnos.dat","wb"))== NULL){ cout<<"No se puede abrir \n"; exit(0); } cout<<"Nombre : "; gets(r.nombre); while(r.nombre[0]!='\0'){ cout<<"Edad : "; cin>>r.edad; fwrite(&r,sizeof(r),1,f); cout<<"Nombre : "; gets(r.nombre); } fclose(f); } void anadir(){ FILE *f; struct alumno r; if((f=fopen("alumnos.dat","ab"))== NULL){ cout<<"No se puede abrir \n"; exit(0); } cout<<"Nombre : "; gets(r.nombre); while(r.nombre[0]!='\0'){ cout<<"Edad : "; cin>>r.edad; fwrite(&r,sizeof(r),1,f); cout<<"Nombre : "; gets(r.nombre); } fclose(f); } void reporte(){ FILE *f; struct alumno r; if((f=fopen("alumnos.dat","rb"))== NULL){ cout<<"No se puede abrir \n"; exit(0); } cout<<setw(20)<<"Nombre" <<setw(10)<<"Edad\n"; while(fread(&r,sizeof(r),1,f)!=0){ cout<<setw(20)<<r.nombre <<setw(10)<<r.edad<<"\n"; } fclose(f); getch(); }
void ordenar(){ FILE *f; long pos,pos1,pos2,nreg,i,j; struct alumno r,r1,r2; if((f=fopen("alumnos.dat","rb+"))== NULL){ cout<<"No se puede abrir \n"; exit(0); } fseek(f,0L,2); fgetpos(f,&pos); nreg=pos/sizeof(r); for(i=nreg-1;i>=1;i--) for(j=1;j<=i;j++){ pos1=(j-1)*sizeof(r); pos2=(j)*sizeof(r); fseek(f,(long)(pos1),0); fread(&r1,sizeof(r),1,f); fseek(f,(long)(pos2),0); fread(&r2,sizeof(r),1,f); if(strcmp(r1.nombre,r2.nombre)>0){ fseek(f,(long)(pos2),0); fwrite(&r1,sizeof(r),1,f); fseek(f,(long)(pos1),0); fwrite(&r2,sizeof(r),1,f); } } fclose(f); cout<<"Ordenado Ascendentemente." "Pulse una tecla para continuar\n"; getch();
void consulta(){ FILE *f; struct alumno r; char nombrec[20]; if((f=fopen("alumnos.dat","rb"))== NULL){ cout<<"No se puede abrir \n"; exit(0); } cout<<"Ingrese nombre a consultar : "; gets(nombrec); while(fread(&r,sizeof(r),1,f)!=0){ if(!strcmp(r.nombre,nombrec)){ cout<<setw(20)<<"Nombre" <<setw(10)<<"Edad\n"; cout<<setw(20)<<r.nombre <<setw(10)<<r.edad<<"\n"; break; } } if(strcmp(r.nombre,nombrec)){ cout<<"No existe ese nombre \n"; getch(); }
fclose(f); getch();
void modificacion(){ FILE *f; struct alumno r,r1; char nombrec[20],resp; long creg=0; if((f=fopen("alumnos.dat","rb+"))== NULL){ cout<<"No se puede abrir \n"; exit(0); } cout<<"Nombre a modificar:"; gets(nombrec); while(fread(&r,sizeof(r),1,f)!=0){ creg++; if(!strcmp(r.nombre,nombrec)){ cout<<setw(20)<<"Nombre" <<setw(10)<<"Edad\n"; cout<<setw(20)<<r.nombre <<setw(10)<<r.edad<<"\n"; break; } } if(!strcmp(r.nombre,nombrec)){ cout<<"NUEVO REGISTRO\n"; cout<<"Nombre : "; gets(r1.nombre); cout<<"Edad : "; cin>>r1.edad; cout<<"Grabar modificacin? (S/N)"; resp=getche(); if(resp=='S' || resp=='s'){ fseek(f,(creg-1)*sizeof(r),0); fwrite(&r1,sizeof(r),1,f); } } else{ cout<<"No existe ese nombre \n"; getch(); } fclose(f); } void eliminacion(){ FILE *f,*f1; struct alumno r; char nombrec[20],resp; int sw=0; if((f=fopen("alumnos.dat","rb"))== NULL){ cout<<"No se puede abrir \n"; exit(0); }
f1=fopen("tmpfich.dat","wb"); cout<<"Nombre a eliminar: "; gets(nombrec); while(fread(&r,sizeof(r),1,f)!=0){ if(!strcmp(r.nombre,nombrec)){ cout<<setw(20)<<"Nombre" <<setw(10)<<"Edad\n"; cout<<setw(20)<<r.nombre <<setw(10)<<r.edad<<"\n"; cout<<"Eliminar ? (S/N)\n"; resp=getch(); sw=1; if(resp=='S' || resp=='s') cout<<"Eliminado\n"; else fwrite(&r,sizeof(r),1,f1); } else fwrite(&r,sizeof(r),1,f1); } if (sw==0){ cout<<"No existe ese nombre \n"; getch(); } fclose(f); fclose(f1); remove("alumnos.dat"); rename("tmpfich.dat","alumnos.dat");
BIBLIOGRAFIA
1. Swan,
Tom.
(1995).
Borland
C++
4.5.
Editorial
Sams
Premier. 2. Deitel, H. M. Y Deitel, P.J. (1994). Como Programar en C/C++. Editorial Prentice Hall. 3. Gottfried, Byron S. (1991). Programacin en C. Editorial Mc Graw-Hill. 4. Joyanes Aguilar, Luis. (1988). Fundamentos de Programacin Algoritmos y Estructura de Datos. Editorial McGraw-Hill. 5. Alcalde, Eduardo Y Garcia, Miguel. (1987). Metodologa de la Programacin. Editorial McGraw Hill.

C++ Corre

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

C++ Corre

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD NACIONAL DEL CENTRO DEL PERU

TECNICAS DE PROGRAMACION ESTRUCTURADA: APLICACIONES CON C++

ABRAHAM GAMARRA MORENO DANIEL GAMARRA MORENO JUAN GAMARRA MORENO

TECNICAS DE PROGRAMACIN ESTRUCTURADA: Aplicaciones en C++

CAPITULO 1 PROGRAMACIN DE COMPUTADORAS

1.1.1. ANLISIS DEL PROBLEMA

1.1.2. PROCESO DE SOLUCIN

de sus formas de presentacin es a travs de cdigo en un lenguaje de programacin.

1.1.3. REFINAMIENTO DEL PROGRAMA

1.2. CARACTERSTICAS DE LOS PROGRAMAS

TECNICAS DE PROGRAMACIN ESTRUCTURADA: Aplicaciones en C++

debe ser fcilmente adaptado a otro lenguaje de programacin.

1.2.3. MODULARIDAD Y ESTRUCTURACIN

1.3. OBJETOS DE UN PROGRAMA

TECNICAS DE PROGRAMACIN ESTRUCTURADA: Aplicaciones en C++

TECNICAS DE PROGRAMACIN ESTRUCTURADA: Aplicaciones en C++

2.1.2. PROGRAMACIN MODULAR

2.1.3. PROGRAMACIN ESTRUCTURADA

TECNICAS DE PROGRAMACIN ESTRUCTURADA: Aplicaciones en C++

2.2. CONSTRUCCIN DE ALGORITMOS

problema planteado. Estos niveles muchas veces representan mdulos de programas.

2.3. REPRESENTACIN DE ALGORITMOS

2.3.1. DIAGRAMA DE FLUJO

adicionales que se emplean para situaciones especificas.

2.3.2. DIAGRAMA N-S

TECNICAS DE PROGRAMACIN ESTRUCTURADA: Aplicaciones en C++

CAPITULO 3 CARACTERISTICAS DEL C++

TECNICAS DE PROGRAMACIN ESTRUCTURADA: Aplicaciones en C++

3.3. PALABRAS RESERVADAS

TECNICAS DE PROGRAMACIN ESTRUCTURADA: Aplicaciones en C++

3.4. ESTRUCTURA DE UN PROGRAMA

3.5.1. COMENTARIO EN MS DE UNA LINEA

3.5.2. COMENTARIO EN UNA SOLA LNEA

TECNICAS DE PROGRAMACIN ESTRUCTURADA: Aplicaciones en C++

El compilador ignora todo lo que viene despus de // hasta el final de la lnea.

3.7. TIPOS DE DATOS FUNDAMENTALES

3.7.2. TIPOS ENTEROS

TECNICAS DE PROGRAMACIN ESTRUCTURADA: Aplicaciones en C++

LONGITUD RANGO 32 bits -2,147,483,648 a 2,147,483,647

3.7.3. TIPOS DE PUNTO FLOTANTE

3.7.4. TIPO VOID

3.8. MODIFICADORES DE TIPO

3.9.1. CONSTANTES ENTERAS

o hexadecimal; por decimal: 34, 5678.

3.9.2. CONSTANTE CARCTER (CHAR)

3.9.3. CONSTANTE CADENA

3.9.4. CONSTANTE DE PUNTO FLOTANTE

3.10. DEFINICIN DE CONSTANTES

const <identificador>=<Valor>; Ejemplo: const NOTA_MAX=20;

3.11. DECLARACIN DE VARIABLES

TECNICAS DE PROGRAMACIN ESTRUCTURADA: Aplicaciones en C++

double double double

TECNICAS DE PROGRAMACIN ESTRUCTURADA: Aplicaciones en C++

3.13. CONVERSIN DE TIPOS

TECNICAS DE PROGRAMACIN ESTRUCTURADA: Aplicaciones en C++

CAPITULO 4 OPERADORES BSICOS

4.2. OPERADOR DE ASIGNACIN

TECNICAS DE PROGRAMACIN ESTRUCTURADA: Aplicaciones en C++

4.2.1. IGUAL (=)

4.2.2. ASIGNACIN MLTIPLE

4.2.3. ASIGNACIN RELATIVA

TECNICAS DE PROGRAMACIN ESTRUCTURADA: Aplicaciones en C++

4.3. OPERADORES DE RELACIN