45509261-c-corre

UNIVERSIDAD NACIONAL DEL CENTRO DEL PERU

TECNICAS DE PROGRAMACIONESTRUCTURADA:

APLICACIONES CON C++

ABRAHAM GAMARRA MORENO

DANIEL GAMARRA MORENO

JUAN GAMARRA MORENO

CONTENIDO

INTRODUCCIÓN ................................................................................................................1

CAPITULO UNO PROGRAMACIÓN DE COMPUTADORAS

1.1. Construcción de un programa de computadora ............................................3

1.1.1. Análisis del problema...........................................................................4

1.1.2. Proceso de solución.............................................................................4

1.1.3. Refinamiento del Programa ................................................................5

1.2. Características de los programas ....................................................................5

1.2.1. Claridad..................................................................................................5

1.2.2. Eficiencia ...............................................................................................5

1.2.3. Modularidad y estructuración.............................................................6

1.3. Objetos de un programa....................................................................................6

1.3.1. Constantes ............................................................................................6

1.3.2. Variables................................................................................................7

CAPITULO DOS ALGORITMOS

2.1. Definiciones .........................................................................................................8

2.1.1. Algoritmo................................................................................................8

2.1.2. Programación modular ........................................................................9

2.1.3. Programación estructurada ................................................................9

2.2. Construcción de algoritmos ............................................................................11

2.3. Representación de algoritmos........................................................................11

2.3.1. Diagrama de Flujo ..............................................................................11

2.3.2. Diagrama N-S .....................................................................................12

2.3.3. Pseudocódigo .....................................................................................12

CAPITULO TRES CARACTERISTICAS DEL C++

3.1. Características ..................................................................................................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 más de una linea.....................................................15

3.5.2. comentario en una sola línea ...........................................................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 carácter (char) .................................................................18

3.9.3. Constante cadena ..............................................................................18

3.9.4. Constante de punto flotante .............................................................19

3.10. Definición de constantes .................................................................................19

3.10.1. La directiva #define ............................................................................19

3.10.2. Const ....................................................................................................19

3.11. Declaración de variables .................................................................................19

3.12. Expresiones .......................................................................................................19

3.13. Conversión de tipos..........................................................................................20

CAPITULO CUATRO OPERADORES BÁSICOS

4.1. Operadores aritméticos ...................................................................................22

4.2. Operador de asignación ..................................................................................23

4.2.1. Igual (=) ................................................................................................24

4.2.2. Asignación múltiple ............................................................................24

4.2.3. Asignación relativa .............................................................................24

4.3. Operadores de relación ...................................................................................25

4.4. Operadores lógicos ..........................................................................................25

CAPITULO CINCO SALIDA / ENTRADA ESTÁNDAR

5.1. Salida/entrada estándar en c++ .....................................................................26

5.1.1. Salida con cout ...................................................................................26

5.1.2. Entrada con cin...................................................................................27

CAPITULO SEIS SENTENCIAS DE CONTROL

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 aplicación.................................................................................48

CAPITULO SIETE SUBPROGRAMAS

7.1. Subprogramas o subrutinas............................................................................62

7.2. ¿Cuándo utilizar un subprograma? ...............................................................62

7.3. Diseño descendente (Top Down) ..................................................................63

7.3.1. Ejemplo ................................................................................................63

7.4. Programación modular ....................................................................................66

7.4.1. Modulo .................................................................................................66

7.4.2. Criterios a considerar en programación modular ..........................67

7.4.3. Fases de la programación modular .................................................67

7.5. Definición de funciones ...................................................................................67

7.5.1. Declaración de prototipos .................................................................68

7.5.2. Llamada a una función: .....................................................................69

7.5.3. Parámetros por valor .........................................................................71

7.5.4. Parámetros por referencia ................................................................71

7.5.5. Ámbito de una variable ......................................................................73

7.5.6. Variables locales ................................................................................74

7.5.7. Párametros formales y reales ..........................................................74

7.5.8. Variables globales ..............................................................................74

7.6. Programas de aplicación.................................................................................77

7.7. Funciones del sistema .....................................................................................81

7.7.1. Utilizacion de la directiva #include...................................................81

CAPITULO OCHO ESTRUCTURA DE DATOS: ARREGLOS

8.1. Arreglos unidimensionales: vectores.............................................................84

8.2. Arreglos bidimensionales: tablas / matrices.................................................90

CAPITULO NUEVE REGISTROS

9.1. Representación 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 aplicaciÓn............................................................................. 105

CAPITULO DIEZ PUNTEROS

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

CAPITULO ONCE ARCHIVOS

11.1. Organización de archivos............................................................................. 126

11.2. Escritura en archivos: ................................................................................... 129

11.3. Lectura de archivos: ...................................................................................... 129

11.4. Ubicación del puntero para acceso directo ............................................... 130

BIBLIOGRAFIA............................................................................................................... 137

INTRODUCCIÓN

La programación de computadoras en sus inicios fue concebida como un arte donde la inspiración del programador era la base para escribir programas. Con el objetivo de disminuir el tiempo de elaboración de programas, disminuir el costo de mantenimiento y mejorar el trabajo en equipo, se idearon técnicas como la metodología estructurada que a su vez dio origen al análisis y diseño estructurado. En la actualidad existen nuevas técnicas como la metodología orientada a objetos, pero que en la práctica es una metodología más estructurada. Dentro de la diversidad de Lenguajes de Programación el C/C++ sigue siendo un estándar universal por su portabilidad, es así que muchos compiladores comerciales han sido desarrollados en el C/C++.

La mayoría de la bibliografía del Lenguaje de Programación C/C++ asume que el lector tiene conocimientos previos de programación, lo que conlleva a una secuencia de aprendizaje donde primero se estudian cursos introductorios como Pascal y metodología de la programación estructurada, que forman las bases y luego se estudia el Lenguaje de Programación C/C++. Nuestra experiencia en la enseñanza de lenguajes de programación no nos ha permitido recomendar un texto que contenga la metodología y programación en C/C++. Es por eso que el texto esta dirigido a lectores que necesitan mejorar su metodología de programación y elaborar programas en C++, encontrando en este texto ejercicios variados en forma y

TECNICAS DE PROGRAMACIÓN ESTRUCTURADA: Aplicaciones en C++ GamarraMorenoADJ 1

complejidad. El texto contiene técnicas de programación estructurada con aplicaciones en Lenguaje C/C++.

En los capítulos I y II se desarrollan los conceptos básicos sobre las técnicas de programación. Los capítulos III, IV y V desarrollan las características del lenguaje de programación C++. Las Sentencias de control, tratada en el capitulo VI, es la parte medular de cualquier programa y son estas que la que definen lasecuencia de ejecución de las sentencias del programa. En el capitulo VII, los programas grandes son divididos en pequeños programas llamados subprogramas y implementados como funciones, mediante lastécnicas del diseño descendente y la programación modular se consigue una división optima del programa en subprogramas. Las estructuras de datos como los registros (en C/C++ struct) y arreglos (en inglés 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 en su aprendizaje en la programación de computadoras.

LOS AUTORES.


CAPITULO UNO

PROGRAMACIÓN DE COMPUTADORAS

1.1. CONSTRUCCIÓN DE UN PROGRAMA DE COMPUTADORA

Cualquier tarea que involucre el enfrentarse a un problema - no necesariamente la construcción de un programa de computadora -, involucra el tener una comprensión total del mismo y planear cuidadosamente cada uno de los pasos que intervienen en su solución.

La aparición 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, ¿cómo 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 diferenteslenguajes de programación existentes, también se pueden emplear una combinación de estos.

Obviamente debemos conocer las particularidades de cada lenguaje de programación y emplearlo adecuadamente. En nuestro caso emplearemos el Lenguaje de Programación C++ aplicado con Técnicas de


Programación Estructurada, ambos serán analizados con más 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. ANÁLISIS 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 entradaEn el cual se especifica los datos proporcionados por el problema en cuestión. Algunas veces se tendrán que seleccionar entre muchos datos, aquellos datos importantes para obtener lo que se requiere.

Datos de salidaEl programa que se elabora para solucionar el problema generará un resultado (lo que requerimos), ¿qué resultado?. Evidentemente, esto también 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 SOLUCIÓN

Luego del análisis estableceremos la relación 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 relación con los datos de salida a través de un algoritmo que será la solución a nuestro problema. Un algoritmo es simplemente el conjunto de acciones que se deberán establecer para solucionar nuestro problema. Este algoritmo - el Capítulo Dos trata en detalle acerca de los algoritmos - puede ser presentado de diversas maneras, una


de sus formas de presentación es a través de código en un lenguaje de programación.

1.1.3. REFINAMIENTO DEL PROGRAMA

En esta etapa sometemos al programa a una serie de pruebas para determinar que cambios se podrían 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 habíamos dejado sueltos.

1.2. CARACTERÍSTICAS DE LOS PROGRAMAS

Para llegar a la solución de un problema podemos utilizar varios métodos de solución, o lo que es lo mismo, varios algoritmos. Para seleccionar el algoritmo correcto debemos tener en cuenta ciertas características inherentes a estos algoritmos, que pueden estar representados en la forma de un programa de computadora. He aquí algunas de las características que podemos mencionar para este programa de computadora.

1.2.1. CLARIDAD

Ha de ser fácil de leer y entender, en lo posible se debe emplear el algoritmo más simple, de entre las múltiples 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 pueda, emplear la menor cantidad de acciones o instrucciones en el programa, aprovechando los recursos que pueda ofrecer el sistema y la computadora, debe ser fácilmente adaptado a otro lenguaje de programación.


1.2.3. MODULARIDAD Y ESTRUCTURACIÓN

Puede estar subdividido en bloques o módulos, cada módulo realiza una parte del trabajo total. Los módulos deben usar las técnicas de la Programación Estructurada para facilitar la verificación, depuración 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 características:

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 los podemos dividir en Constantes yVariables.

1.3.1. CONSTANTES

Estos objetos tienen valores fijos y que no pueden ser variados a lo largo de la ejecución 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.

En el C++ también 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 la posibilidad de ser cambiados durante la ejecución del programa. Ejemplo: int a; declara una variable “a” de tipo int.


CAPITULO DOS

ALGORITMOS

2.1. DEFINICIONES

2.1.1. ALGORITMO

El algoritmo tal como lo vimos inicialmente, es el conjunto de acciones que se deberán realizar para resolver un problema. Si este problema ha de ser resuelto por una computadora, entonces el algoritmo es el conjunto de instrucciones que deberán ser realizados por la computadora.

El algoritmo empleado debe indicar el orden de realización de cada instrucción, el número de instrucciones será finito. Se debe obtener los mismos resultados, cuando los datos de entrada son los mismos.

Para la construcción de los algoritmos emplearemos; la Programación Modular y una Técnica de Programación Estructurada.


2.1.2. PROGRAMACIÓN MODULAR

Existe una “regla de oro” en la programación, “divide y vencerás”. La Programación Modular es la aplicación de esta regla, divide el programa en módulos, en el caso del C++ estos módulos están representados en la forma de funciones, ya que el C++ es un lenguaje funcional, es decir solamente emplea funciones en la construcción de un programa.

Estos módulos reducen la complejidad de un programa, al permitir que cada módulo pueda ser analizado y perfeccionado casi independientemente del resto de los módulos, no totalmente independiente porque no se debe perder la visión global del programa.

Los módulos son interdependientes entre sí; uno de ellos, el módulo principal, controla y relaciona los demás módulos. El módulo principal, también es conocido como programa principal; en el caso del C++ esta viene a ser la función principal o función main(). El resto de módulos se conocen como procedimientos o subprogramas; en el caso del C++ se denominan simplemente funciones.

Un módulo es un conjunto de instrucciones ordenadas, los cuales pueden ser referenciados empleando el nombre que se le asigna al módulo.

Cabe mencionar que, si el programa no es muy complejo no será necesario crear más de un módulo, en este caso no se ha dividido el programa.

2.1.3. PROGRAMACIÓN ESTRUCTURADA

Ya sea que el programa cuente con uno o varios módulos, en nuestro caso del C++, con una o más funciones, tendremos que emplear la técnica de programación estructurada en el módulo o los módulos.

La Programación Estructurada, es una técnica de programación –existen otras- que emplea en el diseño de los módulos: estructuras de


control, recursos abstractos y un diseño descendente.

Estructuras de controlSon tres tipos de estructuras que al utilizarse individualmente o en forma combinada pueden resolver cualquier problema de programación 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 continuación de otra, sin omitir ninguna.Estructuras selectivas, son aquellas que seleccionan una alternativa –puede ser una o varias instrucciones- a realizar, la selección depende del valor de una condición. Estas a su vez se dividen en estructuras selectiva simple, doble y múltiple.Estructuras repetitivas, son aquéllas en le que una instrucción o conjunto de instrucciones se repiten una cantidad de veces determinada por una condición. Tenemos las siguientes, estructura repetitiva mientras, hacer - mientras, desde – hasta (para).

Recursos abstractosEl conjunto de instrucciones a seguir es un recurso abstracto, pues es independiente del tipo de computadora a emplear, así como también del lenguaje de programación. Estas instrucciones

deben ser implementadas con pocos o casi ningún cambio,en un lenguaje de

programación específico paracualquier tipo de computadora.

Metodología Descendente de “Arriba haciaAbajo”

Esta metodología conocida también como “top_down” coloca las instrucciones en una estructura jerárquica, teniendo que algunas de estas instrucciones se encuentren en niveles respecto a otros. Dos instrucciones de niveles inmediatos se

TECNICAS DE PROGRAMACIÓN ESTRUCTURADA: Aplicaciones en C++ GamarraMorenoADJ10

relacionan a través de sus entradas y salidas.En cada nivel se detalla como se utilizanlos datos que permitirá la resolución delproblema planteado. Estos niveles muchasveces representan módulos de programas.

2.2. CONSTRUCCIÓN DE ALGORITMOS

Con el conocimiento acerca de los datos de entrada y salida, se puede iniciar la construcción del algoritmo.

Para construir un algoritmo se emplea un diseño descendente, por lo tanto el algoritmo puede emplear módulos de programa que serán fáciles de analizar.

Cada uno de estos módulos pueden modificados constantemente de tal manera que se ajusten cada vez más a las necesidades de nuestro programa.

Luego es necesario representar el algoritmo a través de algunas herramientas que mencionaremos en la siguiente sección.

2.3. REPRESENTACIÓN DE ALGORITMOS

El algoritmo puede ser representado de diversas maneras, para ello emplearemos algunas de las denominadas herramientas de programación: Diagrama de flujo, Diagrama N-S, Pseudocódigo. La representación del algoritmo recurriendo al código de un Lenguaje de Programación tal como el C++, hace que se tenga que conocer necesariamente la sintaxis y características de este,por ello en forma

general e independientemente del lenguajede programación, es mejor representarloempleando algunas de estas herramientas.

En este libro orientaremos el diseño del algoritmo para su representación en el C++.

2.3.1. DIAGRAMA DE FLUJO

Es una técnica que sirve para representar un algoritmo a través de símbolos y representa el orden de la secuencia de los algoritmos a través de líneas de flujo, representadas como flechas.


Existen unos pocos símbolos denominados principales que permite representar un algoritmo en forma general, pero además se cuenta con un conjunto de símbolos adicionales que se emplean para situaciones especificas.

2.3.2. DIAGRAMA N-S

El diagrama Nassi – Schneiderman, para abreviar diagrama N-S, cumpletambién la función 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. PSEUDOCÓDIGO

Representa al algoritmo, en forma de palabras y frases del lenguaje natural, en nuestro caso el español. El Pseudocódigo a de estar sujeto a ciertas reglas que mencionaremos oportunamente, de tal manera que permitan expresar nuestro algoritmo de manera fácil y flexible.


CAPITULO TRES

CARACTERISTICAS DEL C++

3.1. CARACTERÍSTICAS

El lenguaje de programación C++ se emplea para escribir sistemas de operativos, compiladores, programas ensambladores, programas de bases de datos, sistemas expertos, etc. Y sus características son:

Es de propósito general;

Es un lenguaje de alto nivel como: PASCAL, BASIC, etc;

Es un lenguaje estructurado, pues contiene las estructuras básicas de composición, selección 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 programación modular: se pueden escribir programas independientes (módulos) constituyendo librerías de programas para ser utilizados posteriormente;


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, función, clase, estructura, etc. Su longitud significativa por defecto es de 32 caracteres y debe estar formado por:

El primer carácter debe ser una letra o el carácter subrayado (_),

Los siguientes caracteres al primero pueden ser letras, dígitos, o el carácter subrayado (no esta permitido los espacios),

El lenguaje C++ diferencia entre mayúsculas y minúsculas 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 programación C++ y entre algunas de las palabras reservadas tenemos:

Asm cdecl continue

AutoChar_cs

Break Class default

case const delete

Do enum far Friend inline long Pascalregister

Double_es_fastcallGotoIntNearPrivateReturn

_ds Extern float hugeInterrupt new protected_saveregs

else_exportforif_loaddsoperatorpublic_seg

short static this virtual

Signed Struct typedef void

sizeof switch union volatile

_ss template unsigned while


3.4. ESTRUCTURA DE UN PROGRAMA

El Lenguaje de programación C++ esta formado por funciones y estos a su vez están formados por bloques, la función main es la encargada de llamar a las otras funciones.

// Directivas y declaraciones main(){

//Directivas declaraciones//Sentencias

}función_1(){

//Directivas declaraciones//Sentencias

}//Más 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 variableo una función. La declaración de una función 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 MÁS DE UNA LINEA

/* Comentario */

El compilador ignora todo lo que se encuentra entre /* y */.

3.5.2. COMENTARIO EN UNA SOLA LÍNEA

// Comentario


El compilador ignora todo lo que viene después de // hasta el final de la línea.

3.6. BLOQUES

Cualquier grupo de instrucciones puede formar un bloque y ser tratado como una instrucción simple, para lo cual basta encerrarlo entre llaves.

{//Sentencias

}Se pueden anidar como se muestra a continuación

{//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 es tratado como un número entero.

3.7.2. TIPOS ENTEROS

Guardan números enteros positivos o negativos o cero, los tipos enteros son:

TIPO LONGITUD RANGOUnsigned char 8 bits 0 a 255Char 8 bits -128 a 127Enum 16 bits -32,768 a 32,767Unsigned int 16 bits 0 a 65,535Short int 16 bits -32,768 a 32,767Int 16 bits -32,768 a 32,767Unsigned long 32 bits 0 a 4,294,967,295


TIPO LONGITUD RANGOLong 32 bits -2,147,483,648 a 2,147,483,647

3.7.3. TIPOS DE PUNTO FLOTANTE

Guardan números positivos, negativos o cero con parte fraccionaria o punto decimal.

TIPO LONGITUD RANGOFloat 32 bits 3.4*10-38 a 3.4*1038)Double 64 bits 1.7*10-308) a 1.7*10308

Long double 80 bits 3.4*10-4932 a 1.1*104932

3.7.4. TIPO VOID

Es un tipo de dato que indica vacío (nulo). Cuando una función no devuelve un valor la función 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 numéricos, caracteres o cadenas que no ocupa memoria fuera del código del programa.

3.9.1. CONSTANTES ENTERAS

Son constantes sin parte fraccionaria y puede estar en sistema de numeración octal, decimal


o hexadecimal; por ejemplo en el sistema decimal: 34, 5678.

Constante hexadecimalLas constantes Hexadecimales y están precedidas por 0x, utiliza los dígitos del0..9 y las letras de A..F (para representar valores del 10..15); por ejemplo: 0xFF, 0x12.

Constante octalSon constantes en el sistema de numeración octal y están precedidos por 0 (cero), utiliza los dígitos del 0..7; por ejemplo:011, 004.

3.9.2. CONSTANTE CARÁCTER (CHAR)

Es una constante que esta formado por un solo carácter encerrado entre comillas o una secuencia de escape; por ejemplo: '\n','A'.

Las secuencias de escape que se pueden utilizar son:

S.ESC CARACTER DE SALIDA\a alerta (beep)\b Retroceso\f salto de pagina (alimentación)\n salto de línea\t tabulador horizontal\" comillas dobles\r retorno de carro\\ Backslash\? Signo de interrogación\DDD Código octal de un carácter\xHHH Código hexadecimal de un carácter\0 carácter nulo\' comilla simple\v Tabulación vertical

3.9.3. CONSTANTE CADENA

La constante cadena es un conjunto de caracteres y/o secuencias de escape que están encerrados entre comillas dobles. "A" es una cadena y 'A' es un carácter.


3.9.4. CONSTANTE DE PUNTO FLOTANTE

Son constantes numéricas con parte fraccionaria; por ejemplo: 12.48, .24, -4.3E+38.

3.10.DEFINICIÓN DE CONSTANTES

Una constante no puede cambiar su valor cuando el programa esta en ejecución. 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.DECLARACIÓN DE VARIABLES

Toda variable para ser usada por un programa debe ser antes declarada y el formato a utilizar es:

[<almacenamiento>] <tipo> <identificador> [<=valor>];

< almacenamiento>: auto, static, register, extern. Si se omite asume auto.

<identificador>: Indica los nombres de las variables a definir y están separados por comas.

Ejemplos:

int contador=0;float sueldo, descuento, igv=0.18;

3.12.EXPRESIONES

Son valores, constantes, variables, llamada a una función o una combinaciones de los anteriores. Cuando


se mezclan variables de diferentes tipos en una expresión, C++ las convierte a un mismo tipo. C++ convertirá todos los operandos al tipo más grande según:

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) Si uno de los operandos es un long double el otro se convierte a long double.

b) Si uno de los operandos es double el otro se convierte a double.

c) Si uno de los operandos es long el otro se convierte a long.

EJEMPLO

d) Si uno de los operandos es unsigned el otro se convierte a unsigned.

char ch; int i; float f; double d;r=(ch / i) + (f * d) - (f + i);

int double double double

int double double

double

double

En la conversión, el tipo char ch es convertido a int y el float f es convertido a double. Luego según los operandos se van modificando los tipos hasta obtener double.

3.13.CONVERSIÓN DE TIPOS

Para forzar el tipo de una expresión utilice:

(tipo) <expresión>


Ejemplo:

float res;

int num=13;

i=(float) num/2; /* i toma el valor de 6.5 */

/* Primero num se cambia al tipo float y luego efectua la operación */


CAPITULO CUATRO

OPERADORES BÁSICOS

4.1. OPERADORES ARITMÉTICOS

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 EJEMPLO OBSERV. PRECEDENCIA( ) Agrupación (3+5) 1- Menos unitario -3 2+ Más unitario +3 2++ Incremento a++ a=a+1 2-- Decremento a-- a=a-1 2* Multiplicación 4*3 3/ División 4/3 3% Modulo 4%3 3+ Suma 4+3 5- Resta 4-3 5

Cuando el operador de división se aplica a un operando de tipo entero el resultado es de tipo entero, ejemplo3/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. Sólo es aplicado a datos de tipo entero.

El operador ++ o -- puede ir delante o después del operando. Cuando va delante del operando primero incrementa o decrementa y luego utiliza el nuevo valor del operando. Cuando va después 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 línea es equivalente a:

a x a 3;

x

a 1;

a 3;

Ejemplo del uso de ++ después 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 y a 2;

a

a 2;

a 1;

4.2. OPERADOR DE ASIGNACIÓN

Estos operadores son utilizados para asignar un valor a una variable y pueden ser:


4.2.1. IGUAL (=)

Variable = <Valor>;El valor puede ser una constante, una variable o una expresión.

Ejemplos:

saldo = 567.89;car = ‘A’;edad = 20;

4.2.2. ASIGNACIÓN MÚLTIPLE

Permite asignar un valor o expresión a más de una variable.

variable_1=variable_2=…=variable_N=expresión;

Ejemplo:

x=y=3*2;

4.2.3. ASIGNACIÓN RELATIVA

variable <operador> = Expresión

El operador puede ser cualquier operador aritmético y es equivalente a:

variable = variable operador expresión;

OPERADOR EJEMPLO OBSERVACIONES+= x+=5; x=x+5;-= x-=5; x=x-5;*= x*=5; x=x*5;/= x/=5; x=x/5;%= x%=5; x=x%5;

Ejemplo:

x += 5; //Equivalente a x=x+5; y -= 3; //Equivalente a y=y+3; z = 2; //Equivalente a z=z*2;


4.3. OPERADORES DE RELACIÓN

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 EJEMPLO PRECEDENCIA> mayor que 4>12 1>= mayor o igual que 4>=12 1< menor que 4<12 1<= menor o igual que 4<=12 1== igual que 4==12 2!= diferente de 4!=12 2

4.4. OPERADORES LÓGICOS

Los operadores lógicos dan como resultado verdadero o falso. Recuerde que en "C++" todo numero diferente de cero es verdadero y cero es falso.

OPERADOR DESCRIPCION EJEMPLO PRECEDENCIA! No lógico !(4>12) 1&& y lógico (4>12)&&(8>12) 2|| o lógico (4>12)||(8>12) 3

El resultado de los operadores lógicos se resume en la siguiente tabla:

p q !p !q p&&q p||q1 1 0 0 1 11 0 0 1 0 10 1 1 0 0 10 0 1 1 0 0


CAPITULO CINCO

SALIDA / ENTRADA ESTÁNDAR

5.1. SALIDA/ENTRADA ESTÁNDAR 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 inserción 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 carácter del teclado

}


Ejemplo 2

//programa que suma dos nùmeros#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 través del flujo de entrada cin. El objeto cin es un objeto predefinido en C++ que corresponde al flujo de entrada estándar. Este flujo representa datos que proceden del teclado. El operador >> se denomina también de extracción o de lectura de. Toma el valor del objeto flujo de su

izquierda y lo sitúaa en la variable situada a su derecha. Su formato es:

cin >>variable_1>>variable_2>>…>>variable_n;

Ejemplo 1:

/* Programa que suma dos nùmeros leidos del teclado */

#include <iostream.h>

main(){ int x,y,suma;

cout << "Ingrese dos nùmeros : ";cin >> x >> y;suma=x+y;cout<< "\n la suma de "<< x <<" mas "<<y <<" es " <<suma;

}


Ejemplo 2:

/* Programa que suma convierte de Farenheit aCelsius */#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;

}


CAPITULO SEIS

SENTENCIAS DE CONTROL

Las sentencias de control son una parte imprescindible dentro de un lenguaje de programación. Son aquellas que determinan secuencia de las sentencias a ejecutar.

6.1. SENTENCIA if

Expr

SIN0

Sentencia

Si la expresión es diferente de CERO ejecuta la sentencia y continua con la sentencia que sigue a if.

if (expresión) sentencia;

Ejemplo 1 : El siguiente programa determina el número mayor de dos números ingresados por el teclado.


#include <iostream.h>void main(){

float num1,num2,mayor;

cout <<"Ingrese dos números : ";cin >> num1 >> num2;mayor=num1;if(num2>num1) mayor=num2;cout <<"El mayor es : "<<mayor<<endl;

}

Explicación

Después del ingreso de los dos números se asume que el mayor es num1, pero la condición de la sentencia if evalúa si num2 es mayor que num1 y si la condición es verdadera el mayor es num2.

Ejemplo 2 : El siguiente programa determina el valor absoluto.


float num;

cout <<"Ingrese el número : ";cin >> num;if(num<0) num=-num;cout <<"El valor absoluto : "<<num<<endl;

}

Explicación

El numero ingresado se evalúa 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 números ingresados.


int a,b,c,t;

cout<<"Tres números 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;

}

Explicación


Los números ingresados son a, b y c. Utilizando el algoritmo de la burbuja para tres números, que consiste:En comparar si el primer numero es mayor que elsegundo 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 condición se intercambian sus valores. Al final a, b y c contienen los valores ordenados ascendentemente de los números 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 números 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 ejecución 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 están encerrado entre llaves formando un bloque de sentencias.

SI Expr NO

Sentencia_1 Sentencia_2

Si la expresión es diferentede CERO ejecuta la sentencia_1, sino ejecuta la sentencia_2. En ambos casos continua con el flujo del programa.


if (expresión) sentencia_1;else sentencia_2;

Ejemplo 1 : Programa que determine el salario semanal a pagar a un trabajador. Por trabajar más 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.


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

Explicación

La sentencia if evalúa si el trabajador tiene mas de 40 horas (horas>40) para determinar si tiene horas extras. Si tiene horas extras calculasu pago debido a las horas extras ((horas-40)*1.5*p_h) y su pago normal por las40 horas (40*p_h). Si no tiene horas extras para calcular su pago se multiplica simplemente el número de horas trabajas por pago por hora (horas*p_h).

Ejemplo 2 : Programa que determina si un año es bisiesto. Un año es bisiesto si es múltiplo de 4. Los años múltiplos de100 no son bisiestos salvo que lo seantambién de 400; por ejemplo: 1984 y2000 son bisiestos, pero 1800 no esbisiesto.


int anno,sw=0;

cout<<"Año : ";


cin>>anno;

if(anno % 4==0){ sw=1; if(anno%100==0&&anno%400!=0)

sw=0;}if(sw) cout <<"Año bisiesto";

else cout<<"Año no bisiesto";cout<<endl;

}

Explicación:

En el programa sw=0 significa que el año no es bisiesto y sw=1 significa año bisiesto.

Se asume que el año es no bisiesto (sw=0) y si es múltiplo de cuatro (anno % 4==0) sw cambia a1, lo que significa que el año es bisiesto. Los años múltiplos de 100 también son múltiplos de cuatro, pero no son bisiestos. Por esa razón, cuando los años son múltiplos 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 perímetro de un triángulo sise ingresan las medidas sus tres lados a, b y c. Para que los tres lados del triángulo cierren se debe cumplir: a<b+c, b<a+c y c<a+b.


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

}

Explicación:

Antes de calcular el perímetro se evalúa si los tres lados forman el triángulo.


expr==const_1 SI

NO Sentencia_1

expr==const_2 SI

NO Sentencia_2

expr==const_3 SI

...

...

...

Sentencia_3

expr==const_N SI

Sentencia_N NO

Sentencia_x

if (expresión_1) sentencia_1;else if (expresión_2) sentencia_2;else if (expresión_3) sentencia_3;......else if (expresión_n) sentencia_n;[else sentencia_x;]

Ejemplo 1 : La comisión sobre las ventas totales de un empleado es como sigue:

Si ventas < 50.00 unidades monetarias (u.m.) entonces no hay comisión. Si esta entre 50.00 u.m. y 500.00 u.m. incluidos, entonces la comisión es 10% de las ventas.Si las Ventas > 500.00, entonces la comisión es 50.00 u.m. mas 8% de las ventas superiores a 500.00.

El programa calcula la comisión cuando se ingresa las ventas.



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<<"Comisión: " << comision<<endl;}

Ejemplo 2 : Programa que calcula el monto a pagar por el consumo de energía eléctrica, si durante su ejecución se ingresa el consumo y el tipo de tarifa. Las tarifas son:

TIPO DE TARIFA

COSTO (U.M./Kw-h)

1 2.302 8.253 6.424 5.805 9.65


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

}

Explicación:

En el programa según el tipo de tarifa se determina la tarifa correspondiente y al multiplicar el tipo de tarifa por el consumo se


obtiene el monto a pagar. Además, 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, sólo si la tarifa existe se calcula e imprime el monto a pagar, caso contrario se imprime “La tarifa no existe”.

6.2. SENTENCIA switch

Expr

Constante_1 Constante_2 Constante_n default

Sentencia_1 Sentencia_2 ..... Sentencia_n Sentencia_x

El switch es una forma sencilla de evitar largos, tediosos y confusos anidamientos de else-if, esta sentencia proporciona una estructura lógica y clara para bifurcación múltiple.

switch(expresión){case constante_1 : sentencia_1; break;case constante_2 : sentencia_2; break;case constante_3 : sentencia_3; break;

.

.case constante_n : sentencia_n; break;[default : sentencia_x;]

}

La sentencia switch evalúa el valor de la expresión y según ese valor determina el flujo del programa. Si el valor de la expresión 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 expresión 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 ocasionaría que todas las sentencias que están debajo de la constante que tome el valor de la expresión se


ejecuten hasta encontrar un break o el final de switch; por ejemplo: si la expresión es igual a la constante_2 se ejecutarían la sentencia_2, la sentencia_3, así sucesivamente hasta encontrar un break o el final de la sentencia switch.

Ejemplo 1 : Programa que calcula el monto a pagar por el consumo de energía eléctrica, si durante su ejecución se ingresa el consumo y el tipo de tarifa. Las tarifas son:

TIPO DE TARIFA

COSTO (U.M./Kw-h)

1 2.302 8.253 6.424 5.805 9.65


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 categoría (A,B,C) y su año de ingreso. Luego calcula su nuevo sueldo, según:

Categoría "A": 15% para los que ingresaron antes de 1980 y 12% para el resto.


Categoría "B": 20% para los que ingresaron antes de 1980 y 17% para el resto.Categoría "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 Año:”; cin>>anno;cout<<"Ingrese Categoría:”;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':



break; case 'C': case 'c':



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 condición, pero si el bucle se ejecuta indefinidamente se forma un bucle infinito. Un bucle infinito se forma generalmente por un error lógico de programación.

Las sentencias repetitivas en C++ son: while, do while y for.


6.4. SENTENCIA while

Expr

SI

N0Sentencia

Primero evalúa la expresión (expr), si la condición es verdadera (diferente de cero) entonces la sentencia es ejecutada, caso contrario pasa el control a la sentencia que sigue a la sentencia while.

Después de la ejecución de la sentencia la condición nuevamente es evaluada y se procede como en el caso anterior.

Para que la sentencia se ejecute por lo menos una vez la condición por lo menos una vez debe ser verdadera.

while (expresión) sentencia;

Ejemplo 1 : Programa que imprime los n números consecutivos.


int n,i;

cout<<"Ingrese el valor de n: ";cin >> n;i=0;while (n>i){ i++;

cout<<i<<"\n";}

}

Explicación:

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 condición de while n>i, ó 3>0 se cumple por lo:Hacer i=1

Imprimir el valor de i=1 y un cambio de líneaLa condición de while n>i, ó 3>1 se cumple por lo:Hacer i=2Imprimir el valor de i=2 y un cambio de líneaLa condición de while n>i, ó 3>2 se cumple por lo:Hacer i=3

Imprimir el valor de i=3 y un cambio de líneaLa condición de while n>i, ó 3>3 no se cumpleFin del programa

Ejemplo 2 : Programa que imprime los divisores de un numero natural


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

}}

Explicación:

Para determinar los divisores de n: se divide n entre los números consecutivos de 1 hasta aproximadamente la mitad de n. Si al dividir n entre uno de los números consecutivos el residuo es cero

significa que este numero consecutivo es divisor de n. Es decir por cada numero consecutivo se debe determinar sies divisor de n.

En el programa en la variable i se generan los números consecutivos y con la

sentencia if (n%i==0) se determina si i es divisor, la

condición determina si n entre i tiene residuo cero.

Ejemplo 3 : Programa que determina si un numero natural es primo. Un numero es primo si


sólo es divisible por la unidad y por si mismo.


int n,d;

cout <<"Numero natural : ";cin >> n;d=2;while(d*d<n && n%d!=0) d++;if (d*d>n)

cout<< "Es primo"<<endl;else

cout<< "No es primo"<<endl;}

Ejemplo 4 : Programa que imprime los factores primos de un numero natural.


int n,d=2;

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 números primos indicados comenzando de1. El valor de n es ingresado.


int n,d,i,cant;

cout<<"Cantidad de números 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++;

}}

}


6.5. SENTENCIA do while

Sentencia

SI

Expr

NO

La sentencia se ejecuta mientras la expresión sea verdadera (diferente de cero). La expresión es evaluada después que se ejecuta la sentencia. La diferencia fundamental entre while y do while es que la segunda se ejecuta por lo menos una vez, sea cual sea el resultado de expresión.

do sentencia while(expr);

Ejemplo 1 : Programa que obtiene el producto de dos números enteros positivos mediante sumas.


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 Máximo Común Divisor (MCD) de dos números naturales utilizando el algoritmo de euclides.

El algoritmo consiste: los números 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 números si


5 1 570 12 1010 2 0

1 1 260 36 24 12 014 12 0

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 máximo común divisor es igual al

último divisor, por ejemplo:MCD(70,12)=2 MCD(60,36)=12


int n1,n2,mcd,res;

cout<<"Ingrese 2 números enteros: ";cin>>n1>>n2;do{

}

6.6. SENTENCIA for

res=n1%n2; n1=n2; n2=res;

}while(n2);mcd=n1;cout<< "El MCD es "<<mcd<<endl;

Expr_1

Expr_2

SI

SentenciaN0

Expr_3

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 ejecución de la sentencia. La


expr_3 es comúnmente el contador del bucle y es ejecutado después de la ejecución de la sentencia. Tanto expr_1, expr_2 y expr_3 pueden contener más de una expresión separados por comas.

for(expr_1;expr_2;expr_3) sentencia;

No es imprescindible indicar las TODAS las expresiones dentro del paréntesis 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 términos de:

s1 2

2 3

3...

4#include <iostream.h>void main(){

int i,n; float s;

cout<<"Cantidad de términos: ";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 11

2

1 1...

1

3 4 n


int n,i; float s;

cout<<"Cantidad de términos: ";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 términos de:

s 11

2

1 1...

3 4

#include <stdio.h>#include <conio.h>#include <iostream.h>void main(){

int n,i; float s,t;

clrscr();cout<<"Cantidad de términos: ";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:

s1 1

1 A 1 2 A1

1 3A...

1

1

n * A

#include <iostream.h>void main()

{ int n,i; float s,t,a;

cout<<"Cantidad de términos: ";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 términos de la serie de fibbonacci menores que n.

Los términos de la serie de fibbonacci se obtienen sumando los dos términos que le antecedentes así: 1, 2, 3, 5, 8, 13, ... Los términos 1 y 2 son los números iniciales y partir de ellos se calculan los demás términos.



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

for(expr1;expr2;expr3){ sentencia_1; sentencia_2;... break; sentencia_n;

}

sentencia_siguiente;

La sentencia break es usada dentro de un bloque while o do while o for o switch, y fuerza la finalización de la sentencia donde es usada.

Ejemplo : Programa que lee un número de punto flotante y lo imprime redondeado a dos decimales. El usuario decide si quiere continuar.


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

for(expr1 ;expr2 ;expr3){ sentencia_1; sentencia_2;... continue; sentencia_n;

}sentencia_siguiente;

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 números pares comprendidos de 1 a 20.


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 programación estructurada.

Ejemplo : Programa que suma los números ingresados, el ingreso termina cuando el ingreso es cero.



int n,s=0;

inicio:cout<<"Ingrese un número : ";cin>>n;s+=n;

if(n) goto inicio;cout<<"La suma es: "<<s<<endl;

}

Explicación:

Si n!=0 (verdadero) vuelve a ejecutar la sentencia a la etiqueta inicio.

6.10.PROGRAMAS DE APLICACIÓN

Ejemplo 1 : Programa que lee 3 números y los imprime en orden descendente.


int a,b,c;

cout<<"Ingrese 3 números 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;

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

Ejemplo 2 : Programa que resuelve una ecuación de segundo grado de la forma:

ax 2bx c 0

La discriminante es:

d b 24ac

Si la discriminante es mayor o igual que cero(d>=0) tiene raíces reales, caso contrario


2

tiene raíces complejas. Las raíces se obtienen con:

xb b 4ac

2a#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;

}

Ejemplo 3 : Programa que permita jugar a las adivinanzas. El usuario tiene que elegir un entero de un solo dígito. 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 información se debe determinar el número.


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”; 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 calificación 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.


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 una fecha(dd/mm/aaaa) es correcta.


int anno,mes,dia,ok=0,bisiesto=0;

cout<<"Fecha (dd mm aaaa):";cin>>dia>>mes>>anno;//Determina si el año es bisiesto if(anno % 4==0){

bisiesto=1;if(anno%100==0&&anno%400!=400)


bisiesto=0;}//En función al mes verifica si el//numero de días 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 números en un línea, así:

1 2 34 5 6......97 98 99


int i;

for(i=1;i<=99;i++){ cout<<i<<”\t”; if(!(i%3)) cout<<"\n";

}}

Ejemplo 7 : Programa donde se ingresa un numero del1 al 99 y luego lo imprima en letras.

#include <string.h>#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 población 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.


float pa,pb,ta,tb;int i;

//Poblacion Apa=52e+6;//Poblacion Bpb=85e+6;//Tasa de crecimiento Ata=0.06;//Tasa de crecimiento Btb=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 número en base 2 y luego imprima su equivalente en decimal. Durante el ingreso solo se lee los dígitos 0 y 1, otro dígito es ignorado.


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//Conversión 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";

}

Ejemplo 10 : Programa que imprime los “n” primeros números perfectos, si “n” es ingresado. Un numero perfecto es un entero positivo que es igual a la suma de sus divisores, excluido si mismo.



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 años, meses y días.


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;if(anno_n%100==0 &&

anno_n%400!=0) bisiesto=0;

}switch(mes_n) {



diam=31; break;case 4: case 6: case 9:case 11:

diam=30; break;case 2 :

if(bisiesto) diam=29;else diam=28;break;

}

}}else{

edad_d=dia_a+diam-dia_n;

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


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<<" años"; cout <<" y "<<edad_m<<" meses"; cout <<" y "<<edad_d<<" dias\n";

}elsecout<<"Error en el ingreso\n";

}

Ejemplo 12 : Programa que imprime todos los números de tres dígitos CDU, tales que si se invierte el orden de sus cifras aumentan en 297.



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 reunión hubo 820 apretones de mano. Sabiendo que cada persona saluda a otra sola una vez y a todas las demás. Este programa determina cuantas personas asistieron a la reunión.


int s,i;

s=0; i=0; dos+=++i; while(s!=820); cout<<"Asistieron:"<<i+1<<endl;

}

Ejemplo 14 : Programa que lee un numero entero y luego lo imprime sin los dígitos mayores a 5. Por ejemplo, si se ingresa456712 se imprime 4512.


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;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 interés compuesto por un tiempo de "n" años. Cada "x" años se deposita un mismo monto de dinero ”p” y cada "y" años se retira un mismo monto de dinero “q”. Tanto el deposito como el retiro se realizaran al finalizar el año. Programa que imprime el año y el capital acumulado al final del año considerando el deposito y/o retiro efectuado.


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

}}

Ejemplo 16 : Programa que imprime los números capicúas comprendidos entre 0 y 1000. Un numero es capicúa si al invertir sus cifras sigue siendo el mismo numero.


Por ejemplo, 121 es capicúa porque al invertir sus cifras sigue siendo 121.


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 números 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 entre2, si el segundo factor es impar seacumula el primer factor donde se vaobtener el resultado. El procesotermina cuando el segundo factor sehace CERO. por ejemplo para multiplicar30 por 12:

primer factor

segundo factor

acumulador

30 12 060 6 0120 3 120240 1 360480 0 360


void main(){int f1,f2,producto=0;

cout << "Ingrese dos numeros: ";cin >> f1 >> f2;while(f2){

if(f2 % 2) producto+=f1;f1*=2;f2/=2;

}cout << "Producto=" << producto<<endl;

}


17 24 1 8 1523 5 7 14 164 6 13 20 2210 12 19 21 311 18 25 2 9

Ejemplo 18 : Programa que visualiza el cuadrado mágico de orden impar n, comprendido entre 3y 17. Un cuadrado mágico se compone de números enteros comprendidos

entre 1 y n2. La suma de los números que figura en cada línea, cada columna y cada diagonal son idénticas.

Regla de construcción:El número 1 se coloca en la casilla central de la primera fila.Cada número siguiente se coloca en la fila anterior y columna siguiente.Después de ubicar un número múltiplo 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.


int i,n,x,y;

do{

cout<<"Dimensión 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 triángulo y determina el tipo de triángulo.

#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 triángulo es "; if(a==b && b==c)

cout << "equilátero";else {

if (a==b || a==c || b==c)cout<<"isósceles"; 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 rectángulo \n";

else cout<<"\n";}

}else {

cout<< "No forman un triángulo";}cout<<endl;

}


CAPITULO SIETE

SUBPROGRAMAS

7.1. SUBPROGRAMAS O SUBRUTINAS

Un subprograma es un conjunto de sentencias cuya ejecución se invoca mediante su nombre. En la mayoría de los lenguajes de programación se dividen en: procedimientos y funciones, pero en el lenguaje C++ sólo esta permitido las funciones. Al conjunto de subprogramas que vienen definidos en las librerías del compilador, se les conocecomo subprogramas del sistema. Los programadores pueden crear sus propios subprogramas según sean sus necesidades, a estos se les conoce como subprogramas definidos por el usuario. Este capitulo, trata principalmente sobre las técnicas utilizadas en la construcción de funciones y sobre las funciones definidas por el usuario.

7.2. ¿CUÁNDO UTILIZAR UN SUBPROGRAMA?

Existen dos razones importantes porque se deben utilizar estas funciones, ellas son:

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


al subprograma y se crea un subprograma con las sentencias repetidas o similares.

b) En un programa, una parte se encarga de un trabajo específico. Esto se consigue aplicando las técnicas Diseño descendente y programación modular, que se tratan más adelante.

7.3. DISEÑO DESCENDENTE (TOP DOWN)

Problem a

Subproblema 1 Subproblema 2 Subproblema 3

Subproblema2.1

Subproblema2.2

El diseño descendente, también es conocido como diseño TOP DOWN, consiste en dividir un problema1 en subproblemas y estos en otros subproblemas que sean fáciles de solucionar. Una vez resuelto cada parte se integran para obtener la solución de todo el problema. En este método se analizade las características generales a características específicas (descomposición jerárquica). A cada nivel o paso de refinamiento se le conoce como stepwise. El diseño descendente es utilizado en la solución de problemas de gran complejidad.

Para descomponer el problema, para cada subprograma se debe contestar: ¿Qué hace? y ¿Cómo lo hace?. Los niveles de descomposición dependen de la complejidad del problema. Se recomienda parar la descomposición cuando el subproblema se refiere a la solución de algo específico o es fácil de solucionar, el programador conforme se va familiarizando con el problema encontrará la descomposición óptima.

7.3.1. EJEMPLO

Elaborar el diseño 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 solución del problema será mediante la elaboración del problema.


a) Por cada hora extra se le paga 25% más que una hora normal.

b) Bonificación por movilidad (movil) igual a 1000.

c) Bonificación suplementaria (b_sup) igual al 3% del sueldo básico (sueldo).

d) La bonificación total (bonif) es la suma de todas las bonificaciones que percibe.

Asimismo, el trabajador esta sujeto a los siguientes descuentos:

e) Las tardanzas y faltas se descuentan con respecto a remuneración computable. La remuneración computable es igual al sueldo básico más la suma de todas las bonificaciones excepto la bonificación por horas extras.

f) El total de descuentos (descuentos) se obtiene sumando todos los descuentos.

ALGORITMO GENERAL

I. Ingreso de datosII. Cálculo el sueldo a pagarIII. Imprime boleta de pago.

PRIMER REFINAMIENTO

I. Ingreso de datos

I.1. Ingreso del nombre del trabajador (nombre) y sueldo básico (sueldo).

I.2. Ingreso de días de faltas (dias_falta) y minutos de tardanzas (minutos).

I.3. Ingreso de horas extras(h_extras).

II. Cálculo el sueldo a pagar

II.1. Cálculo de bonificaciones(bonif)


II.2. Cálculo 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 extras(p_h_extras):

1.25*h_extras*sueldo/30/8

Para incrementar 25% a X, es suficiente multiplicar a la cantidad por 1.25 porque100% de X + 25% de X es 125%de X que a su vez es igual a1.25*X.

El pago por una hora normal es igual al resultado de sueldo/30/8, donde sueldo es el sueldo básico. Note que el sueldo básico corresponde al mes y esta dividido entre30 días que tiene el mes yeste resultado es divididoentre 8 que es la cantidadde horas que se trabajadurante un día.

II.1.2. movil=10000

II.1.3. b_sup=0.03*sueldo

II.1.4. bonif=movil+b_sup+p_h_extras

II.1.5. Remuneración computable(r_computable):

sueldo+movil+b_sup

II.2. CALCULO DE DESCUENTOS:

II.2.1. r_minima=sueldo+bonif


II.2.2. faltas=r_computable/30*dias_falta.

Para obtener el descuento por falta: la remuneración computable se divideentre la cantidad de días que tiene el mes, note que el mes comercial tiene 30 días.

II.2.3. tardanzas=r_computable/30/8/60*minutos. Para obtener el descuento por la tardanza: la remuneración computable se divide secuencialmente entre la cantidad de días que tiene el mes, entre la cantidad de horas trabajadas por día y entre la cantidad de minutos que tiene una hora.

II.2.4. descuentos=faltas+tardanzas

Aquí paramos la descomposición del problema.

7.4. PROGRAMACIÓN MODULAR

La programación complemento del

modular se toma muchas veces como diseño descendente. La programación

modular consiste en dividir un programa en módulosindependientes, buscando un sólo punto de entrada y uno de salida. Como complemento del diseño descendente proporciona módulos funcionales (todos los elementos contribuyen a una sola tarea) y están organizados en niveles de jerarquía.

7.4.1. MODULO

Es una parte de un programa (subprograma) que cumple con una función 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 módulo para lograr su propósito.


Un módulo en el Lenguaje de Programación Pascal o en Foxpro puede ser un procedimiento o una función y en Lenguaje C++ es una función. En resumen, un módulo puede ser un subprograma.

7.4.2. CRITERIOS A CONSIDERAR EN PROGRAMACIÓN MODULAR

a) Debe tener una sola entrada y una sola salida.

b) Debe realizar un trabajo específico.

c) Debe tener la máxima independencia y la máxima cohesión (todo lo suficiente para realizar su trabajo).

d) Debe estar separados las funciones de entrada y/o salida de las de cálculo.

7.4.3. FASES DE LA PROGRAMACIÓN MODULAR

a) Dividir el problema utilizando el diseño descendente (TOP-DOWN).

b) Analizar los parámetros a ser enviados y ha ser devueltos.

c) Diseñar el módulo.

d) Montaje en el sistema en forma ascendente(BOTTOM-UP).

7.5. DEFINICIÓN DE FUNCIONES

Se compone de la cabecera de la función (prototipo de una función) seguido por el cuerpo de la función. Cuyo formato es:

<Tipo> Nombre_f (t1 p1, t2 p2,…,tk pk){

Donde:

<cuerpo de la función>}

<tipo> Es el tipo de valor que ha de devolver la función. Si la


función no retorna ningún valor entonces el tipo es void.

Nombre_f Es el nombre de la función.

t1, t2, …, tk Son los tipos de datos de los parámetros.

p1, p2, .., pk Son los parámetros. Un parámetro es una variable utilizado para enviar y/o recibir datos.

Si la función devuelve un valor debe utilizarse la sentencia return cuyo formato es:

return (expresión)

return puede situarse en cualquier punto del cuerpo de la función y provoca la salida inmediata de la función retornando el valor evaluado en la expresión. Si se omite la expresión, return retorna a la función que lo llamo y no devuelve ningún valor.

7.5.1. DECLARACIÓN DE PROTOTIPOS

El prototipo de una función tiene por finalidad indicar al compilador el tipo de valor que devuelve, así como el número y tipo de sus parámetros. En C++ por cada función 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 función. Si la función no retorna ningún valor entonces el tipo es void.

Nombre_f Es el nombre de la función.


t1, t2, …, tk Son los tipos de datos de los parámetros.

p1, p2, .., pk Son los parámetros.

OBSERVACIONES:

a) Si en la definición o el prototipo de una función se omite el tipo de dato que retorna entonces por defecto el compilador asume el tipo int.

b) Si la función no retorna un valor se define como tipo retornado al tipo void y la función no necesita usar la sentencia return.

c) Si no se usa la sentencia return la función se ejecuta todo el cuerpo de la función y retorna a la siguiente línea de donde fue llamado.

7.5.2. LLAMADA A UNA FUNCIÓN:

En cualquier lugar del programa se puede llamar a la función, incluso puede llamarse a si mismo. Para llamar a una función se utiliza el siguiente formato:

Nombre_f(E1, E2,…, Ek)

Donde:

E1, E2, …,Ek Son expresiones que proporcionan los valores a los parámetros, en el orden indicado.

La lista de parámetros debe estar de acuerdo al tipo y cantidad de parámetros definidos en la función. El primer parámetro de la lista corresponde al primer parámetro de la definición, el segundo parámetro de la lista al segundo parámetro de la definición, así sucesivamente.

Ejemplo 1 : Programa que imprime los números primos que existen desde 1 hasta 100.



//declaracion de prototipos primo(int n);

void main(){//función 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 función hipotenusa para calcular la hipotenusa de un triángulo rectángulo si se proporcionan como parámetros 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);

}


7.5.3. PARÁMETROS POR VALOR

Hasta al momento solo se han utilizado parámetros por valor. Se dice que los parámetros 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 parámetros que son pasados por valor solo pueden cambiar su valor momentáneamente dentro de la función y a la salida de la función recuperan su valor de entrada. Cuando un parámetro es pasado por valor la función copia su valor y lo utiliza dentro de la función.

Un parámetro pasado por valor puede ser una constante, una expresión, una llamada a una función o una variable.

7.5.4. PARÁMETROS POR REFERENCIA

Se dice que los parámetros son pasados por referencia si estos se utilizan para suministrar datos de entrada y/o salida indistintamente. Esto significa que la función puede alterar el valor de entrada de las variables que son pasados por referencia. Por lo tanto, si la función debe modificar el valor de la variable pasada como parámetro y que esta modificación retorne a la función llamadora, entonces el parámetro debe ser pasado por referencia.

En este método, el compilador no pasa una copia del valor del argumento; en su lugar, pasa una referencia, que indica a la función donde existe lavariableen memoria. La referencia que una función recibe es la dirección de la variable. Es decir, pasar un argumento o parámetro por referencia es, simplemente, indicarle al compilador que “que pase la dirección del argumento”.

Una referencia se indica por el operador de dirección &.

Un parámetro pasado por referencia siempre tiene que ser una variable.


Ejemplo : El siguiente programa intenta cambiar el valor de dos números si el primero es mayor que el segundo, pero fracasa porque elparámetro pasado es por valor.


void intercambiar(int x,int y);

void main(){int x,y;

cout<<"ingrese 2 números: ";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 números: 5 3¿x= 5 y= 3

El siguiente programa si logra intercambiar los valores de las dos variables. Observe su implementación de la función intercambiar.


void intercambiar(int &x,int &y);

void main(){int x,y;

cout<<"ingrese 2 nùmeros ";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 números: 5 3¿x= 3 y= 5


7.5.5. ÁMBITO DE UNA VARIABLE

El ámbito de una variableson los lugares donde una variable es conocida. En C++ el ámbito esta definido por los bloques y la ubicación de las declaraciones.

Ejemplo : Programa que permite sumar los n números ingresados.


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 función 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 sólo pueden ser usadas dentro de este bloque. En conclusión el ámbito de "n" es toda la función main(), el ámbito de i, num y s es sólo el bloque de la sentencia if.


7.5.6. VARIABLES LOCALES

Se dice que un variable es local cuando sólo es conocido en un bloque determinado. Un bloque comienza con { y termina con }.

7.5.7. PÁRAMETROS FORMALES Y REALES

Los parámetros formales son variables locales usadas para definir de la función; por ejemplo: en la función máximo los parámetros 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 números:";cin>>n1>>n2>>n3;cout<<"Máximo : " << 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 parámetros reales son los datos que son enviados a la función y son utilizados en la llamada a la función; por ejemplo: en la llamada a la función máximo los parámetros reales son n1, n2 y n3.

Los parámetros reales tienen que coincidir con el número y el tipo de los parámetros formales, correspondiendo el primer parámetro real al primer parámetro formal, el segundo parámetro real al segundo parámetro formal, así sucesivamente.

7.5.8. VARIABLES GLOBALES

Se dice que una variable es global cuando es conocido en más de dos funciones. Es


recomendable minimizar el uso de variables globales porque accidentalmente puede ser modificado por una función produciendo resultados inesperados.

Ejemplo : El programa solicita un ángulo en grados sexagesimales en forma decimal, luego llama a la función radian() que convierte el ángulo a radianes y llama a la función sexag() que convierte la forma decimal del ángulo a grados, minutos y segundos sexagesimales.

Función radian()

Para la conversion se utiliza la siguiente relacion:

radianes=sexagesimales*(3.1416/180)

Función sexag()

Se separa la parte entera y la parte fraccionaria del ángulo que esta forma decimal.

La parte entera corresponde a los grados.

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 por60: 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”;}

7.6. PROGRAMAS DE APLICACIÓN

Ejemplo 1 : Programa que halla la hipotenusa de un triángulo.

#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 parámetros 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 función 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);

}


Ejemplo 4 :

}

Programa que permita verificar si unafecha (dd/mm/aaaa) es correcta

#include <stdio.h>

int bisiesto(int);int fechaok(int,int,int);

3

Ejemplo 3 : Programa que llama a la función raiz_cub e imprime la raíz cúbica de los números del 1 al 10. La función raiz_cub() calcula la raíz cúbica de un número entero y a esta a su vez llama a la función abs que se encarga de devolver el valor absoluto de un número de tipo double.

Algoritmo Newton-Raphson para calcular la raíz cubica de n:

Hacer x=n/10Mientras valor_absoluto(x*x*x-n)>0.0001 hacer

x xn x

3 x 2

x es el valor de la raíz cúbica de "n"

double raiz_cub(double);double abs(double);#include<iostream.h>#include<math.h>double abs(double);/* Función 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;

void main(){


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 números y los ordena ascendentemente.


void cambiar(int &a,int &b);void main(){

int n1,n2,n3;

cout<<"Ingrese tres números :";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 número en base de 2 al 9 y lo convierte a otra base de 2 al9.

#include <iostream.h>#include <stdio.h>

long cnto10(long numero,int base); long c10ton(long numero,int base); long ingbasen(int base);long 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{

doc=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 librerías del lenguaje C++ utilizan los archivos de cabecera (archivos con extensión 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 código fuente del programa, su extensión es h (de header, cabecera en inglés). Cuyo formatos son:

#include <ruta\nomfich.h>. Hace queel archivo cabecera sea buscado sólo ruta indicada, si lo encuentra lo inserta, caso contrario genera un mensaje de error.

#include <nomfich.h>.- Hace que el archivo cabecera sea buscado en los directorio especificado para los archivos cabeceras, generalmente es el directorio es llamado


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 búsqueda, sino lo encuentra en ninguno de los directorios genera un mensaje de error.

Para llamar a una función de la librería del c++ es necesario utilizar la directiva#include con el nombre del archivo de la cabecera que le corresponde. Para las funciones matemáticas se usa #include<math.h>, para las funciones de cadena se usa#include <string.h>, etc. Para mayor información recurra al manual del lenguaje de programación.


CAPITULO OCHO

ESTRUCTURA DE DATOS: ARREGLOS

En los capítulos anteriores se ha definido y utilizado los tipos de datos fundamentales con los cuales se podía manejar datos enteros, de punto flotante o carácter. Imagínese 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, tendríamos que definir por lo menos 30 variables. Ampliando la situación anterior supongamos el caso en que se necesite conocer el promedio de la temperatura ambiente durante 5 años (aproximadamente 1825 días), y de acuerdo al razonamiento anterior, tendríamos que utilizar una variable por día para lo cual se necesita definir 1825 variables. Ampliando su imaginación suponga que usted comienza con la definición 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 solucionaría el caso anterior.

Un arreglo (array) es una colección 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.


8.1. ARREGLOS UNIDIMENSIONALES: VECTORES

Un arreglo unidimensional, o simplemente un arreglo, de N variables de algún 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 tamaño del arreglo o la cantidad de elementos(variables) que se utilizará en el arreglo.

Ejemplo:

int A[100]

El arreglo A consiste de la colección de variables A[0],…A[99] de tipo int, que son referidas por el nombre del arreglo y el correspondiente subíndice entre corchetes. 100 es la dimensión 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 tamaño del arreglo (N-1).


Indicaciones sobre arreglos:

Los datos de las variables componentes A[0],.., A[99], se almacenan unos a continuación de otros.

Para acceder a un elemento del arreglo utilizar el siguiente formato

Identificador [indíce del arreglo]

Ejemplo:

En el arreglo A, para almacenar el valor 5 en el índice 3 usar:

A[3]=5;

Para escribir el valor almacenado anteriormente usar:

cout<<A[3];

El nombre del arreglo es igual a la dirección de la primera variable del arreglo A[0]. Así A tiene el valor &A[0].

La dirección de cada componente A[i], dada por &A[i], también puede ser expresada por A+i


Ejemplo 1 : Programa que lee e imprime el contenido de un vector.


#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 vectorcout<<"El contenido del arreglo es :\n";for(i=0;i<N;i++)

cout<<A[i]<<"\n";}

Explicación:

Para la lectura del vector se debe recorrer cada una de las celdas por lo cual se hace una referencia a cada celda a través de sus índices (se usa la variable i), que toman valores de 0 a 4 a través de la sentencia for. Para la impresión de los elementos se debe recorrer también 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 arreglofloat 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


}

// calcula e imprime promedio prom=1.0*s/N; // multiplicar por 1.0 para

//obtener la división como//punto flotante

cout<<"El promedio del vector es : "<<prom;cout<<endl;

}

Explicación:

En la lectura del vector se agrega el acumulador s para guardar lasuma 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 división en punto flotante.

Ejemplo 3 : Programa quelee 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 V[N], int&may,int &men);int existe(int V[N], int valor);

void main(){ int A[N];// definimos el arreglo A de enteros

// para 10 elementosint 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];}}


// función que devuelve el mayor y el menor// para numeros entre -10000 y 10000void hallar_mayor_y_menor(int V[N], int&may,int &men){ int i; //indice del arreglo

may=-10000; // inicializamos con un valor// pequeño 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

//algún elementomay=V[i]; // del arreglo se toma ese

//elemento como mayor

if (men>V[i]) //si el menor es mayor que// algún elemento

men=V[i]; // del arreglo se toma ese// elemento como menor

}}// fin de la funcion hallar_mayor_y_menor

// función que calcula cuantas veces existe un// valor en un vectorint 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

//algún elemento del veces++; //arreglo se incrementa

// vecesreturn(veces);

}

Explicación:

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 función main() se realiza la lectura delcontenido del vector a través de la función leer_vector(A), donde se envía la variable arreglo A como un parámetro por referencia. Para calcular el mayor y menor elemento usamos la función hallar_mayor_y_menor(A, ma, me) que envía 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á función. Además se envía el arreglo A y un valor a la función existe que permitirá obtener cuantas veces se repite el valor en el vector.

La función leer_vector(int V[N]), recepciona el arreglo A a través de la variable arreglo V


como un parámetro por referencia, debe notarse que no se necesita &, para tratar a V como un parámetro por referencia; porque es un arreglo y basta mencionar su nombre para tener la dirección del primer elemento. La lectura de los elementos se realiza en la instrucción for para lo cual utilizamos el índice del arreglo i definido como una variable local.

En la función 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 parámetros por referencia por lo que debe de utilizarse el &. En la función inicializamos may con –10000 para que tenga un valor pequeño de tal forma que se compare con los

elementos del arreglo y si algún 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 comparecon los elementos del arreglo y

si algún valor es menor que men se almacena este valor enmen. Al final del

recorrido del vector, men almacena al menor elemento. Los

valores del mayor y menor se devuelven a través de may y men que serán los mismos que ma y me respectivamente porque han sido pasados como referencia.

En la función 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 ningún elemento. El arreglo almacena datos enteros y de dimensión MAX (definido como constante).

#include <iostream.h>#define MAX 20int 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);

}


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 BIDIMENSIONALES: TABLAS / MATRICES

Es un conjunto de elementos, todos del mismo tipo, y se necesita especificar dos subíndices para poder identificar a cada elemento del arreglo. La representación 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.


M[0][0] M[0][1] M[0][2] M[0][3] M[0][4]

M[1][0] M[1][1] M[1][2] M[1][3] M[1][4]

M[2][0] M[2][1] M[2][2] M[2][3] M[2][4]

M[3][0] M[3][1] M[3][2] M[3][3] M[3][4]

Columna

4?

Columna

3?

Columna

2?

Columna

1?

Columna

0?

Fila 0 ?

Fila 1 ?

Fila 2 ?

Fila 3 ?

En las celdas del arreglo se muestra el uso de los subíndices, donde el primer subíndice representa a la fila y el segundo subíndice 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 el valor almacenado anteriormente usar:

Cout<< M[2][3];

Para almacenar/recuperar los elementos de un arreglo bidimensional tenemos dos formas:


Recorrido por filas:

M[0][0] M[0][1] M[0][2] M[0][3]

M[1][0] M[1][1] M[1][2] M[1][3]

Recorrido por columnas:

M[0][0] M[0][1] M[0][2] M[0][3]

M[1][0] M[1][1] M[1][2] 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";

}}


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 números naturales y cada una de las siguientes contiene la rotaciónde la fila anterior un lugar a la derecha. A continuación se muestra un cuadrado latino de orden 4 (N = 4).

1 2 3 4

4 1 2 3

3 4 1 2

2 3 4 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 latinoint n;cout<<"Ingrese orden : ";cin>>n;cuadrado_latino(a,n);//almacena los valores

//del cuadrado latinoescribir(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 ceroval=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";}

}


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 y[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];}


CAPITULO NUEVE

REGISTROS

Frecuentemente en nuestras actividades diarias empleamos datos que guardan alguna relación 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 algún producto, me importaría determinar quién es mi cliente, lo puedo hacer a través de su nombre, si le asigné un código también podría identificarlo a través de este, para visitarlo necesito su dirección y si deseo llamarlo pues necesito su número telefónico; adicionalmente podría también tener otros datos relativos a este cliente, como podría ser la fecha de su cumpleaños para enviarle una tarjeta, etcétera. 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 colección de datos o campos (código, nombre, dirección, número telefónico, fecha de nacimiento, etc.) acerca de una entidad (cliente), estos en conjunto pueden ser tratados como una unidad de información. 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, etcétera, tenemos una Base de Datos.


9.1. REPRESENTACIÓN DE REGISTROS

En el C++ para representar los registros empleamos en muchas ocasiones las estructuras y las uniones. La estructura es básica para la representación de los registros de una tabla de una base de datos y las uniones en una celda de una hoja de cálculo.

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 años 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 unión permite almacenar diferentes tipos de datos en una misma posición de memoria. Si por ejemplo tenemos cierto componente electrónico que podamos identificarlo a través de un número que tiene asignado o a través de su color (paracada color existe un equivalente numérico), entonces sería lo mismo identificarlo por su color o por su equivalente numérico (sería ilógico hacerlo por ambos); en consecuencia se puede utilizar una unión para ello, donde empleamos alternadamente el equivalente numérico o su color, pero no ambos.

9.2. ESTRUCTURAS

La estructura es una unidad que agrupa a una o más 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;

};


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 años y talla de este alumno. Luego el programa debe mostrar los datos de dicho alumno.

//Registra a un alumno empleando una//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 (años): "); scanf("%d",&alumno.edad); printf("\nIngrese la talla (metros): " ); scanf("%f",&alumno.talla);printf("\n");printf("El alumno %s tiene ", alumno.nombre); printf(" %d años de edad ", alumno.edad); printf(" y mide %5.2f metros\n",alumno.talla);

}

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 FernándezIngrese la edad (años): 20


Ingrese la talla (metros): 1.78

La salida será:

El alumno Fidel Fernández tiene 20 años de edad y mide 1.78 metros.

Note que para ingresar la cadena empleamos la función gets(). Esta función permite ingresar una cadena de caracteres hasta que se ingrese el equivalente a nueva línea (retorno de carro).

9.3. UNIONES

La unión en una misma posición de memoria de memoria puede almacenar diferentes tipos de datos, pero en un momento dado puede ser de un solo tipo, el tamaño de la unión es el mismo que se tiene para el tipo de dato mayor entre los diferentes tipos de la unión.

La sintaxis para crear una unión es la siguiente

union identificador{tipo1 ide1;tipo2 ide2;..tipoN ideN;

};

Como podemos observar, para definir la unión disponemos de la palabra reservada union, y entre las llaves se definen todos los tipos alternativos de la unión.

Ejemplo : Desarrolle un programa que demuestre que una unión puede manejar un solo tipo de dato a la vez. Tome como base para este programa el registro de un componente electrónico que se puede identificar a través de un número que tiene asignado o a través de su color (para cada color existe un equivalente numérico), es lo mismo identificarlo


por su color o por su equivalente numérico.

//Registra la identificación de un//componente empleando una unión#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("\nNúmero del componente: %d",

componente.numero);

printf("\n\nIngrese número del componente: "); scanf("%d", &componente.numero); printf("\nColor del componente: %s",

componente.color);printf("\nNúmero del componente: %d\n",

componente.numero);return 0;

}

La forma de definir una unión es similar a la de una estructura. Si al programa ingresamos los siguiente datos tenemos:

Ingrese color del componente: AZUL

Color del componente: AZUL Número del componente: 23105

Ingrese número del componente: 560

Color del componente: 0 UL Número del componente: 560

A la primera petición 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 número obtenemos un valor no predecible.

A la segunda petición de ingreso acerca del número del componente respondemos con el número 560, ahora tenemos la salida correcta para el número 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 parámetros por valor se tiene en la definición de la función la siguiente forma:

nom_funcion(struct tipo_estru par_var);

donde nom_function es el nombre que le damos a la función, struct es la palabra reservada para las estructuras, tipo_estru es variable tipo estructura que hemos creado y par_valor es un parámetro que se pasa por valor.

Para llamar a la función se aplica:

nom_funcion(var_estru);

donde var_estru es la variable tipo estructura que se pasa por valor.

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 años y talla de este alumno. Luego el programa debe mostrar los datos de dicho alumno empleando para ello una función.

//Registra a un alumno empleando//una estructura y la pasa a//una función para su salida

#include<stdio.h>




};

void impr_alu(struct estalumno cual_alu);


printf("Ingrese el nombre: ");gets(alumno.nombre);printf("\nIngrese la edad (años): "); 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(" años de edad y ");printf("mide %5.2f",cual_alu.talla);printf(" metros\n");

}

Para el paso de parámetros por variable o referencia se tiene en la definición de la función la siguiente forma:

nom_funcion(struct tipo_estru &par_ref);

donde nom_function es el nombre que le damos a la función, struct es la palabra reservada para las estructuras, tipo_estru es variable tipo estructura que hemos creado y par_ref es un parámetro que se pasa por referencia.

Para llamar a la función se aplica:

nom_funcion(var_estru);

donde var_estru es la variable tipo estructura que se pasa por valor.

Ejemplo : Modifique el ejemplo anterior de tal manera que el almacenamiento del


registro se haga a través de una función.

//Registra a un alumno empleando//una estructura en una función//y la pasa a otra función para su salida#include<stdio.h>



};

void ingr_alu(struct estalumno &cual_alu);

void impr_alu(struct estalumno cual_alu);


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 (años): "); 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(" años 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 quepermita registrar la fecha y hora de nacimiento de una persona. Respecto a la fecha se desea saber el día, mes y año de nacimiento. Sobre la hora se desea registrar la hora, los minutosy 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 año 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 más adecuada de aprovechar las estructuras es empleándolo 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 parámetros es por variable o referencia.

9.6. PROGRAMAS DE APLICACIÓN

EJEMPLO 1 : Escribir unprograma que permite realizar operaciones con números racionales. Un numero racional (p,q) donde p es el numerador y q 0 es el denominador.

Igualdad de números racionales: (p, q) = (p’, q’) p q’ = p’ q

Adición en los racionales:(p, q) + (p’, q’) = (p q’ + p’q , q q’)

Multiplicación de racionales(p, q) (p’, q’) = (p p’, q q’)



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 multiplicación 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 común usado

// para simplificar if (s.num>s.den) d=s.num; else d=s.den;//simplifica la fracción 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 día, mes y año de la visita, así como también 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]){


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 año: ");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]){


printf("%s",pe[i].nomb);printf(" de %d años \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 DIEZ

PUNTEROS

En este capítulo analizamos una de las características más poderosas del C++, el puntero (o apuntador), que son las capacidades más difíciles de dominar. Los punteros permiten simular las llamadas por referencia (uso de parámetros por referencia), crear y manipular estructuras de datos como son las listas enlazadas, colas, pilas y árboles; utilizando la asignación dinámica de la memoria.

10.1.CONCEPTOS BASICOS

Un puntero o apuntador es una variable que contiene la dirección de otra variable.

Puesto que un puntero contiene la dirección de un objeto, se puede acceder al objeto, "indirectamente" a través de él. Si x es una variable de tipo int, y px es un apuntador. El operador unario de dirección & devuelve la dirección de un objeto, por lo que la proposición

px = &x ;

asigna la dirección de x a la variable px y se dice que px "apunta a" x. El operador & sólo se puede aplicar a variables y a elementos de un arreglo.


px = &x; se puede representar de la siguiente forma:

px Variable x

direc de x valor

o en forma simplificada

px Variable x

valor

El operador unario de indirección * toma su operando como una dirección y accesa a esa dirección para obtener su contenido.

Para realizar que la proposición px = &x, es necesario declarar las variables que intervienen en el ejemplo como se muestra a continuación.

int x;int *px;

La declaración de x ya la hemos visto anteriormente. La declaración del apuntador px es nueva

int *px;

significa que px es una variable que contiene la dirección de una variable entera.

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 "<<x<<"\n\n";

cout <<"px es ";cout <<px<< " y &x es "<<&x<<"\n";

}

Explicació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 carácter nulo (‘\0’). En la memoria los caracteres de una cadena son almacenados uno detrás del otro como se muestra en la figura:

La siguiente proposición

char cad[10]=”Mi Perú”;

genera el siguiente arreglo de caracteres.

[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]

‘M’ ‘i’ ‘P’ ‘e’ ‘r’ ‘ú’ ‘\0’

Caracteres Nulo Sin usar

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 carácter.


Ejemplo 1 : Escribir un programa donde se ingrese un texto y luego determine el número 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 programa donde se ingrese un texto y luego imprima todas las palabras que inicien en una vocal y su longitud sea 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 1; else if (c=='I') return 1; else if (c=='O') return 1; else if (c=='U') return 1; else return 0;

}

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] [1] [2] [3] [4] [5] [6] [7]

‘M’ ‘i’ ‘P’ ‘e’ ‘r’ ‘ú’ ‘\0’

Caracteres Nulo

La diferencia de estas tres declaraciones con:

char cad[10]=”Mi Perú”;

es que el tamaño del arreglo se ajusta a la cantidad de caracteres de la cadena más el carácter nulo.


En C++ es apropiado decir que una cadena es un puntero, de hecho es un puntero al primer carácter 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.


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 paracontar cuantas palabras en total existen, además el programa debe calcular cuantos caracteres tiene la palabra más grande y la más corta. Para hacer el recorrido deberá usar sólo 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 más corta consta de 3 caracteres yla más

grande consta de 8 caracteres.


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 espacioif (may<cont-1) may=cont-1;if (men>cont-1) men=cont-1;

}


10.3.PUNTEROS A ESTRUCTURAS

Dada la declaración

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 C1 ... CKp

Para acceder al campo de una variable estructura a través del puntero a estructura usar:

p->C1, ... , p->CK

El uso más difundido de una variable puntero a estructura es en las estructuras de datos con asignación dinámica de la memoria los cuales se estudian en los siguientes items.

10.4.LISTAS ENLAZADAS

Una lista enlazadaes una colecciónlineal 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 vía un puntero al primer nodo de la lista. Se puede tener acceso a los nodossubsecuentes vía 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).


LNULL

Nodos

La estructura de datos en C++ usada puede ser:

struct nodo

{ int info;//guarda la información del nodo

struct nodo *sig; //puntero que apunta al siguiente

// nodo

};

Si definimos una lista como elementos de un conjuntoE. Se tiene que:

Una lista sobre E es una secuencia ordenada L de cero o más elementos de E:

a1, a2, ...., an

Si n=0, L no tiene elementos y será llamada la lista nula o vacía.

Si n>=1, L tiene n elementos ydiremos que su longitud es n.

a1 es el primer elemento de L y an esel último elemento de L.

Para i= 1, 2, … , n-1, ai precede a ai+1

Para i= 2, 3, … , n, ai sigue a ai-1

El orden en la secuenciadetermina la posición de cada elemento.

Ahora se mencionan las características de algunas operaciones que vamos a implementar para la lista enlazada con punteros.

Operaciones básicas con una lista


Suponemos que L es una lista. Además conviene postular la existencia de una posición especial: FIN(L), la cual sigue a la posición del último elemento de L que es (NULL).

ANULA(L) : Función que convierte a L en la lista vacía o nula y retorna la posición FIN(L).

LOCALIZA(x,L) : Función que retorna la posición del primer elemento de L que es igual a x o FIN(L), si tal elemento no existe.

RECUPERA(p,L) : Función que retorna al elemento que está en la posición p en L. No esta definida si p=FIN(L) o si no hay una posición p en L.

SUPRIME(p,L) : Función que suprime al elemento de la posición p en L; esto es, si Les a1, …, ap-1, ap, ap+1, …,an antes; después L es a1, …, ap-1, ap+1, …,an. El resultado no esta definido si p=FIN(L) o si no hay una posición p en L.

INSERTA(x,L) Función 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 implementación 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 opción (1-7)==>

";cin>>op;switch (op){ case 1 : L=anula(L);break;

case 2 : cout<<"Digite posición 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 posición es "<<p;getch();break;


case 6 : cout<<"Digite posición a mostrar ==> ";cin>>p;

x=recupera(p,L);if (x==-1)

cout<<"no existe posición";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 posición pos else

return (p->info);}

struct nodo * FIN(struct nodo *top)


// Esta implementación 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<<"impresión 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 posición 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<<"posición no encontrado o lista

vacía \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 b c d e

Frente 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 también se le da a una cola.

Las operaciones básicas que caracterizan a una cola son las siguientes:

ANULA(C) : Función que convierte a la cola C en la cola vacia.

VACIA(C) : Función que retorna 1 si la cola esta vacía y 0 en caso contrario.

FRENTE(C) : Función que retorna el 1er. elemento de la cola C. Esta función no está definida si la cola es vacia.

INSERTA_COLA(x,C) : Función que inserta al elemento x en el final de C.

SUPRIME_COLA(C) : Función que suprime el elemento del frente de la cola C. No se realiza si la cola es vacia.

Ejemplo 1 : Realizar la implementación con punteros delas operaciones de una cola.

Cola

5 6

Frente Final

NULL


#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 opción (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*/ nuevo->info=x;/*05*/ /* primer dato*//*06*/ if (comienzo==NULL)//si es vacia la cola/*07*/ { comienzo=nuevo;nuevo->sig=NULL;}/*09*/ else/*13*/ { /*nuevo se pone al final de la cola*//*15*/ q=comienzo;/*16*/ while (q!=NULL)/*17*/ {p=q; q=q->sig;}/*18*/ p->sig=nuevo;nuevo->sig=q;/*19*/ }

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 ONCE

ARCHIVOS

En el capítulo de registros al utilizar los arreglos de estructuras se da la desventaja que los datos de los registros existen, mientras el programa este en ejecución, perdiéndose cuando el programa finaliza. Para salvar esta situación 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.ORGANIZACIÓN DE ARCHIVOS

Un archivo es una colección de datos que con un título o nombre se almacenan o graban en dispositivos tales como discos, disquetes, cintas magnéticas, etc. Los datos de un archivo pueden ser leídos y utilizados por otros medios.

Las operaciones básicas con un archivo son:

Apertura del archivo empleando un nombre para identificarlo

Escritura de datos en el archivo

Lectura de datos del archivo

TECNICAS DE PROGRAMACIÓN ESTRUCTURADA: Aplicaciones en C++

GamarraMorenoADJ126

Cierre del archivo

Los datos de un archivo son simplemente bytes o caracteres almacenados uno a continuación de otro que son enumerados con 0, 1,...

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

Después de cada operación de escritura o de lectura, el archivo apunta al componente que sigue al grupo de datos escritos o leídos: Acceso secuencial.

También es posible desplazar el apuntador a un componente particular dentro del archivo, empleando funciones de movimiento del apuntador: Acceso directo.

Se debe cerrar un archivo cuando ya no se desee trabajar con él.

Para borrar o eliminar un archivo se emplea la función unlink(). Por ejemplo, mediante

unlink(“DATOS”);

se borra el archivo de nombre DATOS.

FUNCIONES DE ALTO NIVEL

Para utilizar este grupo de funciones se debe incluir la cabecera stdio.h


El uso de las funciones requiere la declaración 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 función fopen(), con el siguiente formato:

arch = fopen(“NOMBRE DE ARCHIVO” , modo);

donde modo puede ser:

“r” Abre para solo lectura

“w” Crea para escritura. Si el archivo existe, este se sobreescribe

“a” Abre para escribir al final del archivo o crea para escribir si el archivo no existe.

“r+” Abre un archivo existente para actualizar (lectura y escritura).

“w+ “ Crea un nuevo archivo para actualizar (lectura y escritura). Si el archivo existe, este se sobreescribe

“a+” Abre para añadir, abre para actualizar en el final del archivo, o crea este si no existe.

Para especificar que un archivo esta siendo abierto o creado en el modo texto añadir “t” a la cadena (rt, w+t, etc.)

Para especificar el modo binario, añadir “b” a la cadena (wb, a+b, etc.)


Not a :

Si se tiene la cadena “r+t” es equivalente a “rt+”, sucede lo mismo con las demás combinaciones.

La función fopen() devuelve la dirección 0 (cero o NULL) si la operación de apertura falla, o un valor (dirección) distinto si es correcta.

Si la operación 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 carácter c en arch.

fwrite(s, m, n, arch): Escribe en arch n datos detamaño o longitud m (igual a m*n bytes) ubicados apartir de la dirección s.

11.3.LECTURA DE ARCHIVOS:

fgetc(arch) : Devuelve el siguiente carácter leído en arch.

fread(s, m, n, arch): Lee en arch n datos de tamaño o longitud m (igual a m*n bytes) y los almacena a partir de la dirección 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 carácter escrito o leído 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 número de datos escritos o leídos. Así fwrite() devuelve el número de n datos especificados o un valor menor en caso de error. Y fread() devuelve el valor n o un número menor, por ejemplo 0 si está en el final del archivo.

11.4.UBICACIÓN DEL PUNTERO PARA ACCESO DIRECTO

Usar : fseek (arch, desp, orig);

La función pone o ubica el puntero del archivo en el componente cuya posición 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 archivo1 = posición actual2 = 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 el contenido de un archivo de texto.

#include <string.h>#include <stdio.h>#include <conio.h>#include <iostream.h>

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 <string.h>#include <stdio.h>#include <conio.h>#include <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 que administra archivos binarios

#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];


}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 modificaci¢n? (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;


}


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). Programación en C. Editorial

Mc Graw-Hill.

4. Joyanes Aguilar, Luis. (1988). Fundamentos de Programación

Algoritmos y Estructura de Datos. Editorial McGraw-Hill.

5. Alcalde, Eduardo Y Garcia, Miguel. (1987). Metodología

de la Programación. Editorial McGraw – Hill.


45509261-c-corre

Documents