programacion orientada a objetos

UNIVERSIDAD NACIONAL DE INGENIERÍA

FACULTAD DE INGENIERÍA MECÁNICA

INDICE

1 CONCEPTOS GENERALES DE COMPUTACION……...…………………….…………………. 06

1 Ing. Ricardo Castañeda

2013PROGRAMACION ORIENTADA A OBJETOS

1.1 Computadora…………………………………………...………….………………………..……

1.2 Componentes de una computadora……………..……………………………………….…..

1.3 El sistema informatico…………………………………………….………………………….…

1.4 Algoritmos…………………………………………………………………………………………

1.5 Lenguajes de Programacion…………………………………….…………………………..…

1.6 Tipos de Programación….……………………………………….…………………………….

1.7 Diseño de Algoritmos……………..………….………………….…………………………..….

1.8 Objetos_datos de Entrada/salida…….…….………………………………..…………….…...

1.9 Procesos Directos o Secuenciales…..………………………….…………………………..…

1.10 Esructuras de decisión simple..………………………………….…………………………….

1.11 Estructuras de decisión anidada…..………….………………….…………………………...

1.12 Estructuras de decisión multiple…..………….………………….…………………………...

1.13 Estructuras Repetitivas…………………………………………………………………………

1.13.1 Estructuras Mientras………..………….………………….…………………………...

1.13.2 Estructuras Hacer Mientras...………….………………….…………………………...

1.13.3 Estructuras Para…………………………………………………………………………

Problemas……………….…………………………………………………………..……………………

Ejercicios propuestos.………………………………………………………..…....……………………

2 ESTRUCTURA DE UN PROGRAMA BORLAND C++………….………..…………………………

2.1 Organizacion de un programa Borland C++……………………….…………………………

2.2 Estructura General de un Programa en Borland C++………………….……………………

2.3 Elementos de un Programa en C++………………………….……….…………………………

2.4 Tipos de variables estándar en C++……………………………………….……………………

2.5 Constantes……………………………………………………………….…………………………

2.6 Variables……………………………………………………………………………………………..

2.7 Entrada y salida simple en C++…………………………………………….……………………

2.8 Secuencias de Escape…………………………………………………………………………..

2.9 Manipulacion y formato de datos de salida…………………………….……………………

Problemas…………………………………………………………………………………………………

3 ESTRUCTURAS DE CONTROL EN C………………………….………………………….…………

3.1 Expresiones y operadores………………………………………………………………………

3.2 Estructuras de Control en Lenguaje C……………………………………………...………..

Problemas…………………………………………………………………………………………………

Ejercicios propuestos.………………………………………………………..…....……………………

4 FUNCIONES EN LENGUAJE “C++”..……………………………………………………….………

4.1 Funciones Predifinidas ( De Biblioteca)………………………………………..……..………

4.2 Funciónes Definidas por el Usuario.……………………………………………….…………

4.2.1 Ubicación del prototipo, la llamada y la función en lenguaje C++.…………….

4.2.2 Comunicación entre funciones……………………………………………………….

4.3 Funciones Inline…………………………….…………………………………………………….

4.4 Funciones Recursivas……………………………………………………………….………….

06

06

06

06

07

07

09

10

10

13

16

17

21

21

22

26

29

42

44

44

45

46

46

47

47

47

49

50

53

60

60

64

73

80

82

82

91

92

92

94

94

2 Ing.Ricardo Castañeda

2013FACULTAD DE INGENIERIA MECANICA

4.5 Punteros a Funciones……………………………………………………………….………….

Problemas………………….……….………………………………………………………………

Ejercicios Propuestos…………….………………………………………………………………

5 ARREGLOS EN LENGUAJE “C”………………………………………………….…………………

5.1 Definicion…………………….……………………………….……………………………………

5.2 Acceso a elementos………….……………………………………………………..…………….

5.3 Operaciones con arrays unidimensionales………………………………………………….

5.4 Arregños de 2 dimensiones.……………………………………………………..…………….

5.5 Operaciones con matrifes…………………..………………………………………………….

Problemas…………….………………………………………………………………….………..………

Ejercicio propuestos.………………………………………………………………….………..………

6 CADENAS EN C++……………………………………………………………………….…………….

6.1 Lectura de una cadena del teclado………………………….……………………

6.2 Funciones para Manejar cadenas………..………………………………………………………

6.3 Vectores de cadenas………………………………………………………………………………

Problemas…………….………………………………………………………………….………..………


7 REGISTROS EN LENGUAJE C++……………………………………………………………………

7.1 Modelamiento de un registro de acuerdo a las entidades del mundo real ……

7.2 Creacion y manejo de Registros……………………….………………….……………………

7.3 Acceso a miembros del registro ……….………..…………………………………………

7.4 Inicialización de estructuras ………………………………………………………………..

7.5 Asignación de estructuras ………………………….……………………………………….

Problemas……………………………………………….…………………………………………………


8 CONCEPTOS DE LA PROGRAMACION ORIENTADA A OBJETOS…………………………….

8.1 Programacion orientada a objetos……………………………………………………………..

8.2 Clases………………….………………………..………………………………………………….

8.3 Objeto………………………………………………………………………………………………..

8.4 Herencia……………….………………………..………………………………………………….

8.5 Polimorfismo………….………………………..………………………………………………….

Problemas……………………………………………….…………………………………………………


9 CLASES Y CONSTRUCTORES………………………………………………………………………..

9.1 Secciones y funciones miembro……………………………………………………………….

9.1.1 Secciones…………………………………………………………………………………..

9.1.2 Funciones miembro……………………………………………………………………..

9.2 Constructores y destructores………………………………………………………………….

9.2.1 Constructor……………………………………………………………………………..

9.2.2 Destructores………………………………………………………………………………..

Problemas……………………………………………….…………………………………………………

95

97

104

107

107

107

107

117

117

120

130

132

132

134

137

140

143

145

145

146

146

146

147

151

163

165

165

168

168

170

170

171

175

177

177

177

177

178

178

180

182



10 HERENCIA Y CLASES DERIVADAS………………………………………………….…………….

10.1 Definicion……………………………..……………………….……………………

10.2 Clases Derivadas…………………..……..………………………………………………………

10.3 Herencia multiple…………………………………………………………………………………

10.4 Funciones amigas………………………………………………………………………………

10.5 Funciones virtuales………………………………………………………………………………

Problemas…………….………………………………………………………………….………..………

11 POLIMORFISMO…………………….…………………………………………………………………

11.1 Via funciones virtuales…………………………………………………………………

11.2 Sobrecarga de operadores y funciones…………….………………….……………………

11.2.1 Introduccion………………….…….………..…………………………………………

11.2.2 Sobrecarga de operadores..………………………………………………………..

11.2.3 Sobrecarga de funciones………………….……………………………………….

Problemas……………………………………………….…………………………………………………

12 FLUJOS Y ARCHIVOS………………………………………………………………………………….

12.1 Archivos de texto……………..…………………………….…………………………………..

12.2 Archivos Binarios….………………………..………………………………………………….

12.2.1 Introduccion…………………………………………………………………………..

12.2.2 Entrada/Salida por archivos………..………………………………………………….

12.2.3 Apertura de un archivo……………..………………………………………………….

12.3 Operaciones con archivos……………………………………………………………………..

12.4 Archivos binarios con acceso aleatorio…………………………………………………….

Problemas……………………………………………….…………………………………………………

187

187

187

188

188

188

189

198

198

198

198

198

200

201

206

206

210

210

210

210

212

212

213



CAPITULO I

1. CONCEPTOS GENERALES DE COMPUTACION

1.1. Computadora

Es un conjunto de circuitos electrónicos, que es capaz de recibir un flujo de entrada (Datos), procesarlo de

acuerdo a un conjunto de instrucciones (Programa) y emitir un flujo de salida (Resultados).

1.2. Componentes De Una Computadora

De acuerdo a la definición anterior, la computadora necesita dos elementos importantes, llamadas

componentes, para conseguir sus objetivos y estas son:

o Hardware.- Es la parte física, consiste en un conjunto de unidades conectadas entre si por los llamados

buses de comunicación, este hardware también se conecta con una serie de dispositivos externos que nos

permiten ingresar información a la computadora y además tomar información de ella de tal manera que sirva



a nuestros fines, estos dispositivos son los llamados periféricos, estos pueden ser de entrada, salida o de

entrada/salida.

Las unidades mencionadas son:

Unidad de Entrada

Unidad Central de Procesamiento, que se compone de:

o Unidad de Control

o Unidad aritmetica y lógica.

Unidad de Memoria (Memoria RAM)

Unidad de salida

Buses de Comunicación

Los periféricos son:

Periféricos de entrada: Teclado, Mouse, Micrófono, Scanner, cámara digital, Lector de códigos de

barras, Lápices Ópticos, Joystick.

Periféricos de salida: Monitor, Impresora, Parlantes, Plotter, Audífonos, Fax, Data Show.

Periféricos de entrada/salida: disco duro, Cd, memoria USB, disco flexible, DVD.

o Software.- Es la parte lógica nos permite manejar el hardware y obtener los resultados esperados, existe 3

tipos de software:

Software base: Los sistemas operativos como el DOS, Windows, UNIX .

Software aplicado: Son los famosos paquetes como el Word (Procesador de texto), Excel (Hoja de

cálculo), Power Point y otros.

Software de uso general: Son los lenguajes de programación que nos permiten escribir programas de

uso específico. Ejemplos: Visual C, Java, Visual FoxPro.

1.3. El Sistema Informático

Un sistema informático es un sistema que nos ayuda a automatizar procesos mediante el manejo adecuado de la

información, la construcción de un sistema informático lo podemos considerar en las siguientes etapas:

Análisis

Diseño

Programación

Implementación

1.4. Algoritmos

Los programas y los algoritmos son en realidad una misma secuencia de solución solamente la utilización de

cada uno de ellos tiene variantes.

Definición De Algoritmo.- Un algoritmo es la descripción ordenada paso a paso de la solución de un problema o

el desarrollo de un proceso.

Los algoritmos se pueden clasificar en tres tipos:

Algoritmo literal : Nos permite la comunicación de persona a persona una de sus formas más conocidas

es el SEUDOCÓDIGO.

Algoritmo gráfico : Nos permite visualizar la lógica de la solución. Se le conoce también como DIAGRAMA

DE FLUJO

Algoritmo codificado : Nos permite la comunicación entre la persona y la máquina (Computadora) . Se le

conoce como PROGRAMA.



1.5. Lenguajes de Programacion.- Los programas y los Lenguajes De Programación Los lenguajes de

programación nos permiten construir programas para aplicaciones especificas, estos lenguajes normalmente

tienen su ámbito de aplicación o sea tienen diferentes enfoques, por ejemplo los dos primeros lenguajes fueron

el FORTRAN y el COBOL.

FORTRAN.- Su nombre proviene de, FORmula TRANslation, es un lenguaje científico creado especialmente

para la realización de cálculos.

COBOL.- Su nombre proviene de COmmon Busines Oriented Lenguaje, es un lenguaje para manejo de

información comercial creado especialmente para la realización de procesos.

Actualmente tenemos una variedad de lenguajes, desde bajo nivel hasta alto nivel, una breve descripción seria:

Lenguaje de maquina: Es una secuencia de bits, que realmente son señales eléctricas (normalmente 0

voltios y 5 voltios) que para el computador serán los ceros y unos llamados también bits, por ejemplo:

01011001 00001101

La programación con este lenguaje es muy dificultosa y normalmente se recurre a otro lenguaje nemotécnico

llamado ensamblador.

Lenguaje ensamblador: donde las instrucciones y los dispositivos se reemplazan por códigos nemotécnicos

con lo cual se facilita tremendamente la programación, dependiendo del procesador, tendríamos por ejemplo:

El ensamblador depende de la arquitectura del procesador pero normalmente existen bastantes similitudes

en todos los ensambladores.

Lenguaje de alto nivel: Nos permiten realizar muchas operaciones con pocas instrucciones, estas

instrucciones se parecen al lenguaje que usamos comúnmente (en idioma ingles), por ejemplo: begin, end,

program, if, else etc.

Tenemos el Pascal, FoxPro Java, Visual Basic, Visual FoxPro etc.

Un lenguaje interesante es el lenguaje “C” que es el que nosotros vamos a utilizar, este lenguaje es de nivel

intermedio pues tiene rutinas que realizan procedimientos complejos con una sola instrucción así como

también el manejo casi al nivel de máquina, por lo tanto es de nivel intermedio.

1.6. Tipos de Programación

La programación ha evolucionado desde la primera vez que fue utilizada y se ha modificado sobre todo por la

opinión y contribución de los expertos programadores, la secuencia ha sido:

Programación lineal

Se colocan todas las sentencias en el programa principal, a medida que la aplicación realiza nuevas tareas y se

afina el programa crece en forma vertical, antiguamente este tipo de programación predominaba pero no es

muy práctico.

Programación estructurada: Es una programación modular donde el programa principal solo se utiliza para

llamar a los módulos que realizan las tareas, si la tarea de un modulo se vuelve más compleja se divide en

otros módulos, aquí el crecimiento es horizontal.

Los dos casos anteriores se verían así gráficamente:


mov ah,9int 21hmov ah,10………….push cs

Programación Lineal

Programa 1xxx………………..………………….………………………………………..…………………………………………..……………………..

Programa 1xxx, con mas tareas………………..………………….………………………………………………………..…………………………………………..


Programación orientada a objetos

Es una programación en la cual los datos y los procedimientos se encapsulan y además se le agrega niveles

de visibilidad, para simular un poco mejor lo que ocurre en los procesos del mundo real. Aquí ya intervienen los

conceptos de clases, herencia y polimorfismo, como se verá en el capítulo correspondiente.

1.7. Diseño del algoritmo

El algoritmo es la piedra fundamental de la programación pues los programas y el sistema en general será tan bueno

como buenos sean los algoritmos utilizados para la construcción de este.

En realidad un algoritmo es la descripción de una secuencia de solución que normalmente está compuesta por los

siguientes bloques:

INICIALIZACION – LECTURA – PROCESO – ESCRITURA Esta estructura es como un esqueleto que siempre

tenemos que tomar en cuenta cuando desarrollamos un algoritmo. Gráficamente lo consideramos como sigue:


Programación Lineal

Programa 1xxx………………..………………….………………………………………..…………………………………………..……………………..

Programa 1xxx, con mas tareas………………..………………….………………………………………………………..…………………………………………..

Programación estructurada

Programa principalSubprog01

Subprog02

Subprog03

Subprog01

Subprog02

Subprog03

Programa principalSubprog01

Subprog02

Subprog03

Subprog01, con mas tareas

Subprog01.1

Subprog01.2

Subprog02

Subprog03

ESCRIBIR

LEER

PROCESAR

INICIALIZAR


Seudocódigo y diagrama de flujo

El seudocódigo es un algoritmo literal cuya semejanza con el lenguaje de programación (código) lo hace muy útil para

la fase de previa a la escritura del programa después el programa podrá fácilmente ser escrito; veamos un ejemplo:

Ejemplo 1.1

ALGORITMO

PROGRAMA

En cambio el objetivo del diagrama de flujo es visualizar rápidamente la lógica del algoritmo.

Diagrama de FlujoPero las tres herramientas representan lo mismo y por eso también se clasifican como:

Algoritmo literal (seudocódigo) Permite la comunicación Persona – Persona

Algoritmo codificado (programa) Permite la comunicación Persona – Computadora



/* Permite verificar si una nota es aprobatoria o no */

nota es entera1.- Leer (nota)2.- Si (nota >=10) Entonces 2.1. Escribir ( “Aprobatoria”) Sino 2.2. Escribir (“Desaprobatoria”) Fin-si3.- Fin

/* Codigo: poo01e1 programa creado por Ricardo Castañeda de la Rosa Fecha: 17 de marzo de 2013 objetivo: programa que verifica si una nota ingresada por teclado es aprobatoria o no datos de entrada : nota salida : mensaje de aprobacion o desaprobacion*/

# include<iostream.h># include<conio.h>void main( ){ int nota; clrscr(); cout << "Nota = "; cin>> nota; if ( nota >=10) cout<< "Aprobatoria"; else cout<< "Desaprobatoria"; getch( ); }

INICIO

FIN

Escribir“Desaprobado”

Escribir“Aprobado”

¿Nota >= 10? V F

Leer (Nota)

Algoritmo gráfico (diagrama de flujo) Visualiza la lógica.

Como vemos cada tipo de algoritmo tiene su propia utilidad, pero nos damos cuenta que son herramientas paralelas.

1.8. Objetos_Datos de Entrada/Salida

Los procesos estándares casi siempre transforman los objetos _ datos de entrada en objetos _ datos de salida. Todas

las variables se definen como almacenadores de datos de entrada o como almacenadores de resultados o en

algunos casos como variables intermedias. Los procesos transformadores normalmente tienen componentes de los

siguientes procesos básicos:

o Procesos secuenciales.

o Procesos de decisión.

o Procesos de repetición.

1.9. Procesos Directos o Secuenciales

Los procesos por defecto son secuenciales o directos y su objetivo es realizar un cálculo o un procedimiento. Son los

casos más comunes pero tienen poca inteligencia incorporada y sirven en problemas sencillos.

Ejemplo 1.2: Escriba un algoritmo que nos permita leer dos datos y hallar su media.

ALGORITMO

Como vemos en el ejemplo seguimos la secuencia leer, procesar, escribir.

Ejemplo 1.3: Escriba un algoritmo que lea un total de horas y lo exprese en semanas días y horas. Si lee 400 horas

debe escribir 2 semanas, 2 días y 16 horas.

ALGORITMO

PROGRAMA



dato1, dato2 son enteros media es real 1.- Leer (dato1) 2.- Leer (dato2) 3.- media (dato1 + dato2)/2 4.- Escribir (media) 5.- Fin

total_horas, semanas, días y horas son enteros.

resto es entero

1.- Leer (total_horas)

2.- semanas total_horas/168 // Calcular Semanas

3.- resto total_horas – semanas*168 // resto de división

4.- días resto/24 // calcular días

5.- horas resto – días *24 // calcular horas

6.- Escribir (semanas, días, horas)

7.- FIN

/* CODIGO:POO1E3

PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA

FECHA: 17 DE MARZO DE 2013

OBJETIVO: PROGRAMA QUE LEE UNA CANTIDAD EN HORAS Y LAS ESCRIBE COMO SEMANAS, DIAS Y

HORAS.

DATOS DE ENTRADA : total_horas

SALIDA : semanas, dias,horas.*/

#include <iostream.h>

#include <conio.h>

EJECUCION:

Ejemplo 1.4: Escriba un algoritmo que lea los coeficientes de una función cuadrática, también el argumento y me

devuelva el valor de la función.

ALGORITMO



/* CODIGO:POO1E3



OBJETIVO: PROGRAMA QUE LEE UNA CANTIDAD EN HORAS Y LAS ESCRIBE COMO SEMANAS, DIAS Y

HORAS.

DATOS DE ENTRADA : total_horas

SALIDA : semanas, dias,horas.*/


#include <conio.h>

A, B, C, x y f1 son reales

1.- INICIO

3.- Escribir(“"Ingrese coeficientes de A*x^2 +B*x +C ")

4.- Escribir( " A = ")

5.- Leer(A)

4.- Escribir( " B = ")

5.- Leer(B)

4.- Escribir( " C = ")

5.- Leer(C)

6.- escribir(" Ingrese argumento x = ")

7.- Leer(x)

8.- f1 A*x*x +B*x+C

9.-Escribir ( “f1(x) = “,f1)

10.- FIN

PROGRAMA

1.10. Estructuras de Decisión Simple (Si) .- Nos permite derivar el control hacia uno de dos puntos del algoritmo.

Forma General

Si (Condición)

Entonces

...............

...........(Bloque1)

...............

[Sino

...............

...........(Bloque2)

............]

Fin Si

Funcionamiento.- Se evalúa la condición, si esta se cumple (es verdadera) se ejecuta el bloque 1 (Entonces) si esta

no se cumple se ejecuta el bloque 2 (sino), en caso de que este exista, luego se pasa a la siguiente instrucción.

Nota: La forma sin el else se utiliza bastante y por eso la indicamos.

Si (Condición)

Entonces



/* CODIGO: POOC1E4



OBJETIVO: Programa secuencial que calcula una función de la forma

f1(x) = A*x^2 +B*x +C ; los coeficientes A, B y C serán leídos, asi como el argumento x */


#include <conio.h>

void main( )

{ float A,B,C;

float x, f1;

clrscr( );

cout<< "Ingrese coeficientes de A*x^2 +B*x +C "<< endl;

cout<< " A = "; cin>>A;

cout<< " B = "; cin>>B;

cout<< " C = "; cin>>C;

cout<< " Ingrese argumento x = "; cin>>x;

f1= A*x*x+B*x+C;

cout<< " f1(x) = "<< f1; getch(); }

...............

Fin Si

Ojo que esta es la primera forma solo que sin la parte opcional else.

Ejemplo 1.6: Veremos tres casos con las mismas variables pero con diferentes valores. El funcionamiento del Si se

visualizara de acuerdo a la salida.

Segmento de AlgoritmoNota = 15

Si (Nota > 10) Entonces Escribir(“Aprobado”) FinSi

Escribir(“FIN”)

Salida de Ejecución

AprobadoFIN


Si (Nota > 10) Entonces Escribir(“Aprobado”) FinSi

Escribir(“FIN”)


FIN


Si (Nota > 10) Entonces Escribir(“Aprobado”) Sino Escribir(“Desaprobado”) FinSi

Escribir(“FIN”)


DesaprobadoFIN

Ejemplo 1.7: Escriba un algoritmo que lea cuatro valores y me muestre el menor.

ALGORITMO

Dato1, dato2, dato3, dato4, Menor1, Menor2 y MenorT son enteros

1.- Leer(dato1,dato2, dato3, dato4)

2.- Si ( dato1 < dato2)

Entonces

2.1 Menor1 dato1

Sino

2.2 Menor1 dato2

FinSi

3.- Si ( dato3 < dato4)

Entonces

3.1 Menor2 dato3

Sino

3.2 Menor2 dato4

FinSi

4.- Si ( Menor1 < Menor2)

Entonces

4.1 MenorT Menor1

Sino

4.2 MenorT Menor2

FinSi

5.- Escribir( “El menor total es =“, Menort) 6.- FIN

PROGRAMA



/* CODIGO: POOC1E7


OBJETIVO: Programa que muestra el menor de 4 valores */

# include<iostream.h>

# include<conio.h>

void main( )

{ int dato1, dato2, dato3, dato4,menor1, menor2, menort;

clrscr( );

cout<< " dato1="; cin>> dato1;

Ejemplo 1.8: Escriba un programa que lea los datos de un cilindro y si son positivos y calcule el área y el volumen.

Solucion:

ALGORITMO

/* Halla área y volumen de un cilindro */

radio, altura, Pi son reales

area1, area, volumen son reales

1.- Leer(radio)

2.- Leer(altura)

3.- Pi = 3.1416

4.- Si ( (radio > 0) i (altura > 0)

Entonces

4.1 area1 Pi*radio2

4.2 area2*Pi*radio*altura+ 2*area1

4.3 volumen area1*altura

4.4 Escribir(area, volumen)

FinSi

5.- FIN

PROGRAMA



/* CODIGO: POOC1E7


OBJETIVO: Programa que muestra el menor de 4 valores */


# include<conio.h>

void main( )

{ int dato1, dato2, dato3, dato4,menor1, menor2, menort;

clrscr( );

cout<< " dato1="; cin>> dato1;

/* CODIGO: POOC1E8


OBJETIVO: Programa que halla el volumen y area de un cilindro

Datos de Entrada:: RADIO Y ALTURA

Salida: AREA Y VOLUMEN.*/


# include<conio.h>

EJECUCION

1.11. Estructuras de decisión anidada: Esto sucede cuando una estructura de decisión está contenida

completamente dentro de otra, veamos

1 Si (Condición1)

Entonces

1.1 ...............

1.2 Si (Condicion2)

Entonces

1.2.1............

1.2.2............

Sino

1.2.3.................

1.2.4..................

FinSi(Anidado)

Sino

1.3..............

1.4.............

FinSi(Externo)



/* CODIGO: POOC1E8


OBJETIVO: Programa que halla el volumen y area de un cilindro

Datos de Entrada:: RADIO Y ALTURA

Salida: AREA Y VOLUMEN.*/


# include<conio.h>

Aquí vemos que la estructura de decisión con la condición2, estará anidada en la estructura de decisión con la

condición1, veamos un ejemplo.

Ejemplo 1.9: Escriba el algoritmo que me permita leer una nota y escribir la condición académica del alumno en el

curso:

De 0 a 6 condición “Reprobado”

De 6 a 10 condición “Desaprobado”

De 10 a 16 condición “Aprobado”

De 16 a 20 condición “Excelente”

Solucion:

ALGORITMO

/* Discrimina nota*/

nota es entera

1. Leer ( nota)

2.-Si (nota<10)

Entonces

2.1 Si (nota>=6)

Entonces

2.1.1 Escribir(“Desaprobado”)

Sino

2.1.2 Escribir(“Reprobado”)

FinSi

Sino

2.2 Si (nota>=16)

Entonces

2.2.1 Escribir(“Excelente”)

Sino

2.2.2 Escribir(“Aprobado”)

FinSi

FinSi

3.- FIN

PROGRAMA



/* CODIGO: POOC1E9



OBJETIVO: Lee nota e imprime condicion academica.*/


# include <conio.h>

void main( )

{ int nota ;

clrscr( );

cout << "Ingrese Nota => ";

cin>> nota;

if(nota <10)

if(nota>= 6)

cout<< "Desaprobado";

else

cout<< "Reprobado";

else

if(nota>=16)

EJECUCION

1.12. Estructuras de Decisión Múltiple (case).- Nos permite derivar el control hacia uno de varios puntos del

algoritmo.

Forma General

Case (Índice)

1: ...............

(Bloque1)

2: ...............

(Bloque2)

3: ...............

(Bloque3)

n: ...........

(Bloque n)

Sino : ........

(Bloque por defecto)

Fin Case

Funcionamiento.- Se evalúa el índice y si:

Vale 1 se ejecuta el bloque 1.

Vale 2 se ejecuta el bloque 2.

Vale n se ejecuta el bloque n.

Si cae fuera del rango [1,n} se ejecuta el bloque por defecto(sino).

A continuación se pasa a la siguiente instrucción.

Veamos un ejemplo:

Ejemplo 1.10: Escriba un algoritmo que lea los dos operandos ( valor1 y valor2) lea también el operador (+, - , * ó /) y ejecute la operación

indicada.

Solucion:

ALGORITMO

valor1, valor2, resultado son reales



/* CODIGO: POOC1E9



OBJETIVO: Lee nota e imprime condicion academica.*/


# include <conio.h>

void main( )

{ int nota ;

clrscr( );

cout << "Ingrese Nota => ";

cin>> nota;

if(nota <10)

if(nota>= 6)

cout<< "Desaprobado";

else

cout<< "Reprobado";

else

if(nota>=16)

operador es carácter

1. Leer ( valor1)

2.- Leer(valor2)

3.- Leer(operador)

4.- Case (operador)

“+” : resultado valor1 + valor2

escribir(“resultado = ”, resultado)

“– “: resultado valor1 – valor2

escribir(“resultado = ”, resultado)

“ * “: resultado valor1 * valor2

escribir(“resultado =”, resultado)

“/ “: resultado valor1 / valor2

escribir(“resultado =”, resultado)

sino: escribir( “ No es operación”)

Fin Case

5.- FIN

PROGRAMA

EJECUCION



/* CODIGO: POOC1E10


OBJETIVO: Lee operandos y operador y realiza la operacion.*/


# include<conio.h>

void main( )

{ float v1, v2,res; char operador;

clrscr( );

cout<< " v1 v2="; cin>> v1>>v2;

cout<< " operador ="; cin>> operador;

switch( operador)

{case '+': res=v1+v2;

cout<<"resultado="<<res;break;

case '-' :res=v1-v2;


case '*' : res=v1*v2;


case '/' : res=v1/v2;


default : cout<< " No es operación"; }

getch( ); }

Ejemplo 1.11: Escriba un algoritmo que lea un numero entre 30 y 50 y lo imprima en letras.

Por ejemplo: lee 35 e imprime “treinta y cinco”.

Solucion:

ALGORITMO

/* Lee un numero entre 30 y 50 y lo convierte a letras */

numero, dec, uni son enteros

1. Leer ( numero)

2.- Si ( (numero>=30) i ( numero<=50))

Entonces

2.1 dec numero/10

2.2 uni numero%10

2.3 Case (dec) 3 : Escribir( “ Treinta”) 4 : Escribir (“ Cuarenta”) 5 : Escribir (“ Cincuenta”) Fin Case 2.4 Case (uni) 1 : Escribir( “y Uno”) 2 : Escribir (“y Dos”) 3 : Escribir (“y Tres”) 4 : Escribir( “y Cuatro”) 5 : Escribir (“y Cinco”) 6 : Escribir (“y Seis”) 7 : Escribir( “y Siete”) 8 : Escribir (“y Ocho”) 9 : Escribir (“y Nueve”) Fin Case Sino

2.5 Escribir( “ Fuera del rango”)

Fin Si

3.- FIN

PROGRAMA



/* CODIGO: POOC1E11


OBJETIVO: Lee numero entre 30 y 50 en numeros y los transforma en letras. */

#include<iostream.h>

#include<conio.h>

void main( )

{int numero, dec, uni;

clrscr( );

cout<< " Numero = "; cin>> numero;

if ( (numero >= 30) && (numero<= 50))

{ dec = numero / 10; uni = numero % 10;

switch( dec)

{case 3 : cout<< "Treinta "; break;

case 4 : cout<< "Cuarenta "; break;

case 5 : cout<< "Cincuenta "; }

switch( uni)

{case 1 : cout<< "y uno"; break;

EJECUCION

1.13. Estructuras Repetitivas

1.13.1. Estructura Mientras.- Nos permite ejecutar varias veces un conjunto de instrucciones.

Forma General

Mientras (Condición)

............................

....(Bloque Mientras)

........................

Fin Mientras

Funcionamiento.- Se evalúa la condición, si esta se cumple (es verdadera) se ejecuta el bloque mientras, se vuelve

a evaluar la condición y si esta se sigue cumpliendo se vuelve a ejecutar el bloque y así se seguirá repitiendo

mientras la condición sea verdadera, si en alguna evaluación la condición ya no se cumple termina la repetición y se

pasa a la siguiente instrucción.

Ejemplo 1.12: Algoritmo que lee 10 valores y me muestra la suma y el promedio de los valores leídos.

ALGORITMO



/* CODIGO: POOC1E11


OBJETIVO: Lee numero entre 30 y 50 en numeros y los transforma en letras. */


#include<conio.h>

void main( )

{int numero, dec, uni;

clrscr( );

cout<< " Numero = "; cin>> numero;

if ( (numero >= 30) && (numero<= 50))

{ dec = numero / 10; uni = numero % 10;

switch( dec)

{case 3 : cout<< "Treinta "; break;

case 4 : cout<< "Cuarenta "; break;

case 5 : cout<< "Cincuenta "; }

switch( uni)

{case 1 : cout<< "y uno"; break;

/* Halla suma y promedio de 10 valores leídos */

valor, suma , cont son enteros

promedio es real

1. cont 0

2. suma 0

3. Mientras ( cont < 10)

3.1 Leer(valor)

3.2 suma suma + valor

3.3 cont cont + 1

Fin Mientras

4. promedio suma/10.0

PROGRAMA

EJECUCION



/* Halla suma y promedio de 10 valores leídos */


promedio es real

1. cont 0

2. suma 0

3. Mientras ( cont < 10)

3.1 Leer(valor)

3.2 suma suma + valor

3.3 cont cont + 1

Fin Mientras

4. promedio suma/10.0

/* CODIGO: POOC1E12



OBJETIVO: Hallar suma y promedio de 10 valores leídos */


# include<conio.h>

void main( )

{ int valor, suma, cont;

float promedio;

clrscr( );

cont = 0;

suma = 0;

while ( cont < 10 )

{ cout<< " valor = "; cin >> valor;

suma = suma + valor;

cont = cont + 1; // cont ++

}

promedio = suma/10.0;

cout << " Suma = "<< suma<< endl;

cout << " Promedio = " << promedio;

getch( ); }

1.13.2. Estructura Hacer - Mientras.- Nos permite ejecutar varias veces un conjunto de instrucciones, esta

estructura repetitiva primero ejecuta y después prueba la condición.

Forma General

Hacer

.........................

...........................

(Bloque sentencias)

......................

Mientras(Condición)

Funcionamiento.- Primero se ejecuta el bloque de sentencias y después se evalúa la condición, si esta se cumple

(es verdadera) se ejecuta nuevamente el bloque, se evalúa nuevamente la condición y si esta se sigue cumpliendo

se vuelve a ejecutar el bloque y así se seguirá repitiendo mientras la condición sea verdadera, si en alguna

evaluación la condición ya no se cumple termina la repetición y se pasa a la siguiente instrucción.

La diferencia con el bloque mientras es el orden en la evaluación de la condición (expresión

booleana en general) y la ejecución del bloque asociado.

MIENTRAS HACER – MIENTRAS

Ejemplo 1.13: Escriba un algoritmo que lea 10 valores y me muestre la suma y el promedio de ellos.

Solucion:

ALGORITMO

/* Halla suma y promedio de 10 valores leídos.

Utiliza la estructura repetitiva el Hacer-Mientras */


promedio es real


PROBAR

EJECUTAR

EJECUTAR

PROBAR


1.- cont 0

2.- suma 0

3.- Hacer

3.1.-Leer(valor)

3.2.- suma suma + valor

3.3.-cont cont + 1

Mientras(cont <10)

4.- promedio suma/10.0

5.- Escribir ( “Suma = “, suma)

6.- Escribir ( “ Promedio =”, promedio)

7.- Fin

PROGRAMA/* CODIGO: POOC1E13



OBJETIVO: Hallar suma y promedio de 10 valores leídos, con el do while */


# include<conio.h>

void main( )

{ int valor, suma, cont;

float promedio;

clrscr( );

cont =suma= 0;

do { cout<< " valor = "; cin >> valor;


cont ++;

} while ( cont<10);



cout << " Promedio = " << promedio; getch( ); }

EJECUCION

Ejemplo 1.14: Escriba un algoritmo que permita mostrar un menú vertical, indicando las opciones en forma general.

Solucion:

ALGORITMO

/* Muestra menú vertical en forma general */

opcion es caracter

1. Hacer

1.1 LimpiarPantalla ( )



1.2 Escribir ( “MENU VERTICAL”)

1.3 Escribir ( “1.- Tarea 1 ”)




1.7 Escribir ( “5.- Salir ”)

1.8 Escribir ( “Opcion =>”)

1.9 Leer (opcion)

1.10 case ( Opcion)

1.10.1 ‘1’: Funcion1()

1.10.2 ‘2’: Funcion2()

1.10.3 ‘3’: Funcion3()

1.10.4 ‘4’: Funcion4()

FinCase

Mientras ( opcion <> ‘5’)

2. FIN

PROGRAMA



/* CODIGO: POOC1E14



OBJETIVO: Muestra un menu vertical general */


# include<conio.h>

void main( )

{ char opcion;

do

{ clrscr( );

gotoxy(30,2);cout<<"MENU VERTICAL";

gotoxy(30,6);cout<<"1.- Tarea 1";




gotoxy(30,10);cout<<"5.- Salir";

gotoxy(30,16);

cout<<"Opcion --> ";

cin >> opcion;

switch ( opcion)

{ case '1': clrscr();

cout << " Tarea 1";

getch();

break;

case '2': clrscr();

cout << " Tarea 2";

getch();

break;

case '3': clrscr();

cout << " Tarea 3";

getch();

break;

EJECUCION

1.13.3. Estructura Para.- Nos permite ejecutar varias veces un conjunto de instrucciones un número fijo de

veces.

Forma General

Para vc = vi, vf, vinc

.........................

...........................

....(Bloque Para)

........................

Fin Para

Donde: vc variable de control, llamado también índice del Para.

vi valor inicial es el primer valor que toma la variable de control.



/* CODIGO: POOC1E14



OBJETIVO: Muestra un menu vertical general */


# include<conio.h>

void main( )

{ char opcion;

do

{ clrscr( );

gotoxy(30,2);cout<<"MENU VERTICAL";





gotoxy(30,10);cout<<"5.- Salir";

gotoxy(30,16);


cin >> opcion;

switch ( opcion)


cout << " Tarea 1";

getch();

break;

case '2': clrscr();

cout << " Tarea 2";

getch();

break;

case '3': clrscr();

cout << " Tarea 3";

getch();

break;

vf valor final, es el ultimo valor con el que el lazo para se ejecutara.

vinc valor incremento, valor en el cual se incrementa la variable de control después de cada lazo.

Funcionamiento.- El funcionamiento del lazo Para se explica mediante un algoritmo.

ALGORITMO DE FUNCIONAMIENTO DEL LAZO PARA

(Considerando incremento positivo)

1 Si ( vi > vf )

Entonces

1.1 Ir a paso (6)

FinSi

2 vc vi

3 Se ejecuta rango del lazo para

4 vc vc + vinc

5 Si ( vc <= vf )

Entonces

5.1 Ir a paso (3 )

6 FIN

Ejemplo 1.15: Que imprime el siguiente algoritmo

1 Para i = 1,12,2

Escribir ( i)

Fin Para

2 Escribir (“ FIN”)

Solución:

De acuerdo a lo dicho y considerando lo siguiente:

vc es i : vi = 1 : vf = 12: vinc = 2

Imprimirá:

Ejemplo 1.16: Escriba un algoritmo que lea 10 valores y me muestre la suma y el promedio de ellos.

Solucion:

ALGORITMO

/* Halla suma y promedio de 10 valores leídos, ojo no usa contador, pero ”i” cumple esa función */

valor, suma , i son enteros

promedio es real

1. Suma 0

2. Para i = 1,10 // El incremento unitario se puede omitir

2.1. Leer(valor)

2.2. Suma suma + valor

Fin Para

3. Promedio suma/10.0


1

3

5

7

9

11

FIN


4. Escribir ( “Suma = “, suma)

5. Escribir ( “ Promedio =”, promedio)

6. Fin

PROGRAMA

/* CODIGO: POOC1E16



OBJETIVO: Halla la suma y el promedio utilizando una instruccion for. */


#include<conio.h>

void main( )

{ int valor, suma, i;

float promedio;

clrscr( );

suma = 0;

cout<<"Lectura de valores: "<<endl;

for ( i=1; i<=10; i++ )

{ cout<< " valor"<<i<<": "; cin >> valor;


}



cout << " Promedio = " << promedio;

getch( );

}

EJECUCION

NOTA : Observe los siguientes puntos

El for ( Para) de C++ , inicializa la variable de control “i” (índice), indica la condición a verificar para ejecutar una

vez más el lazo y también indica el valor en que se debe incrementar la variable de control.

La variable i es una variable de control pero es interna, nosotros no podemos modificar su valor.

El ultimo valor de ”i” en los dos casos ( algoritmo y programa) es 11.



PROBLEMAS

ALGORITMOS SECUENCIALES

1.- Escriba un algoritmo que lea una cantidad en grados centígrados y lo muestre como grados Fahrenheit.

Implemente el algoritmo el Borland C++ para visualizar los datos de entrada y la emisión de resultados

Solución:

ALGORITMO

grados_c , grados_f son reales

1. INICIO

2. Leer (grados_c)

3. grados_f 32 + (9/5)*grados_c

4. Escribir(grados_f)

5. FIN

PROGRAMA

EJECUCION


/* CODIGO: POOC1PROB1



OBJETIVO: LEER UNA CANTIDAD EN GRADOS CENTIGRADOS Y MOSTRAR SU EQUIVALENTE EN GRADOS FARENHEIT*/


#include<conio.h>

void main()

{

float grados_c,grados_f;

clrscr();

cout<<"Ingrese grados centigrados--> ";

cin>>grados_c;// Lee grados Centigrados

grados_f = 32+(9.0/5.0)*grados_c; //Calcula el equivalente en grados Farenheit

cout<< " En grados farenheit sera : "<< grados_f;//Muestra los grados Farenheit

getch();// nos permite visualizar el resultado, la función getch() pide un caracter

}


2.- Dado los datos de planilla de un empleado, nombre, código, sueldo bruto mensual, horas extras y días faltos

(asumiendo que el descuento sobre el total es de 15%); escriba un algoritmo que procese esta información y me

muestre el sueldo neto que el empleado recibirá.

Implemente el algoritmo el Borland C++ para visualizar los datos de entrada y la emisión de resultados

Solución

ALGORITMO

/*Declaracion de Variables*/

nomemp es cadena

subemp es real

codemp es entero largo

hexemp es real

difemp es entero

sunemp es real

despor es real

desfal es real

destot es real

bonificación es real

1. INICIO

2. despor 0.15 /* Valor de descuento porcentual es de 15%*/

3. Leer (nomemp) /* Leemos nombre del empleado*/

4. Leer (codemp) /* Leemos código del empleado*/

5. Leer (subemp) /* Leemos sueldo bruto del empleado*/

6. Leer (hexemp) /* Leemos horas extras mensuales*/

7. Leer (difemp) /* Leemos días faltos en todo el mes*/

8. bonificación (subemp/240)*(hexemp*1.5) /* bonificación por horas extras*/

1. desfal (subemp/30)*difemp /*calculamos descuento por faltas*/

2. destot desfal+(subemp-desfal+ bonificación)*despor/*Descuento total*/

3. sunemp subemp+ bonificación-destot /*calculando sueldo bruto*/

4. Escribir(“Nombre = “,nomemp)

5. Escribir(“Código = “,codemp)

6. Escribir(“Descuentos= “,destot)

7. Escribir(“Neto = ”,sunemp)

8. FIN

PROGRAMA




OBJETIVO: LEER DATOS DE PLANILLA DE UN EMPLEADO Y CALCULA SUELDO NETO A PAGAR */




#include<conio.h>

#include<stdio.h>

void main()

{ char nomemp[30];

long codemp;

float subemp,sunemp;

float despor,desfal,destot;

float bonificacion;

float hexemp;

int difemp;

clrscr();

despor=0.15;

//Leemos datos de planilla

cout<< "INGRESO DE DATOS:"<<endl<<endl;

cout<<"Ingrese nombre= ";gets(nomemp);

cout<<"Codigo = ";cin>>codemp;

cout<<"Sueldo Bruto= ";cin>>subemp;

cout<<"Dias faltos = ";cin>>difemp;

cout<<"Horas extras = ";cin>>hexemp;

//Calculos de planilla

bonificacion = (subemp/240)*(hexemp*1.5);

desfal = (subemp/30)*difemp;

destot = desfal + (subemp-desfal+bonificacion)*despor;

sunemp = subemp+bonificacion-destot;

//Mostramos Resultados

cout<<endl<<endl;

cout<<"RESULTADOS:"<<endl<<endl;

cout<<" Nombre: "<<nomemp<<endl;

cout<<" Codigo: "<<codemp<<endl;

cout<<" Descuento: "<<destot<<endl;

cout<<" Neto : "<<sunemp<<endl;

getch(); }

EJECUCION

ALGORITMOS CON ESTRUCTURAS DE DECISIÓN SIMPLE



3.- Escriba un algoritmo que lea los coeficientes de una ecuación cuadrática de la forma a.x^2 + b.x + c = 0, y halle

las dos raíces.

Implemente el algoritmo el Borland C++ para ingresar los coeficientes y mostrar las raíces.

Solución:

ALGORITMO

/*Declaración de Variables*/

a, b, c son reales

d es real

raiz1, raiz2 son reales

iraiz1, iraiz2 son reales

1. INICIO

2. Leer (a, b. c)

3. d b^2 – 4*a*c

4. Si (d >= 0)

Entonces

4.1. Si (d = 0)

Entonces

4.1.1. raiz1 -b/(2*a)

4.1.2. Escribir(“Las dos raíces son iguales”)

4.1.3. Escribir(“Raíz = “,raiz1)

Sino

4.1.4. raiz1 (-b/(2*a)) + sqrt(d)

4.1.5. raiz2 (-b/(2*a)) - sqrt(d)

4.1.6. Escribir (“raiz 1 = “,raiz1)

4.1.7. Escribir (“raiz 2 = “,raiz2)

Fin Si

Sino

4.2. Escribir(“Las raíces son imaginarias”)

4.3. raiz1 (-b/(2*a))

4.4. raiz2 sqrt(-d)

4.5. Escribir(“raiz1 = “,raiz1,” +i “,raiz2)

4.6. Escribir(“raiz2 = “,raiz1,” – i “,raiz2)

Fin Si

5. FIN

PROGRAMA




OBJETIVO: CALCULA LAS RAICES DE UNA ECUACION CUADRATICA */


#include<conio.h>

#include<math.h>

void main()

{ float a,b,c;



float d;

float raiz1,raiz2;

clrscr();

cout << "Ingrese coeficientes de a.x^2 + b.x + c = 0 separados por blancos: ";

cin>>a>>b>>c;

d= b*b - 4*a*c;

if ( d >= 0)

if ( d==0)

{ raiz1 = (-b/(2*a));

cout<< "Las dos raices son iguales"<<endl;

cout<< "Raices = "<<raiz1;

}

else

{ raiz1 = (-b/(2*a)) + pow(d,0.5);

raiz2 = (-b/(2*a)) - pow(d,0.5);

cout<< " Raiz 1 = "<<raiz1<<endl;

cout<< " Raiz 2 = "<<raiz2<<endl;

}

else

{ cout<<"Las raices son imaginarias"<<endl;

raiz1=(-b/(2*a));

raiz2 = pow(-d,0.5);

cout<< "Raiz 1 = "<< raiz1 << " + i"<<raiz2<<endl;

cout<< "Raiz 2 = "<< raiz1 << " - i"<<raiz2<<endl;

}

getch();

}

EJECUCION

4.- Escriba un algoritmo que lea cuatro prácticas y halle el promedio. Las reglas son:

a) De no rendir alguna práctica el valor almacenado en esa práctica será 99.

b) De promediarse algún 99 el valor tomado para el promedio será de 0.

c) De existir algún 99 se promediara las otras tres prácticas.

d) De haber rendido las cuatro prácticas se eliminara la menor.

Solución:

ALGORITMO


p1, p2, p3, p4, menor1, menor2, menort son enteras

promedio es real



INICIO

1. Leer (p1)

2. Leer (p2)

3. Leer (p3)

4. Leer (p4)

5. Si (p1= 99)

Entonces

5.1. Si (p2=99) Entonces p2 0 FinSi



5.4. promedio (p2+p3+p4)/3.0

Sino

5.5. Si(p2=99)

Entonces

5.5.1. Si (p3=99) Entonces p3 0 FinSi

5.5.2. Si (p4=99) Entonces p4 0 FinSi

5.5.3. promedio (p1+p3+p4)/3

Sino

5.5.4. Si (p3=99)

Entonces

5.5.4.1. Si (p4=99) Entonces p4 0 FinSi

5.5.4.2. promedio(p1+p2+p4)/3.0

5.5.4.3. Sino

5.5.4.4. Si (p4=99)

Entonces

5.5.4.4.1. promedio (p1+p2+p3)/3.0

Sino

5.5.4.4.2. Si (p1<p2)

Entonces

5.5.4.4.2.1 menor1 p1

Sino

5.5.4.4.2.2 menor1p2

FinSi

5.5.4.4.3. Si (p3<p4)

Entonces

5.5.4.4.3.1 menor2 p3

Sino

5.5.4.4.3.2 menor2p4

FinSi

5.5.4.4.4. Si (menor1< menor2)

Entonces

5.5.4.4.4.1 menort menor1

Sino

5.5.4.4.4.2 menortmenor2

FinSi

5.5.4.4.5. promedio (p1+p2+p3+p4-menort)/3.0



FinSi

FinSi

FinSi

FinSi

6. Escribir(“El promedio es : “,promedio)

7. FIN

PROGRAMA

/* CODIGO:POOC1PROB4



OBJETIVO: CALCULAR PROMEDIO DE CUATRO PRACTICAS

REGLAS QUE OBEDECE EL PROGRAMA:

a) De no rendir alguna práctica el valor almacenado en esa práctica será 99.

b) De promediarse algún 99 el valor tomado para el promedio será de 0.

c) De existir algún 99 se promediara las otras tres prácticas.

d) De haber rendido las cuatro prácticas se eliminara la menor. */


#include<conio.h>

void main()

{ int p1, p2, p3, p4;

float promedio;

int menor1, menor2, menort;

clrscr();

cout<<" P1= ";cin>>p1;




if (p1==99)

{ if(p2==99) p2=0;

if(p3==99) p3=0;

if(p4==99) p4=0;

promedio =(p2+p3+p4)/3.0; }

else

if(p2==99)

{if(p3==99) p3=0;

if(p4==99) p4=0;


else

if (p3==99)

{if (p4==99) p4=0;


else

if (p4==99)

promedio = (p1+p2+p3)/3.0;

else

{if(p1<p2)



menor1=p1;

else

menor1=p2;

if(p3<p4)

menor2=p3;

else

menor2=p4;

if(menor1<menor2)

menort=menor1;

else

menort=menor2;

promedio=(p1+p2+p3+p4-menort)/3.0; }

cout<<"El promedio es : "<<promedio;

getch(); }

EJECUCION

(Caso 3: no rindió 1 práctica)

5.- Escriba un algoritmo que me permita hallar la fecha del día siguiente dada la fecha de un día cualquiera.

Ejemplo: Lee 31/12/2006

Escribe 01/01/2007

Lee 30/06/2005

Escribe 01/07/2005

Lee 15/07/2007

Escribe 16/07/2007

Solución:

ANALISIS

Tenemos tres casos

1.- Fin de año: en este caso hay que comprobar si el mes es 12 (Diciembre) y el día es 31; en este caso se

inicializa día y mes y se incrementa el año.

2.- Fin de mes: en este caso hay que comprobar si es el último día del mes o sea puede ser mes 6 y día 30 ó

mes 7 y día 31 o mes 2 y día 29 pero en año bisiesto; en este caso se inicializa el día, el mes se incrementa

en 1 y el año permanece igual.

3.- El caso no es ni fin de año ni fin de mes: se incrementa día; mes y año permanecen igual.

ALGORITMO




día, mes, año son enteras

cond1,cond2,cond3,cond4 son enteras

1. INICIO

2. Leer (día)

3. Leer (mes)

4. Leer (año)

5. cond1 (día=31) i (mes=12) /*Condición cambio de año*/

6. cond2 (día=31) i ((mes=1)o(mes=3)o(mes=5)o(mes=7)o(mes=8)o(mes= 10))/*Cambio de mes.(31 días)*/

7. cond3 (día=30) i ((mes=4)o(mes=6)o(mes=9)o(mes=11))/*Cambio de mes.(30 días)*/

8. cond4 ((día=28) i (mes=2) i (año%4)!=0)) o ((día=29) i (mes=2) i (año%4)= 0))/*Cambio de mes. febrero*/

9. Si (cond1)

Entonces

9.1. día 1

9.2. mes1

9.3. añoaño+1

Sino

9.4. Si (cond2 o cond3 o cond4)

Entonces

9.4.1. día 1

9.4.2. mesmes +1 Sino

9.4.3. díadia+1

FinSi

FinSi

10. Escribir(dia,mes.año)

11. FIN

PROGRAMA

/* CODIGO:POOC1PROB5


FECHA : 17 DE MARZO DE 2013

OBJETIVO: LEE UNA FECHA Y ESCRIBE FECHA DEL DIA SIGUIENTE */


#include<conio.h>

void main()

{ int dia, mes, a , cond1,cond2,cond3,cond4;

clrscr();

cout<<"Ingrese dia entre 1 y 31 ==> "; cin>>dia;

cout<<"Ingrese mes entre 1 y 12 ==> "; cin>>mes;

cout<<"Ingrese año entre 1900 y 2010 ==> "; cin>>a;

cond1 = (dia==31)&&(mes==12); /*Condición cambio de año*/

cond2 = (dia==31)&&((mes==1)||(mes==3)||(mes==5)||(mes==7)||(mes==8)||(mes==10));

cond3 = (dia==30)&&((mes==4)||(mes==6)||(mes==9)||(mes==11));

cond4 = ((dia==28)&&(mes==2)&&((a%4)!=0))|| ((dia==29) && (mes==2) && ((a%4)== 0));

if (cond1)

{ dia=1;

mes=1;



a =a+1; }

else

if(cond2 || cond3 || cond4)

{ dia = 1;

mes =mes +1; }

else

dia = dia+1;

cout<< "EL DIA SIGUIENTE ES ==> "<<dia<<"/"<<mes<<"/"<<a;

getch(); }

EJECUCION

ALGORITMOS CON ESTRUCTURAS DE DECISIÓN MULTIPLE

6.- Escriba un algoritmo que lea el precio de un artículo y el número de cuotas, calculando el pago mensual de

acuerdo al siguiente cuadro:

- 1 cuota. 0% de interés

- 2 cuotas 3% de interés.

- 4 cuotas 7% de interés





ALGORITMO

precio, pago_mes son reales

numero_c es entera

1. INICIO

2. Leer (precio)

3. Leer (numero_c)

4. Case(digito)

1: pago_mes precio

escribir(pago_mes)

2: pago_mes precio*(1+0.03)/numero_c

escribir(pago_mes)


escribir(pago_mes)


escribir(pago_mes)


escribir(pago_mes)


escribir(pago_mes)


escribir(pago_mes)



Sino: escribir(“Error el numero de cuotas no es válido”)

Fin Case

5. FIN

PROGRAMA/* CODIGO: POOC1PROB6



OBJETIVO: Lee precio de un articulo y numero de cuotas y calcula pago mensual */


# include<conio.h>

void main( )

{ float precio, pago_mes; int numero_c;

clrscr();

cout<< " Ingrese precio del articulo: ";

cin>>precio;

cout<< " Ingrese numero de cuotas: ";

cin>>numero_c;

switch( numero_c)

{ case 1: pago_mes = precio;

cout<< "Pago mensual= "<<pago_mes;

break;

case 2: pago_mes = precio*(1+0.03)/numero_c;


break;



break;



break;

case 10:pago_mes = precio*(1+0.20)/numero_c;


break;



break;



break;

default : cout<< " Error el numero de cuotas no es valido"; }

getch( );}

EJECUCION



ALGORITMOS CON ESTRUCTURAS

DE REPETICIÓN

7.- Escriba un algoritmo que calcule la serie exponencial con 3 dígitos decimales exactos.

Solución

ANALISIS

La serie exponencial es ex= 1 + x/1! +x2/2! + x3/3! ……+xn/n! + x(n+1)/(n+1)!....

Vemos que esta serie se inicializa con el valor 1.

La secuencia (Regla de formación) en el numerador es x0,x1,x2 ..

numerador numerador *x, valor inicial 1

En el denominador es 0!, 1!, 2!, 3! o sea

denominador denominador * i (i es el orden de la iteración o también contador).

Los 3 dígitos decimales exactos significan un error menor o igual a 0.0005(0.5 x 10-3 ), además el error de la serie

se estima como el primer termino despreciado o sé si tomamos n términos el error será x(n+1)/(n+1)!

Nota. x debe estar en el rango [0 1]

ALGORITMO


expx, termino, numerador, x son reales

cont, denominador son enteros

1. INICIO

2. error 1

3. maxerror 0.0005

4. expx 1

5. numerador 1

6. denominador1

7. contador1

8. Leer (x)

9. Mientras (error>= maxerror)

9.1. numerador numerador*x

9.2. denominadordenominador*contador

9.3. termino numerador/denominador

9.4. expx expx +termino

9.5. contador contador +1

9.6. error abs(termino*x/(contador+1))

Fin Mientras

10. Escribir(exp(x), expx) /* Muestro valor de librería y valor calculado.

11. FIN

PROGRAMA/* CODIGO: POOC1PROB7





OBJETIVO: CALCULA LA SERIE EXPONENCIAL CON 3 DIGITOS DECIMALES EXACTOS */


#include<conio.h>

#include<math.h>

void main()

{ int contador , denominador;

float expx,error,maxerror,termino, numerador,x;

clrscr();

maxerror= 0.0005;

error = 1;

expx = 1;

numerador = 1;

denominador = 1;

contador = 1;

cout<<"Ingrese valor x (0.0 y 1.0)==> "; cin>>x;

while (error>maxerror)

{ numerador = numerador *x;

denominador = denominador*contador;

termino = numerador/denominador;

expx = expx + termino;

contador = contador + 1;

error = fabs(termino*x/(contador +1)); }

cout<<endl<<endl;

cout<< "El valor calculado por programa es : "<<expx<<endl;

cout<< "El valor calculado con la función de biblioteca es:"<<exp(x)<<endl;

getch(); }

EJECUCION

EJERCICIOS PROPUESTOS

1. Escriba un algoritmo y programa que lea tres valores que representen los lados de un triángulo y me indique

si el triángulo es escaleno, isósceles o equilátero.

2. Escriba un algoritmo que genere 4 valores al azar entre 1 y 13 (cuatro cartas de una baraja de casinos) y me

indique si tenemos un par, 2 pares , un trío o un póker ( cuatro iguales).

3. Escriba un algoritmo que lea una expresión aritmética entera y me entregue el resultado final.

4. Por ejemplo lee 3 + 5 – 7 y escribe 1 cuando ingresamos el operador =.

5. Escriba un algoritmo y programa que lea “n” valores y me entregue el mayor de todos, el menor de todos y el

promedio final.( n será leído también).

6. Crear un algoritmo que nos permita calcular I=∫a

b

exp (x2 )dx ,los datos de ent rada serana ,b y x .

7. Escriba un algoritmo que nos permita hallar la fecha del dia anterior, dada la fecha de cualquier dia.



CAPITULO II

2 ESTRUCTURA DE UN PROGRAMA BORLAND C++.

2.1 Organización de un Programa Borland C++: Se compone de los bloques:


void main( ){………. ........... ………… }

Datos y Funciones Globales

Datos y funciones externas

Directivas del PreProcesador Include Macros


Directivas del Preprocesador: Permite que se realicen ciertas tareas antes que la compilación se efectúe.

Las directivas son normalmente #include y #define.

Ejemplo:

# include <math.h> // incluye el archivo fuente en C++ de las librerías matemáticas

# include <conio.h> // incluye el archivo fuente de manejo de pantalla

# define PI 3.1416 // indica que PI es equivalente a 3.1416

También:

# include <nombre_archivo> // Busca en directorio por defecto

# include “nombre_archivo”// Busca en directorio actual y luego en directorio por defecto

Declaraciones Globales: Indica que variables y funciones definidas por el usuario comunes (accesibles) a

todas las funciones del archivo fuente.

Ejemplo: # include <iostream.h>

int A,B; float C, D;

int media(int p1, int p2); // Prototipo

La función main(). Es el punto de inicio de la ejecución de un programa

En programas simples todo el código se coloca en el programa. Veamos un ejemplo

En programas más complejos el código va en las funciones

void main ( )

{ leer ( );

procesar_planilla( );

imprimir_planilla( ); }

Lo visualizamos así:


# include <iostream.h>

#include <conio.h>

void main ( )

{ int a,b,c;

clrscr();

cout<< “ingrese a: “;

cin>>a;

cout<< “ingrese b: “;

cin>>b;

c=a+b;

cout<<”La suma es:”<<c<<endl;

getch(); }


void inprimir_planillar( ){ }

void leer( ){ }

void main(){ }

void procesar_planillar( ){ }

2.2 Estructura General de un programa en Borland C++. -

Introducción .- Un programa en C++ se compone de una o más funciones. Por lo menos debe existir la función

main(), una función es un grupo de instrucciones que realizan una tarea (o tareas). Un programa nos permite

incluir una serie de archivos de cabecera, que también contiene definiciones y otras funciones.

Ejemplo : Programa que realiza una suma utilizando funciones y variables globales.


# include<conio.h>

/* Variables globales */

int operando1, operando2;

int resultado;

/* funciones globales, declaración de prototipos */

void leer( );

void sumar( );

void escribir( );

void main( )

{ leer ( );

sumar ( );

escribir ( ) ; }

/* desarrollo de las funciones */

void leer ( )

{ clrscr();

cout<< “ Operando1= “; cin >> operando1;

cout<< “ Operando2= “; cin >> operando2; }

void sumar ( )

{ resultado = operando1 + operando2; }

void escribir ( )

{ clrscr();

cout<< “ Suma = “ << resultado ;

getch(); }

Creación de un Programa.- Para crear y ejecutar un programa hay que realizar las siguientes etapas:

Utilizando un editor de texto escribimos el programa y lo grabamos, este programa grabado será el archivo

fuente del programa.

Genera nombre.cpp

Traducción del programa a lenguaje de maquina o un código entendible por el computador, llamado también

compilación, se genera el código objeto.

Genera nombre.obj

Enlace del código objeto con los códigos de las diferentes librerías produciéndose el código ejecutable.

Genera nombre.exe

Compilación, enlace y ejecución.- El editor, el compilador y la ejecución están disponibles en el entorno

integrado del Borland C++.

El editor en el menú edit

El compilador en Project

La ejecución en el menú debug (depuración).



2.3 Elementos de un programa en C++.- Se compone de elementos llamados tokens, que pueden ser

identificadores, palabras reservadas, comentarios, signos de puntuación, separadores y archivos de

cabecera.

Identificadores.- Cadenas de caracteres sirven para identificar cualquier elemento de un programa

como constantes, variables, funciones etc. Ejemplo: línea, leer_datos, valor, suelo, PI. Todo identificador

está compuesto por letras, dígitos y el carácter subrayado, el primer carácter debe de ser una letra.

Palabras reservadas.- Son identificadores que son utilizados por el sistema y no pueden ser utilizados

para otros fines. Ejemplo: char, return, break, if etc.

Comentarios.- Nos entregan información sobre el programa pero no son procesables. Existen dos tipos

en C

/* ........*/ Comentario se puede hacer por varias líneas

/* Realizado por: AAAAAAAAAA

Fecha: 99/99/99

Calcula aaaaa */

// Comentario para el final de la línea

contador = contador + 1; // Incremento unitario del contador

Signos de puntuación: Los puntos y comas terminan una sentencia, las llaves agrupan instrucciones,

las comas separan elementos iguales etc.

{ leer(a1,a2,a3);

procesar(a1, a2, a3);

escribir(a3); }

Separadores.- Espacios en blanco, tabulaciones, retornos de carro y avances de línea.

Archivos de cabecera.- Nos permiten incluir archivos al momento de compilación.

2.4 Tipos de Variables estándar en C++.- Datos estándar quiere decir aceptados por todos, en C++ tenemos

como en la mayoría de lenguajes enteros, reales y carácter.

Entero

Real

char

2.5 Constantes.- Se clasifican en:

Constantes literales. ( Escritas directamente en el programa)

Enteras. 125, 100, 0x372

Reales. 1.25E-4, 75.25

Carácter. ‘A’, ‘n’

Cadena. “jose ruiz”, “------------“

Constantes definidas(Simbólicas). Definidas mediante #define

#define linea “---------------“


int 9 digitos 4 bytes long 9 digitos 4 bytes

float 3.4 x 10-38 a 3.4 x 1038 4 bytes double 1.7 x 10-308 a 1.7 x 10308 8 byteslong double 3.4 x 10-4932 a 3.4 x 103932 10bytes

Char -128...... 127 1 byteUnsigned char 0..255 1 byte


#define maximo 1000

#define raiz2 1.4142

Constantes enumeradas. Se utilizan para clarificar un programa, un ejemplo seria: enum frutas

{ naranja, papaya, fresa, limón}, inmediatamente el compilador asocia un numero de orden a cada

elemento, el primero será 0 (naranja)

Constantes declaradas. Se declara con el formato

const tipo nombre = valor;

ejemplo: const int dias_mes = 30;

const char[ ] titulo = “ MENU PRINCIPAL”

2.6 Variables.- Se le asigna una posición de memoria cuyo contenido si puede ser modificado, al contrario de las

constantes que no pueden ser modificadas. La variable tiene un identificador, un tipo de valor que almacena

y una dirección. Su forma general es:

Ejemplo: int contador = 0, suma = 0;

float raiz = 1.0;

long factorial=1;

2.7 Entrada y salida simple en C++.- La entrada y salida básica en C++ se realiza utilizando los flujos cin y cout.

El flujo cin(entrada) conecta el dispositivo por defecto de enatrada(teclado) con el sistema.

El flujo cout(salida) conecta el programa con el dispositivo asignado por defecto a la salida(Pantalla).

Para colocar información en cout se utiliza el operador sobrecargado “<<” y para tomar información en cin se

utiliza el operador sobrecargado “>>”. Veamos el ejemplo 1.-



Tipo nombre [= valor];

/* CODIGO: POOC2E1


OBJETIVO: Mostrar la salida en pantalla utilizando el operador << y el flujo cout, con constantes y variables. */


# include<conio.h>

#define linea1 "|---------------------------------------------------|"

#define linea2 "|---------------------------------------------------|"

void main( )

{ int i;

clrscr();

cout<<linea1<<endl; cout<<'|';

for (i=1;i<=20;i++)

cout<<i<<" ";

cout<<'|'<<endl;

cout<<linea2; getch(); }

PROGRAMA

EJECUCION

En la lectura se asignara valores a las variables sea una por una o varias a la vez, como en el ejemplo 2.-PROGRAMA

2.8 Secuencias de escape.- Las secuencias de caracteres en las que el primero es la barra invertida, se

denominaron secuencias de escape y nos permiten enviar ciertos caracteres a la pantalla. Por ejemplo, \n

se utiliza para representar el carácter nueva línea (decimal 10) y \t será tabulación horizontal. La tabla es:.

Secuencia Valor Símbolo Que hace

\a 0x07 BEL Sonido audible (bell)

\b 0x08 BS Retroceso (backspace)

\f 0x0C FF Salto de formato (formfeed)

\n 0x0A LF Saltar una línea (linefeed)

\r 0x0D CR Retorno de carro (carriage return)

\t 0x09 HT Tabulación horizontal (H Tab)

\v 0x0B VT Tabulación vertical (V Tab)

Veamos el ejemplo 3.- PROGRAMA



/* CODIGO: POOC2E2


OBJETIVO: Mostrar las diferentes formas de leer valores y almacenarlos en las variables */


#include<conio.h>

void main( )

{ int voltaje,corriente;

clrscr();

cout<<"Ingrese voltaje ==> ";cin>>voltaje;

cout<<"Ingrese corriente=> ";cin>>corriente;

cout<<"Voltaje = "<<voltaje<<endl; cout<<"Corriente = "<<corriente<<endl;

cout<<"Ingrese voltaje y corriente separados por blancos ==> ";

cin>>voltaje>>corriente;

cout<<"Potencia ==> "<<voltaje*corriente; getch();}

/* CODIGO: POOC2E3


OBJETIVO: MANEJO DE SECUENCIAS DE ESCAPE */


#include<conio.h>

EJECUCION

EJECUCION



/* CODIGO: POOC2E3


OBJETIVO: MANEJO DE SECUENCIAS DE ESCAPE */


#include<conio.h>

2.9. Manipulación y formato de datos de salida.- El precisar con cuantos decimales debe mostrarse nuestros

datos de salida y que ancho y otras características se llama dar formato a la salida. Cuando deseamos

manejar este formato lo podemos realizar de la siguiente manera:

1. Mediante el uso de funciones miembro de un objeto de flujo. Su sintaxis es la siguiente:

nombreObjetoInvocador.nombreFuncionMiembro(listaArgumentos );

cout.width( 5 );

cout.fill( '*' );

cout.precision( 3 );

2. Mediante el uso de funciones especiales llamadas manipuladores, con o sin

argumentos.

cout << flush;

cout << endl;

cout << setw( 6 ) << 12 << endl;

cout << seprecision( 2 ) << 12.325 << endl;

3. Mediante el uso de banderas (indicadores) como argumentos de la función miembro setf( ) del objeto de flujo:

cout.setf( ios::fixed );

cout.setf( ios::showpoint );

Veamos la tabla de manipuladores de flujo de salida:

MANIPULADOR FUNCION QUE REALIZA

dec Establece la base decimal.

hex Establece la base hexadecimal

oct Establece la base octal.

endl Inserta nueva línea y cambia de flujo

ends Inserta un cero nulo al final de la

cadena.

flush Vacía el flujo

setbase(int n) Establece la conversión de base.



resetiosflags(long f) Limpia el formato especificado por f.

setiosflag( long f) Establece formato especificado por

f.

setfill(int c) Rellena con el carácter c.

setprecision(int n) Establece precisión de punto flotante

a n.

setw(int n) Establece el ancho de campo a w.

Ejemplo 4.- Veamos un ejemplo de dec,oct y hex.

PROGRAMA

EJECUCION

Tabla de indicadores de formato:

INDICADOR LO QUE REALIZA

ios::left Justifica a la izquierda dentro de

setw.

ios::rigth Justifica a la derecha dentro de setw.

ios::scientific Muestra números en notación



/* CODIGO: POOC2E4



OBJETIVO: Utilizacion de manipuladores de flujo de salida */


#include<conio.h>

void main( )

{ // Lee un valor y lo muestra en formato decimal, octal y hexadecimal

int numero;

clrscr();

cout<<"Ingrese un numero : ";

cin>>numero;

cout<<"Numero decimal......"<<numero<<endl;//base decimal

cout<<"Numero octal........"<<oct<<numero<<endl;//base octal

cout<<"Numero hexadecimal.."<<hex<<numero<<endl;//base hexadecimal

getch();

}

científica.

ios::fixed Muestra en formato de punto fijo.

ios::dec Formatea a base 10.

ios::hex Formatea a base 16.

ios::oct Formatea a base 8.

ios::uppercase Formatea la parte literal a

mayúscula.

ios::showbase Imprime el prefijo de base.

Ios::showpos Imprime signo

Ios::showpoint Completa con ceros.

Ejemplo 5.- Veamos un ejemplo que maneje la precisión de salida de un valor real.

PROGRAMA

EJECUCION



/* CODIGO: POOC2E5


OBJETIVO: Muestra el uso del manipulador setprecision( )

para indicar el número de dígitos decimales del valor flotante.*/

#include <iostream.h> //Para cout

#include <iomanip.h> //Para setprecision( )

#include <conio.h> //Para getch()

void main( void )

{ float valor = 3.1416;

cout << setiosflags( ios::fixed );

cout << setprecision( 0 ) << valor << endl;







getch(); }

PROBLEMAS

1. Dado un numero “n” se pide calcular la cantidad de cifras impares y de cifra pares que tiene “n”. Utilizar

variables globales.

PROGRAMA

EJECUCION

Nota: Observe algunos detalles, las variables son globales, por lo tanto los contadores se inicializan automáticamente

desde cero. Además num es una variable entera solo debe permitir valores de 5 cifras pero se sobrepasa, quiere

decir que el tipo entero ocupa más de dos bytes (4 bytes).

2.- Escribamos un programa que nos permita realizar operaciones con números complejos, este programa realizara la

suma, resta y multiplicación con números complejos, la división se deja como tarea para el estudiante.

PROGRAMA




OBJETIVO: Halla suma, resta y multiplicación de números complejos */





OBJETIVO: Lee un numero y halla cuantos cifras pares y cifras pares componen el numero. */

int num,cifra;

int contp, conti; // contador de cifras pares y contador de cifras impares


# include<conio.h>

void main( )

{ clrscr( );

gotoxy(30,2); cout<<"Ingrese un numero: ";cin>>num;;

while( num!=0)

{ cifra = num%10;

if (cifra%2==0)

contp++;

else

conti++;

num=num/10; }

gotoxy(30,6);cout<<"Cifras pares : "<<contp;

gotoxy(30,7);cout<<"Cifras impares: "<<conti;

getch(); }



# include<conio.h>

void main( )

{ float ar, ai, br, bi, rr ,ri;

char opcion;

do

{ clrscr( );

gotoxy(30,2);

cout<<"OPERACIONES CON COMPLEJOS";

gotoxy(30,6);cout<<"1.- Suma ";

gotoxy(30,7);cout<<"2.- Resta ";

gotoxy(30,8);cout<<"3.- Multiplicación ";

gotoxy(30,9);cout<<"4.- División ";

gotoxy(30,10);cout<<"5.- Salir ";

gotoxy(30,16);


cin >> opcion;

switch ( opcion)


gotoxy(30,2); cout<<"SUMA";

gotoxy(30,6);cout<<"ar = "; cin >> ar;

gotoxy(30,7);cout<<"ai = "; cin >> ai;

gotoxy(30,8);cout<<"br = "; cin >> br;

gotoxy(30,9);cout<<"bi = "; cin >> bi;

rr = ar + br;

ri = ai + bi;

gotoxy ( 30,22); cout << " rr = " << rr;

gotoxy ( 30,23); cout << " ri = " << ri;

getch();

break;

case '2': clrscr();

gotoxy(30,2); cout<<"RESTA";





rr = ar - br;

ri = ai - bi;

gotoxy ( 30,22); cout << " rr = " << rr;

gotoxy ( 30,23); cout << " ri = " << ri;

getch();

break;

case '3': clrscr();

gotoxy(30,2); cout<<"MULTIPLICACION";







rr = (ar*br) - (ai*bi);

ri = (ar*bi) + (ai*br);

gotoxy ( 30,22); cout << " rr = " << rr;

gotoxy ( 30,23); cout << " ri = " << ri;

getch();

break;

case '4': clrscr();

cout << " tarea ";

getch();

break; }

} while ( opcion!='5'); }

EJECUCION

3.- Escriba un programa que utilice la definición del tipo enumerado color, e imprima el color escogido. PROGRAMA /* CODIGO: POOC2PROB3 FECHA: 18 DE MARZO DE 2013 OBJETIVO: Maneja tipo enumerado */# include<iostream.h>

# include<conio.h>

void main( )

{ enum color {rojo,verde,amarillo,azul,negro};

color c1=rojo,c2 = amarillo, c3 = negro;



switch(c1)

{ case 0:cout<<"ROJO"<<endl;break;

case 1:cout<<"VERDE"<<endl;break;

case 2:cout<<"AMARILLO"<<endl;break;

case 3:cout<<"AZUL"<<endl;break;

case 4:cout<<"NEGRO"<<endl;break; }

switch(c2)






switch(c3)






getch();}

EJECUCION

4.- Elaborar un programa que haga cálculos para generar una boleta de ventas incluyendo el IGV, considere el uso

de salida formateada y también la función gotoxy().

PROGRAMA



OBJETIVO: Maneja la función gotoxy y presenta resultados de una boleta de ventas con una salida formateada. */


# include<conio.h>

# include<iomanip.h>

void main( )

{ char producto[30];

float precio,cantidad,igv,total,sumatotal;

int n,i;

clrscr();

cout<<" Ingrese cantidad de productos ==> ";

cin>>n;

clrscr();

gotoxy(6,4);cout<<"LISTADO DE COMPRAS";

gotoxy(58,4);cout<<"BOLETA DE PAGOS" ;

gotoxy(58,6);cout<<"Producto";

gotoxy(58,7);cout<<"========";



gotoxy(68,6);cout<<"Precio";

gotoxy(68,7);cout<<"======";

cout<<setiosflags(ios::fixed);

cout<<setiosflags(ios::showpoint);

cout<<setprecision(2);

cout<<setiosflags(ios::right);

total=0;

for(i=1;i<=n;i++)

{ gotoxy(2,8+i);cout<<"Producto "<<i<<" : ";cin>>producto;

gotoxy(24,8+i);cout<<"Precio "<<i<<" : ";cin>>precio;

gotoxy(40,8+i);cout<<"Cantidad "<<i<<" : ";cin>>cantidad;

gotoxy(58,8+i);cout<<"| "<<setw(5)<<producto;

gotoxy(67,8+i);cout<<"| "<<setw(5)<<precio*cantidad;

total =total+precio*cantidad; }

igv=total*0.19;

sumatotal=total+igv;

gotoxy(58,8+i);cout<<"------------------";

gotoxy(53,9+i);cout<<"TOTAL "<<setw(6)<<total;

gotoxy(53,10+i);cout<<"IGV "<<setw(6)<<igv;

gotoxy(53,11+i);cout<<"----------------------";

gotoxy(53,12+i);cout<<"TOTAL A PAGAR "<<setw(7)<<sumatotal;

getch(); }

EJECUCION



CAPITULO III



3 ESTRUCTURAS DE CONTROL EN “C”

3.1 Expresiones y operadores

Expresiones.- Una expresión es una secuencia de operadores y operandos, aunque también podemos

tener algunas expresiones que salen de este formato. Ejemplo : a = *c; p1 = &c; numero ++.

Operadores aritméticos.- Nos permiten realizar las operaciones aritméticas básicas sean del tipo real

(float) o entero, considerando que en lenguaje “C” se define el tipo de operación por los operandos, si al

menos un operando es del tipo float la operación se realizara en el modo real.

Ejemplo : 4%3 será 1 y 3%4 será 3 ; 10/4 será 2 y 10/4.0 será 2.5

En el primer caso la división es 1 y el resto 1.

En el segundo caso la división es 0 y el resto 3

En el tercer caso la división es 2 y en el cuarto caso la división es 2.5 (Modo real)

Operadores de incremento y decremento.- Los operadores ++ y - - suman o restan 1 a su argumento. Por

ejemplo a++ y ++a producen el mismo efecto. Sobre el argumento pero :

int numero, valor ;

valor = 6;

numero = valor++; //Asigna a numero 6 a numero y luego incrementa valor a 7

numero = ++valor; // Incrementa valor a 7 y luego asigna 7 a numero

Lo mismo sucede con cont - - y - - cont


Operador Entero Real . + Unitario mas Unitario mas - Unitario menos Unitario menos + Suma Suma - Resta Resta * Producto Producto / Cociente de división entera Cociente real % Resto de división entera ++ Incremento -- Decremento


Operadores de asignación, relación, lógicos y desplazamiento.-

Operadores de asignación.- Consideramos el símbolo = operador de asignación. Por ejemplo podemos

colocar cont1 = cont2 = cont3 = 0; Le asignamos el valor cero a los tres contadores pero esta operación

se realiza de izquierda a derecha. También podemos abreviar c+=5 ; que es equivalente a c = c +5,

tenemos la siguiente tabla

Operadores relacionales.- Relacionan operandos enteros o reales pero su resultado es booleano, estos son:

a == b uno si es verdadero y cero si a no es igual a b

a != b uno si es verdadero y cero si a no es igual a b

a < b uno si es verdadero y cero si a no es igual a b

a > b uno si es verdadero y cero si a no es igual a b

a <= b uno si es verdadero y cero si a no es igual a b

a >= b uno si es verdadero y cero si a no es igual a b

Pero también podemos tener a = b > c en cuyo caso a valdrá 1 si b es mayor que c y cero en caso

contrario.

Operadores lógicos.- Son el not el and y el or, Relacionan operandos booleanos y su resultado es

booleano, estos son:

Negación ! el not lógico

And && el and . para que sea verdadero sus dos operandos deben ser verdaderos.

Or || el or . para que sea verdadero basta que un operando sea

verdadero.

Ejemplo 1 : Escriba un programa que lea un numero y lo muestre invertido. Si lee 2345 debe escribir 5432.

PROGRAMA


Operador Abreviatura Sentencia += a+=b a=a+b -= a-=b a=a-b *= a*=b a=a*b /= a/=b a=a/b %= a%=b a=a%b


/* CODIGO: POOC3E1


FECHA:18 DE MARZO DE 2013

OBJETIVO: Lee un numero y lo invierte */


# include<conio.h>

void main( )

{ int numero, num_inv, digito ;

clrscr( );

num_inv = 0;

cout << " Ingrese un numero de 4 digitos => ";

cin >> numero;

while ( numero >= 10)

{ digito = numero % 10;

num_inv = num_inv*10 + digito;

numero = numero / 10; }

num_inv = num_inv*10 + numero ;

cout << " El numero invertido sera = " << num_inv;

getch(); }

EJECUCION

Operadores Especiales.- Existen otros operadores que pasaremos a revisar

o Operadores de Dirección.- Tenemos los siguientes

“*”accede el campo apuntado.

& Devuelve la dirección del operando

Ejemplo 2: Escriba un programa que maneje punteros de forma básica.

PROGRAMA

EJECUCION


/* CODIGO: POOC3E2


FECHA: 18 de MARZO DE 2013

OBJETIVO: Observar manejo de punteros en forma basica */


# include<conio.h>

void main( )

{

int *p1 ; // Declaramos una variable tipo puntero

int a, b ; //Declaramos las variables a y b del tipo entero

clrscr( );

a = 17;

b = 18;

p1 = &a; // p1 apunta hacia a

cout << "Valor apuntado por p1 ==> "<<*p1<<endl; // Se imprime el valor apuntado por p1

cout << "Direccion de a almacenada en p1 ==> "<<hex << p1<< endl; // Imprime la dirección de a contenida en p1

cout << dec; // vuelve al formato decimal

p1 =&b; // p1 toma la dirección de b

cout << "Nuevo valor apuntado por p1==> "<<*p1; // muestra valor almacenado en el campo apuntado por p1(b)

getch(); }


/* CODIGO: POOC3E1


FECHA:18 DE MARZO DE 2013

OBJETIVO: Lee un numero y lo invierte */


# include<conio.h>

void main( )

{ int numero, num_inv, digito ;

clrscr( );

num_inv = 0;

cout << " Ingrese un numero de 4 digitos => ";

cin >> numero;

while ( numero >= 10)

{ digito = numero % 10;

num_inv = num_inv*10 + digito;

numero = numero / 10; }

num_inv = num_inv*10 + numero ;

cout << " El numero invertido sera = " << num_inv;

getch(); }

“.” Accede a un miembro de un objeto o variable estructurada

“ “Accede a un miembro de un objeto apuntado por el operando de la izquierda.

Operador Condicional.- Su forma es

Operador Coma, Operador( ),Operador[ ], Operador : .-

Coma combina expresiones a> b , c > 10 // a mayor que b , c mayor que 10

( ) Llama a funciones y también altera prioridad

[ ] Acompaña a los arrays

:: Indica ámbito void empleado :: planilla ( ) // indica la función planilla perteneciente a

empleado.

Ejemplo 3.- Escriba un programa que simule un juego de dados. Las reglas son:

a) En la primera jugada si obtiene una suma de los dados de

a. 2,3 o 12 pierde el juego

b. 7 u 11 gana el juego

c. Otra suma vuelve a jugar

b) A partir de la segunda jugada el jugador sigue las reglas

a. Si repite la primera suma gana

b. Obtiene 7 pierde

PROGRAMA


expresion_c ? expresion_v : expresion_f

v1 > v2 ? v1 : v2

devuelve el mayor valor de v1 , v2

/* CODIGO: POOC3E3


OBJETIVO: Escribir un programa que simula un juego de dados */


# include<conio.h>

# include<stdlib.h>

# include<time.h>

void main( )

{ int juego1, juego, dado1,dado2;

clrscr ();

randomize();

dado1 = random(6) + 1;


juego1 = dado1 + dado2;

cout<< juego1<<endl;

if ( (juego1 == 7 ) || ( juego1 == 11 ) )

cout << " Gano juego" ;

else if ( (juego1 == 2) || (juego1 == 3 ) || ( juego1== 12))

cout << " Perdio juego";

else

{ do { dado1 = random(6) + 1;



EJECUCION

3.2 ESTRUCTURAS DE CONTROL EN LENGUAJE “C”

Son las siguientes:

Sentencia if – else

Sentencia switch

Sentencia while

Sentencia do – while

Sentencia for.

Sentencia if .- Nos permite derivar el control hacia uno de dos puntos del programa.

Forma General

if ( condición)

{......(1)............. ;

.....................;

}

[else

{ .........(2)..........;

...................;

}]

ss

Funcionamiento:

Se evalúa la condición, si esta se cumple se ejecuta el bloque 1, caso contario se ejecuta el bloque 2, si existe.

Finalmente pasa el control de ejecución a la siguiente sentencia(ss).

Ejemplos:


/* CODIGO: POOC3E3


OBJETIVO: Escribir un programa que simula un juego de dados */


# include<conio.h>

# include<stdlib.h>

# include<time.h>

void main( )

{ int juego1, juego, dado1,dado2;

clrscr ();

randomize();



juego1 = dado1 + dado2;

cout<< juego1<<endl;

if ( (juego1 == 7 ) || ( juego1 == 11 ) )

cout << " Gano juego" ;

else if ( (juego1 == 2) || (juego1 == 3 ) || ( juego1== 12))

cout << " Perdio juego";

else

{ do { dado1 = random(6) + 1;



If(nota > 10)

cout<< “Curso Aprobado”;

If((numero%2)==0)

cout<< “ El numero es par”;

else

cout<<”El numero es impar”;

Sentencia if anidada.- Se dice que una sentencia esta anidada dentro de otra cuando una de ellas (la externa)

contiene completamente las sentencias de la otra(la interna o anidada). Veamos esto:

if (condicion1) { ………………….; …………………..; ……………………; if(condicion2) {……………………..; …………………….; ……………………; } ………………………….; }else { ………………………..; ………………………..; …………………………; ………………………….; }Podemos observar que el if con condicion2 esta anidado en el if con condicion1 y que el if con condicion3(que tiene a

su vez tiene parte else) está también anidado en el if con condicion1.

Ejemplo 4.- Programa que lee un número y me muestra si es múltiplo de 3, 4 o 5.



/* CODIGO: POOC3E4


OBJETIVO: Ejemplo de if anidado, programa determina si un numero es de 2, 3 o 4 cifras y si es multiplo de 3 o no */


# include<conio.h>

void main( )

{ int numero;

clrscr ();

cout<< " ingrese un numero ==> ";

cin>>numero;

if ((numero> 9) && (numero<10000))

{ if (numero>999)

if(numero%3==0)

cout<<" Numero de cuatro cifras y multiplo de 3";

else

cout<<" Numero de cuatro cifras y no es multiplo de 3";

else

if (numero >99)

if(numero %3==0)

cout<<" Numero de tres cifras y multiplo de 3";

else

cout<<" Numero de tres cifras y no es multiplo de 3";

else

if(numero%3==0)

cout<<" Numero de dos cifras y multiplo de 3";

EJECUCION

Ejemplo 5.- Programa que lee tres notas y halla el promedio eliminando la menor y duplicando la mayor.

PROGRAMA



/* CODIGO: POOC3E4


OBJETIVO: Ejemplo de if anidado, programa determina si un numero es de 2, 3 o 4 cifras y si es multiplo de 3 o no */


# include<conio.h>

void main( )

{ int numero;

clrscr ();

cout<< " ingrese un numero ==> ";

cin>>numero;

if ((numero> 9) && (numero<10000))

{ if (numero>999)

if(numero%3==0)

cout<<" Numero de cuatro cifras y multiplo de 3";

else

cout<<" Numero de cuatro cifras y no es multiplo de 3";

else

if (numero >99)

if(numero %3==0)

cout<<" Numero de tres cifras y multiplo de 3";

else

cout<<" Numero de tres cifras y no es multiplo de 3";

else

if(numero%3==0)

cout<<" Numero de dos cifras y multiplo de 3";

/* CODIGO: POOC3E5



OBJETIVO: Ejemplo de if que lee tres notas y calcula mayor, menor y halla

promedio, duplicando la mayor y eliminando la menor */


# include<conio.h>

void main( )

{ int nota1,nota2,nota3,menor,mayor;

float promedio;

clrscr ();

cout<< " ingrese nota1 : "; cin>>nota1;



menor=nota1;

mayor=nota1;

if (nota2<menor)

menor = nota2;

if (nota3<menor)

menor = nota3;

if (nota2>mayor)

mayor = nota2;

if (nota3>mayor)

mayor = nota3;

//Calculando promedio

promedio= (nota1+nota2+nota3+mayor-menor)/3.0;


getch(); }

EJECUCION

Ejemplo 6.- Escriba un programa que lea 20 edades y me indique cuantos son :

Bebes (0-5años)

Niños (5-12 años)

Adolescentes (12-16 años)

Jóvenes (16-25)

Adultos (25-50)

Mayores (50 a mas)

PROGRAMA

/* CODIGO: POOC3E6

FECHA: 18 de MARZO DE 2013

OBJETIVO: Ejemplo que lee 20 edades y me indique cuantos son :Bebes (0-5años),Niños (5-12 años), Adolescentes (12-16 años),

Jóvenes (16-25),Adultos (25-50), Mayores (50 a mas) */


# include<conio.h>

void main( )

{ int edad,i;

int contb=0;//contador de bebes

int contn=0;//contador de niños

int conta=0;//contador de adolescentes

int contj=0;//contador de jovenes

int contd=0;//contador de adultos

int contm=0;//contador de mayores

clrscr ();

for(i=1;i<=20;i++)

{ cout<< " ingrese edad "<<i<< " : ";cin>>edad;

if ( edad>=0)

if (edad<=5)

contb=contb+1;

else if (edad<=12)

contn=contn+1;

else if(edad<=16)

conta=conta+1;



/* CODIGO: POOC3E5



OBJETIVO: Ejemplo de if que lee tres notas y calcula mayor, menor y halla

promedio, duplicando la mayor y eliminando la menor */


# include<conio.h>

void main( )

{ int nota1,nota2,nota3,menor,mayor;

float promedio;

clrscr ();




menor=nota1;

mayor=nota1;

if (nota2<menor)

menor = nota2;

if (nota3<menor)

menor = nota3;

if (nota2>mayor)

mayor = nota2;

if (nota3>mayor)

mayor = nota3;

//Calculando promedio

promedio= (nota1+nota2+nota3+mayor-menor)/3.0;


getch(); }

else if (edad <=25)

contj=contj+1;

else if (edad<=50)

contd=contd+1;

else

contm=contm+1; }

//Mostrando resultados

cout<<contb<< " bebes"<<endl;

cout<<contn<< " niños"<<endl;

cout<<conta<< " adolescentes"<<endl;

cout<<contj<< " jovenes"<<endl;

cout<<contd<< " adultos"<<endl;

cout<<contm<< " mayores"<<endl;

getch(); }

EJECUCION

Sentencia switch.- Deriva el control hacia uno de varios puntos del programa, permite realizar una selección

múltiple.

Forma General

switch ( expression)

{ case const 1 : ................... ;

....................;

break;

case const 2 : ................... ;

....................;

break;

case const 3 : ................... ;

....................;



break;

case const 4 : ................... ;

....................;

break;

[ default : .....................;

.....................;

break;]

}

Funcionamiento:

La expresión de control o selector se evalúa y se compara con cada una de las etiquetas de case. La

expresión selector debe ser un tipo ordinal (por ejemplo, int, char, pero no float o string). Cada etiqueta es un valor

único, constante y cada etiqueta debe tener un valor diferente de los otros. Si el valor de la expresión selector es

igual a una de las etiquetas case –por ejemplo, etiquetai- entonces la ejecución comenzará con la primera

sentencia de la secuencia sentenciai y continuará hasta que se encuentra el final de la sentencia control switch, o

hasta encontrar la sentencia break. Lo normal es que la sentencia break termine el bloque y después que siga la

ejecución en la siguiente sentencia switch( ).

Ejemplo 7: Escriba un programa que lea un dia de semana del 1 al 7 y lo imprima en letras . Si lee 1 escribe LUNES.

PROGRAMA

/* CODIGO: POOC3E7


OBJETIVO: Elige una opción de un menú simple usando la sentencia condicional SWITCH. */


#include <conio.h>

void main()

{ int dia;

clrscr();

cout<<"Introduce el dia: ";

cin>>dia;

switch(dia){

case 1: cout<<"Lunes"; break;

case 2: cout<<"Martes"; break;

case 3: cout<<"Miércoles"; break;

case 4: cout<<"Jueves"; break;

case 5: cout<<"Viernes"; break;

case 6: cout<<"Sábado"; break;

case 7: cout<<"Domingo"; break;

default:cout<<"No es un dia de semana";

}

getch(); }

EJECUCION



Note que el default no tiene break y es que la salida en este caso es por término de la instrucción switch.

Sentencia while.- Nos permite ejecutar repetidamente un grupo de sentencias hasta que el valor de la

expresión se hace cero (condición falsa)

Forma General

while ( expresión)

{................... ;

.....................;

.....................;

}

Funcionamiento:

La expresión booleana o condición se evalúa y el bucle se repite mientras la condición es verdadera. El bucle while

nunca iterara si la condición comprobada es inicialmente falsa.

Ejemplo 8:

PROGRAMA

EJECUCION



/* CODIGO: POOC3E8



OBJETIVO: Ejemplo de estructura repetitiva while */


# include<conio.h>

# include<stdlib.h>

# include<time.h>

void main( )

{ int numero, suma = 0;

int cont = 1;

clrscr();

randomize();

while ( cont <= 100 )

{ numero=random(20);

suma = suma+ numero;

cont++; }

cout << "La media es = " << suma / 100.0;

getch(); }

.

Comentario: Como suma es un acumulador se inicializa en cero, en cambio en este caso cont va contando por adelantado y su valor final

será 101. Con cont igual a 101 ya no se cumple la condición y por lo tanto se sale del bucle while, a esta variable denominada cont se le

conoce también como variable de control del bucle while, esta variable necesariamente debe ser modificada dentro del rango del while pues

de no suceder esto estaríamos en un lazo infinito.

Sentencia do-- while.- Las sentencias se ejecutan repetidamente hasta que el valor de la expresión se

hace cero (falso)

Forma General

do

{................... ;

.....................;

.....................;

} while ( expresión);

Funcionamiento:

Se ejecutan las sentencias y a continuación se evalúa la expresión, y si es verdadero (distinto de cero), el control se

pasa de nuevo al principio de la sentencia do y el proceso se repite, hasta que la condición (expresión) sea

falsa(cero) y el control pasa a la sentencia siguiente.

Ejemplo 9:

El siguiente ejemplo visualiza los números, cuadrados y cubos de los 20 primeros números:

PROGRAMA

EJECUCION



/* CODIGO: POOC3E9



OBJETIVO: Presenta cuadrados y cubos de los 20 primeros numeros. Usando el do while */


# include<conio.h>

# include<math.h>

void main( )

{ int numero=1;

do

{cout << numero << " " <<pow(numero,2)<<" "<<pow(numero,3) << endl ;

numero++;

}

while (numero < 21);

getch(); }

Sentencia for.- Las sentencias se ejecutan hasta que el valor de la expresion2 sea cero o sea falso.

Forma General

for ( exp1 ; exp2 ; exp3)

{................... ;

.....................;

.....................; }

Funcionamiento:

Una sentencia for ejecuta la iteración de un bucle un número determinado de veces. El lazo for tiene tres partes:

exp1, inicializa las variables de control del bucle; exp2, es la condición que determina si el bucle realiza otra iteración;

la última parte del bucle for es la cláusula que incrementa o decrementa las variables de control del bucle.

Exp1 se utiliza para inicializar la variable de control de bucle; a continuación exp2 se evalúa, si es verdadera (distinta

de cero), se ejecuta la sentencia y se ejecuta exp3 y el control pasa de nuevo al principio del bucle. La iteración

continúa hasta que exp2 es falsa (cero), en cuyo momento el control pasa a la sentencia siguiente al bucle.

Ejemplo 10: Imprimir todos los primos de dos dígitos.

PROGRAMA



/* CODIGO: POOC3E10



OBJETIVO: Imprime los primos menores que 100 o sea dos digitos. Usando el lazo repetitivo for */


# include<conio.h>

void main( )

{ int i,j , primo;

for(i=10; i<100; i++)

{ primo = 1;

for ( j=2;j<i ;j++)

if ( i%j==0)

{primo = 0;

break; }

if(primo == 1)

cout<<i<<endl; }

getch(); }

EJECUCION

Sentencias break y continue

El flujo de control ordinario de un bucle se puede romper o interrumpir mediante las sentencias break y continue.

La sentencia break produce una salida inmediata del bucle flor en que se encuentra situada:

for (i = 0; i < 100; i++)

{

cin » x;

if (x < 0.0)

{

cout <<”salir del bucle” <<endl;

break;

}

cout << sqrt(x)<< endl;

}

La sentencia break también se utiliza para salir de la sentencia switch.

La sentencia continue termina la iteración que se está realizando y comenzará de nuevo la siguiente iteración:

for (i = 0; i < 100; ++i)

{

cin >> x;

if (x < 0.0)

continue;

}

Advertencia:

• Una sentencia break puede ocurrir únicamente en el cuerpo de una sentencia for, while, do o switch.

• Una sentencia continue sólo puede ocurrir dentro del cuerpo de una sentencia for, while o do.

PROBLEMAS

ESTRUCTURAS DE CONTROL



1. Se tienen 6 datos que son los nombres y edades de tres personas, escriba un programa que lea los tres nombres

y edades e imprima los nombres considerando las edades en forma creciente.

SOLUCION:

A) PROGRAMA:




OBJETIVO: LEE TRES NOMBRES Y EDADES E IMPRIME LOS NOMBRES EN FORMA CRECIENTE POR EDAD */


# include<conio.h>

void main( )

{

int edad1, edad2, edad3;

char nombre1[40], nombre2[40], nombre3[40];

clrscr( );

cout<< " Ingrese nombre 1 ==> "; cin>> nombre1;

cout<< " Ingrese edad 1 ==> "; cin>> edad1;





cout<<endl<<endl<<endl;

cout<< "LOS NOMBRES POR EDADES SERA:"<<endl<<endl;

if ( edad1 < edad2)

if( edad2 < edad3)

cout<< nombre1<< " "<<nombre2<< " "<<nombre3<<endl;

else

if (edad1<edad3)


else


else

if (edad1 <edad3)


else

if(edad2<edad3)


else


getch( );

}

B) RESULTADOS:



2. Escriba un programa que lea un nombre y su respectiva edad, esta información debe procesarse e imprimirse el

nombre y el periodo al cual pertenece la persona.

SOLUCION:

PROGRAMA




OBJETIVO: Lee nombres y edades e imprime el periodo en el que se encuentra la persona*/


# include<conio.h>

void main( )

{

int edad;

char nombre[40];

clrscr( );

cout<< " Ingrese nombre ==> "; cin>> nombre;

cout<< " Ingrese edad ==> "; cin>> edad;

if ( (edad>0)&&(edad<=100))

switch(edad)

{ case 1 , 2, 3 , 4 , 5 , 6 , 7 , 8 , 9: cout<<nombre<<" es un niño"<<endl;

break;

case 10 , 11 , 12 , 13 , 14 , 15 , 16: cout<<nombre<<" es un adolescente"<<endl;

break;

case 17 , 18 , 19 , 20 , 21: cout<<nombre<<" es un joven"<<endl;

break;

default :cout<<nombre<<" es un adulto"<<endl;

}

else

cout<<"Error ingrese una edad valida";

getch( ); }

EJECUCION



3. Escriba un programa que imprima todos los números de tres cifras que sean capicúas y cuya suma de sus dígitos

sea par.

Solucion:

PROGRAMA

/* CODIGO: POOC3PROB3 FECHA: 18 DE AGOSTO DE 2013OBJETIVO: Muestra todos los numeros de tres digitos capicuas y cuya suma de estos es par */# include<iostream.h>

# include<conio.h>

void main( )

{ int i , num,numinv, sumadigitos, digito;

clrscr( );

cout<< " Lista de numeros capicúas y suma dígitos par"<<endl<<endl;

for (i=100; i<=999;i++)

{ num = i;

sumadigitos=0;

numinv=0;

while(num>=10)

{ digito= num%10;

numinv = numinv*10+digito;

sumadigitos=sumadigitos + digito;

num = num/10; }

numinv = numinv*10+num;

sumadigitos=sumadigitos + num;

if( (i== numinv)&& ( (sumadigitos%2)==0))

cout<< i << endl;

} // FIN DEL FOR

getch( ); }



4. En la UNI se rinde examen de admisión y de un grupo de 20 postulantes para cuatro facultades cuyos codigos

son: Codigo Facultad

‘S’ Ing. De Sistemas

‘M’ Ing. Mecánica

‘Q’ Ing. Química

‘A’ Ing. Ambiental

La Universidad aplica tres tipos de exámenes a sus postulantes. Los postulantes que obtengan por lo menos dos

exámenes aprobados (mayor o igual a 11) son admitidos caso contrario son rechazados. En base a esto se pide

diseñar un algoritmo que permita:

a) Mostrar por cada postulante el mensaje admitido o rechazado.

b) Presentar el número de ingresantes pro facultad.

Solución:

PROGRAMA



OBJETIVO: LISTA INGRESANTES POR FACULTAD DE UN EXAMEN DE ADMISION */


# include<conio.h>

# include<ctype.h>



# include<stdlib.h>

# include<time.h>

void main( )

{ int i, conts=0,contm=0,contq=0,conta =0;

int exa1, exa2, exa3, numfac;

char facultad;

clrscr( );

randomize();

for (i=1; i<=20;i++)

{ numfac = random(4)+1;

switch(numfac)

{ case 1 : facultad = 'S';break;

case 2 : facultad = 'M';break;

case 3 : facultad = 'Q';break;

case 4 : facultad = 'A';break; }

exa1=random(20)+1;

exa2=random(20)+1;

exa3=random(20)+1;

if(((exa1>=11)&&(exa2>=11))|| ((exa1>=11)&&(exa3>=11))||((exa2>=11)&&(exa3>=11)))

{ cout<<"Postulante Admitido"<<endl;

switch(facultad)

{ case 'S' : conts=conts+1;break;

case 'M' : contm=contm+1;break;

case 'Q' : contq=contq+1;break;

case 'A' : conta =conta+1;break;}

}

else

cout<<"Postulante rechazado"<<endl; }

cout<< " Ingresaron a Ing. Sistemas = "<<conts<<endl;;

cout<< " Ingresaron a Ing. Mecánica = "<<contm<<endl;

cout<< " Ingresaron a Ing. Química = "<<contq<<endl;

cout<< " Ingresaron a Ing. Ambiental= "<<conta<<endl;

getch( );}



5. Se desea leer un conjunto de numeros enteros de tres cifras hasta encontrar un número negativo. Luego mostrar

la cantidad de veces que aparece el digito 3 en todos los números positivos leídos.

Solucion:

PROGRAMA



OBJETIVO: Muestra veces que aparece el digito 3 en los números leídos antes de encontrar un negativo.*/


# include<conio.h>

# include<stdlib.h>

# include<time.h>

void main( )

{ int numero,d1,d2,d3,contdigitos=0;

clrscr( );

while ( 1 )

{ cout<<"Ingrese un numero : ";

cin>>numero;

if(numero < 0 ) break;

d1= numero%10;

numero=numero/10;

d2=numero%10;

numero=numero/10;

d3 = numero;

if( d3==3) contdigitos = contdigitos+1;

if( d2==3) contdigitos = contdigitos+1;

if( d1==3) contdigitos = contdigitos+1; }

cout<< "Numero de veces que aparece el digito 3 es = "<<contdigitos<<endl;

getch( ); }

EJECUCION



6. De un experimento de física se tienen que leer “N” temperaturas( entre positivas y negativas) luego averiguar el

numero de apariciones de la menor temperatura negativa.

Solucion:

PROGRAMA


FECHA: 18DE MARZO DE 2013

OBJETIVO: Muestra la mayor de las temperaturas negativas y cuantas veces se presenta.*/


# include<conio.h>

# include<ctype.h>

# include<stdlib.h>

# include<time.h>

void main( )

{ int temperatura, tempmayorneg=-20,conttemp=1;

int i,n;

clrscr( );

cout<<"Ingrese el valor n= ";

cin >>n;

randomize();

for (i=1;i<=n;i++)

{ temperatura= random(41)-20;

cout<< temperatura<<endl;

if( temperatura < 0)

{ if (temperatura == tempmayorneg)

conttemp= conttemp+1;

if(temperatura > tempmayorneg)

{ tempmayorneg =temperatura;

conttemp= 1; } }

}

cout<<endl<<endl;

cout<<"La temperatura es = " << tempmayorneg<<endl;

cout<<" Se presento: "<< conttemp << " Veces";

getch( ); }

EJECUCION




1. Escriba un programa que simule un juego de dados como en el ejemplo de este capítulo pero en cada caso debe

ganar o perder una suma, si inicialmente usted fija un pozo o sea una cantidad, el juego terminara cuando pierda

todo el pozo inicial o lo duplique.

2. Escriba un programa que genere 5 valores al azar entre 1 y 13 (cinco cartas de una baraja de casinos) y me

indique si tenemos un par, 2 pares , un trío , un full (3 iguales y dos iguales) o póker ( cuatro iguales)

3. Escriba un programa que me permita descubrir una clave de cuatro dígitos realizando todas las combinaciones

posibles hasta dar con la clave.

4. Escriba un programa que lea 5 practicas de 10 alumnos halle el promedio de cada uno de ellos y me indique cual

es el mejor promedio.

5. Escriba un programa que me permita hallar el maximo común divisor y el mínimo común múltiplo de dos valores

enteros.

6. Se realizan elecciones entre tres partidos politicos, escriba un programa que me permita indicar el ganador y si

además supera el 50% será el ganador oficial en primera vuelta.



CAPITULO IV

4 FUNCIONES EN LENGUAJE “C++”.- Es un conjunto de instrucciones agrupadas que tienen un nombre común

y que realizan un cálculo (o proceso) especifico. Todo programa en lenguaje “C” se desarrolla basándose en

funciones, estas posteriormente pueden formar una librería particular.

4.1 Funciones Predefinidas (De biblioteca) Aquí tenemos una serie de funciones, debemos considerar que al

invocarlas debemos seguir las siguientes reglas:

Consideremos la Función sqrt



La función sqrt está incluida en la librería math.h

La invocación debe ser con el nombre o sea sqrt y el parámetro indicado o sea un valor , variable o

expresión de tipo double. O sea sqrt(num), siendo habido sido declarado num como doble precision.

El valor devuelto será el indicado en el prototipo o sea double precision por ejemplo un caso sería:

double r, x ;

x= 5.0;

r=sqrt(x);

En este caso tanto la variable que servirá como argumento, como la variable que recibirá el resultado son

del tipo indicado.

A) Funciones de la librería math.h

Función abs

Retorna el valor absoluto de una variable entera, y cuando se incluye la librería stdli.h tambien considera

valores bcd. La función fabs(double x) considera valores reales.

Ejemplo 1.- escriba un programa que lee tres valores y me imprime el mayor valor absoluto.

PROGRAMA

/* CODIGO: POOC4E1

FECHA: 18DE MARZO DE 2013

OBJETIVO: ejemplo DE LA FUNCION ABS() Y FABS()*/


#include <conio.h>

#include <stdlib.h>

#include <math.h>

void main()

{ int valor1;

float valor2;

double valor3,x,y, z,mayor;

clrscr();

cout<<"Ingrese valor 1 ==> "; cin >>valor1;



x = abs(valor1);

y = fabs(valor2);

z = fabs(valor3);

if (x>y)

mayor= x;

else



Syntax

#include <math.h>

double sqrt(double x);

Syntax

#include <math.h>

#include <stdlib.h>

int abs(int x);

mayor=y;

if (z>mayor)

mayor= z;

cout<<"El mayor será: "<<mayor;

getch(); }

EJECUCION

Funciones ceil y floor

Ceil retorna el entero no menor que x, o sea redondea hacia arriba y floor redondea hacia abajo.

Ejemplo 2.- Escriba un programa que calcule un promedio de 5 edades y me indique entre que edades

consecutivas se encuentra.

PROGRAMA

/* CODIGO: POOC4E2


OBJETIVO: Ejemplo de las funciones ceil() y floor().*/


#include <conio.h>

#include <stdlib.h>

#include <math.h>

void main()

{ int edad,i;

float promedio=0,edadprom1,edadprom2;

clrscr();

for (i=1;i<=5;i++)

{cout<<"Ingrese edad "<<i<<" : ";

cin >>edad;

promedio=promedio + edad;

}

promedio=promedio/5.0;

edadprom1=floor(promedio);

edadprom2=ceil(promedio);

cout<<"La edad promedio se encuentra entre "<<edadprom1<< " y "<<edadprom2;

getch(); }



Syntax

#include <math.h>

double ceil(double x);

long double ceill(long double x);

double floor(double x);

long double floorl(long double x);

EJECUCION

Funciones sin() y cos()

Retornan el seno y coseno de un argumento que debe estar en radianes, argumento y retorno son double.

Ejemplo 3.- Escriba un programa que calcule un el seno y coseno de un triangulo rectángulo notable y

compruebe que seno y coseno de los ángulos complementarios de un triangulo rectángulo son iguales.

PROGRAMA

/* CODIGO: POOC4E3


OBJETIVO: Ejemplo de las funciones SIN() y COS().*/


#include <conio.h>

#include <math.h>

void main()

{ double anga,angb,senoa,cosenob;

clrscr();

anga=37*3.1416/180;

senoa=sin(anga);

angb=53*3.1416/180;

cosenob=cos(angb);

cout<<"El seno de a= "<<senoa<<endl;

cout<<"El coseno de b= "<<cosenob; getch(); }

EJECUCION

Función exp()



Syntax

#include <math.h>

double cos(double x);

long double cosl(long double x);

double sin(double x);

long double sinl(long double x);

Syntax

#include <math.h>

double exp(double x);

long double expl(long double x);

Exp() calcula el valor “e” elevado a la x.

Ejemplo 4.- Escribir un programa con exp(x)

PROGRAMA

/* CODIGO: POOC4E4


OBJETIVO: Ejemplo de las funciones exp()*/


#include <conio.h>

#include <stdio.h>

#include <math.h>

void main()

{ double expx;

double x ;

clrscr();

cout<<"Ingrese x ==> "; cin>>x;

expx = exp(x);

printf("'e' elevado a la potencia \de %lf (e ^ %lf) = %lf\n", x, x, expx);

getch(); }

EJECUCION

Función log() y log10()

Retorna el logaritmo natural de x y el logaritmo en base 10 de x

Función pow()

Retorna x elevado a la y.

Ejemplo 5.- Escribir un programa y calcule una raiz cuadrada usando pow() y

usando sqrt(), compárelas.

PROGRAMA

/* CODIGO: POOC4E5


OBJETIVO: Utiliza pow() y sqrt() para calcular raiz cuadrada*/



Syntax

#include <math.h>

double log(double x);

long double logl(long double x);

double log10(double x);

long double log10l(long double x);

Syntax

#include <math.h>

double pow(double x, double y);

long double powl(long double x, long double y);


#include <conio.h>

#include <math.h>

void main()

{ double x,raiz1,raiz2 ;

clrscr();

cout<<"Ingrese x ==> "; cin>>x;

raiz1 = pow(x,0.5);

raiz2=sqrt(x);

cout<<" Utilizando pow el resultado será = "<<raiz1<<endl;

cout<<" Utilizando sqrt el resultado será= "<<raiz2;

getch(); }

EJECUCION

B) Funciones de la librería stdio.h

Función gets()

Captura una cadena que puede contener espacio en blanco del flujo estándar.

Función printf()

Ejemplo 6.- Escribe una salida formateada en el flujo estándar de salida.

PROGRAMA

/* CODIGO: POOC4E6


OBJETIVO: Utilizar la funcio gets() y la función printf().*/


#include <conio.h>

#include <stdio.h>

#include <math.h>

void main()

{ char nombre[30];

float nota;

clrscr();



Syntax#include <stdio.h>char *gets(char *s);

Syntax

#include <stdio.h>

int printf(const char *format[, argument, ...]);

cout<<"Ingrese nombre ==> "; gets(nombre);

cout<<"Ingrese nota ==> "; cin>>nota;

printf("El alumno %s \n",nombre);

printf("Tiene %6.2f de nota",nota);

getch();

}

EJECUCION

Función clock()

Ejemplo 7.- Escribe un programa que nos permita trabajar con la función clock.

PROGRAMA

/* CODIGO: POOC4E7


OBJETIVO: Maneja la función clock*/


#include <conio.h>

#include <time.h>

#include <stdio.h>

#include <dos.h>

main(void)

{ int i,a=0;

clock_t inicio, fin;

inicio = clock();

for(i=1;i<=100000;i++)

{ if(i>1)

a=i;

cout<<a<<" "; }

clrscr();

fin = clock();

printf("El tiempo de inicio fue : %f\n", inicio / CLK_TCK);

printf("El tiempo de fin fue : %f\n", fin / CLK_TCK);

printf("El tiempo transcurrido fue: %f\n", (fin -inicio ) / CLK_TCK);

getch(); }

EJECUCION



Syntax

#include <time.h>

clock_t clock(void);

Función time()

Ejemplo 8.- Escribe un programa que nos permita trabajar con la función time. Explicar.

PROGRAMA

/* CODIGO: POOC4E8 FECHA: 18 DE MARZO DE 2013 OBJETIVO: Maneja la función time*/#include <time.h>

#include <stdio.h>

#include <dos.h>

#include <conio.h>


void main(void)

{ time_t t;

t = time(NULL);

cout<<"El numero de segundos transcurridos desde el Enero 1, 1970 es "<<t;

getch(); }

EJECUCION

La función cuenta los segundos transcurridos desde 1 enero 70 hasta el día actual.

Funciones que generan números aleatorios

Son las funciones randomize(), rand() y random (num).. Veamos su sintaxis de cada una de ellas.

Función rand()

Genera números aleatorios entre 0 y RAND_MAX, constante definida en stdlib.h

Función randomize()



Syntax

#include <time.h>

time_t time(time_t *timer);

Syntax

#include <stdlib.h>

int rand(void);

Syntax

#include <stdlib.h>

#include <time.h>

void randomize(void);

Inicializa el generador de números.

Función random(n)

Retorna valores entre 0 y num – 1.

Ejemplo 9.- Generar números aleatorios entre un cota mínima y una cota máxima.

PROGRAMA

/* CODIGO: POOC4E9


OBJETIVO: Genera valores aleatorios entre dos valores dados */

#include <stdlib.h>


#include <time.h>

#include <conio.h>

Void main(void)

{ int cota_minima,cota_maxima, i ,nro_terminos;

clrscr();

cout<<"Ingrese cota minima: ";cin>>cota_minima;

cout<<"Ingrese cota maxima: ";cin>>cota_maxima;

cout<<"Ingrese Nro. Terminos: ";cin>>nro_terminos;

randomize();

for(i=0; i<=nro_terminos; i++)

cout<<(cota_minima+random(cota_maxima+1-cota_minima))<<endl;

getch();}

EJECUCION



Syntax

#include <stdlib.h>

int random(int num);

C) Funciones de la librería stdlib.h

Función atof()

Convierte de cadena a número de punto flotante.

Función atoi()

Convierte de cadena a número entero.

Función atol()

Convierte de cadena a numero long (entero largo).

Función itoa()

Convierte un entero a cadena.

Función ecvt()

Convierte una cadena a punto flotante..

4.2 Funciones Definidas por el Usuario.- También podemos crear nuestras propias funciones y como

mencionamos al inicio de este capítulo posteriormente podemos formar nuestra librería partícula. La estructura

de una función definida por el usuario es :

Forma General

Tipo nombrefuncion ( lista de parámetros)

{................... ;

.....................;

.....................;

[return(.....);]

.....................;

}

Donde:

Tipo .............. Tipo de valor que devuelve la función en algunos



Syntax

#include <math.h>

double atof(const char *s);

long double _atold(const char *s);

Syntax

#include <stdlib.h>

int atoi(const char *s);

Syntax

#include <stdlib.h>

long atol(const char *s);

Syntax

#include <stdlib.h>

char *itoa(int value, char *string, int radix);

Syntax

#include <stdlib.h>

char *ecvt(double value, int ndig, int *dec, int *sign);

casos no devuelven ningún valor y el tipo será

void (no devuelve).

nombrefuncion ......Identificador de la función

Lista de parámetros...Establecen la comunicación entre la función que

realiza la llamada y nuestra función

return( ) .....Permite retornar un valor a la función que realizo la

llamada, si la función es de tipo void no retorna valor.

Ejemplo10:

int primo( int p1)

{ int i, sw=1; //asumo que es primo

for( i=2; i <= (p1/2) ; i++)

if ( (p1 % i) == 0)

{ sw = 0;// si es divisible no es primo

break;

}

return(sw); }

La llamada será

If ( primo(a))// a necesariamente es entero

Cout<< a << “ Es primo”<< endl;

Ejemplo 11:

void leer ( long *código, char nombre[40], char dirección[50])

{ // programa de lectura

clrscr();

cout << “ingrese código: “; cin>>*codigo;

cout << “ Ingrese nombre: “;gets(nombre); //Función de lectura

cout << “Ingrese dirección: “; gets(direccion); }

La llamada será leer( &code, name, dire);

Si las declaraciones han sido:

long code;

char name[40];

char dire[50];

4.2.1 Ubicacion del prototipo, la llamada y la function en Lenguaje C++


#include <conio.h>


// LA LLAMADA SE REALIZA DE LA FUNCION MAIN

void main( )

{ int valor1, valor2;

……………………;

……………………….;

// PROTOTIPO DE LA FUNCION (ES EL ENCABEZADO)

int suma(int operando1, int operando2);


4.2.2 Comunicación entre funciones.- La comunicación se puede realizar de dos maneras:

Vía variables Globales

Vía argumentos parámetros

a) Vía variables globales.- Se realiza cuando declaran más variables en un área de acceso público o sea que

todas las funciones pueden acceder estas variables. Un esquema de esto seria


#include <conio.h>

// VARIABLES GLOBALES

int a,b,c;


// LA LLAMADA SE REALIZA DE LA FUNCION MAIN

void main( )

{ int valor1, valor2;

……………………;

……………………….;

// PROTOTIPO DE LAS FUNCIONES

void leer(void);

void multiplicar(void);

void escribir(void);

void main( )

{ // La function main no utiliza variables

leer ( );

multiplicar( );

escribir( );

}

// LAS FUNCIONES QUE TRABAJAN CON VARIABLES GLOBALES

void leer( )

{ cout << “ Ingrese a: ”;

cin >> a;

cout << “ Ingrese b: ”;

cin >> b;

}

void multiplicar( )

{

c = a*b ;

}

void escribir( )


La comunicación es a través de las variables a, b y c. El problema es que las funciones son dependientes de las

variables. Y para cada grupo de variables hay que desarrollar funciones, para independizar las funciones de las

variables se utiliza comunicación argumentos – parámetros, que independiza las variables de los procedimientos.

b) Vía argumentos y parámetros. Esto se establece como explicamos a continuación:

Llamada por valor y llamada por referencia.- Cuando una función es llamada se le debe enviar una lista de

argumentos que son los que establecen la comunicación entre los dos módulos. La pregunta es, ¿Que Argumentos

enviar? Los argumentos enviados pueden ser valores o direcciones dependiendo del parámetro: Si el encabezado

es void f1(int p1, int p2, float *p3) Supongamos que los argumentos son a1, a2 y a3; entonces a1 y a2 deben

necesariamente generar valores simples de tipo entero y a3 será obligatoriamente variable simple de tipo float, pero

el primer parámetro y el segundo al ser variables solamente piden valores enteros pero el tercer parámetro al ser

tipo puntero pide una dirección de una variable simple de tipo float. L a llamada será:

f1 ( a1, a2, &a3);

O sea se envía el contenido de a1 y de a2 pero la dirección de a3, entonces

a1 y a2 ha sido llamadas por valor

a3 ha sido llamada por referencia

Funcionamiento de un subprograma tipo función.- Cuando aparecen el nombre de una función seguido de una

lista de argumentos f2(a1, a2, &a3, &a4) los siguientes eventos tienen lugar:

Se realiza una transferencia de valores y direcciones hacia sus respectivos parámetros. Como lo visualizamos en

el siguiente gráfico(Suponiendo que la llamada se realizo desde main):


main() f2()_

a1 p1

a2 p2

a3 p3

a4 p4

35

40

// LAS FUNCIONES QUE TRABAJAN CON VARIABLES GLOBALES

void leer( )

{ cout << “ Ingrese a: ”;

cin >> a;

cout << “ Ingrese b: ”;

cin >> b;

}

void multiplicar( )

{

c = a*b ;

}

void escribir( )


Se ejecuta la función hasta que la primera sentencia return es alcanzada o termina la función.

Cuando termina la ejecución de la función sucede lo siguiente:

El control retorna al punto siguiente desde donde se realizo la llamada

Sigue la ejecución de main (En este caso).

4.3 Funciones Inline.- Este tipo de funciones que se insertan directamente le dan mayor velocidad a la

ejecución, la forma de indicar una function de este tipo es colocando el especificador inline antes de la

definición de la función. Veamos el formato:

inline tipo_devuelto nombre_funcion (parámetros)

{………….;

………….;

Instrucciones;

}

La llamada será normal como a las otras funciones, pero en el cuerpo de la función no podrá haber:

Variables de tipo static

Sentencias de bucle.

Sentencia switch

Go to

Ejemplo 12.- veamos un ejemplo de uso de una función inline

PROGRAMA

/* CODIGO: POOC4E12


OBJETIVO: UTILIZA FUNCIONES INLINE. */


#include <conio.h>

#include <math.h>

inline float fi (float x)

{ float ff;

ff= pow(x,2)-3*x+5;

return (ff); }

void main(void)

{ float xmin,xmax,deltax,fx,x;


main() f2()_

a1 p1

a2 p2

a3 p3

a4 p4


clrscr();

cout<<"Ingrese x mínimo: ";cin>>xmin;

cout<<"Ingrese x máximo: ";cin>>xmax;

cout<<"Ingrese variación de x: ";cin>>deltax;

x=xmin;

while( x<=xmax)

{ fx=fi(x);

cout<< "f(x)= "<<fx<<endl;

x=x+deltax; }

getch();}

EJECUCION

Fíjense que es una función con un cálculo simple pues retorna el valor de la función para un argumento dado.

4.4 Funciones Recursivas.- Una función recursiva es una función que se llama así misma para resolver un

cálculo o proceso.

Las características de la recursividad son :

En cada llamada recursiva el grado de dificultad del cálculo o proceso disminuye.

Cada llamada tendrá su propio espacio de memoria.

Habrá una llamada no recursiva en algún instante a partir del cual se solucionara el problema a

resolver.

Si tenemos el cálculo de factorial:

!N = N*!(N-1)…….. calcular el factorial de (N-1) es más sencillo que calcular el factorial de N.

Además ! 1 = 1 y ! 0 = 1 que son llamadas no recursivas y nos permite calcular el factorial a partir de esto.

Ejemplo 13.- Escriba un programa que halle el factorial de un numero positivo en forma recursiva.

PROGRAMA

/* CODIGO: POOC4E13


OBJETIVO: Halla factorial en forma recursiva */


# include<conio.h>

int facto (int num);



void main( )

{ int n;

clrscr(); cout<< " NUMERO = "; cin>> n;

cout << " FACTORIAL = "<<facto(n);

getch(); }

/* Funcion recursiva */

int facto ( int num)

{ if (num <= 1)

return(1);

else

return(num * facto(num-1)); }

EJECUCION

4.5 Punteros a funciones.- También podemos devolver la dirección de una función, veamos int (*fpun) (int ) será

la declaración de un puntero a función que recibe un int y devuelve un int; en cambio int *fp(int ) será el

prototipo de una función que recibe un int y devuelve puntero a int.

Ejemplo 14.- Escriba un programa usando el concepto de puntero a función.

PROGRAMA

/* CODIGO: POOC4E14


OBJETIVO: Ejemplo de puntero a función. */


# include<conio.h>

int* funcion1 ( int num)

{ cout <<num<<endl;

return(&num); }

int funcion2 (int num)

{ cout<<num<<endl;

return(num*2); }

void main( )

{ int i,j ;

clrscr();

i=4;

j = funcion2(i); // Imp rime 4

funcion2(funcion2(j));// Primera llamada imprime 8 y en la segunda imprime 16

int (*pf1)(int)=&funcion2;

pf1(i); //Imprime 4

int* (*pf2)(int)=&funcion1;

pf2(j); //Imprime 8

getch();



}

EJECUCION

PROBLEMAS

Problema 1.- EJEMPLO DE FUNCIONES QUE SE COMUNICAN MEDIANTE VARIABLES GLOBALES.

1.- Suponga que tiene un numero “num” y una aproximación a su raíz cuadrada. Para obtener una aproximación

más exacta a la raíz cuadrada real se puede utilizar la formula: aproximaciónnueva = (n/ aproximaciónanterior)

+aproximaciónanterior)/2. Utilizando esta información, escriba un programa que solicite al usuario un número y

una suposición inicial de su raíz cuadrada. Con los datos el programa calculara una aproximación de la raíz

cuadrada que sea exacta hasta 0.00001.

Solución:


FECHA: 16 de agosto de 2007

OBJETIVO: Halla raíz cuadrada por aproximación*/


#include<conio.h>

#include<math.h>

#define ERROR 0.00001

float num,raiz,aprox;

void leer();

void procesar();

void mostrar();

main()

{ leer();

procesar();

mostrar(); }

void leer( )

{ clrscr();

cout<<"Ingrese el numero cuya raíz cuadrada desea ";

cin>>num;

cout<<"Ingrese un valor aproximado de la raíz ";

cin>>aprox; }

void procesar( )

{ do{ raiz=aprox;//almacenar la aproximación

aprox=(num/raiz + raiz)/2.0;//calcular nueva aproximación

cout<<"Nueva Aproximación "<<aprox<<endl;

}while(fabs(aprox-raiz)>ERROR);

getch();

}

void mostrar()

{ cout<<endl<<endl;



cout<<"La Raiz cuadrada es "<<aprox<<endl;

getch(); }

EJECUCION

2.- Escriba un programa que utilizando comunicación vía argumentos y parámetros, pueda calcular la nota final,

considerando que el promedio de prácticas se halla eliminando la menor nota de las cuatro prácticas, la nota final

se hallara

Promedio de prácticas = (practica 1+practica 2 + practica 3 + practica 4 – menor)/3.0

Nota Final = (promedio practicas+ examen parcial + 2*examen parcial)/4.0

SOLUCION:

PROGRAMA

/* CODIGO: POOC4PROB2 FECHA: 18DE MARZO DE 2013 OBJETIVO: Halla nota final con el sistema F*/#include<iostream.h>

#include<conio.h>

#include<math.h>

void leer(float &n1,float &n2,float &n3, float &n4);

float menor(float n1,float n2,float n3, float n4 );

main()

{float EXP, EXF, PFIN,EXS; float a,b,c,d,PP,MEN;

leer(a,b,c,d);

cout<<"\n La menor practica es = "<<menor(a,b,c,d);

MEN=menor(a,b,c,d);

PP=((a+b+c+d)-MEN)/3.0;

cout<<"\n Ingrese la nota del parcial :";cin>>EXP;

cout<<"\n Ingrese la nota del FINAL :";cin>>EXF;

cout<<"\n El promedio de prácticas es :"<<PP;

PFIN=(PP+EXP+2*EXF)/4.0;

cout<<"\n El Promedio Final es :"<<PFIN<<endl;//redondea por exceso

if(PFIN>=10)

cout<<"Su promedio final es: "<<PFIN<<endl;

else

if(PP>6.0)

{cout<<"Ingrese el Examen Sustitutorio: ";cin>>EXS;

if(EXP)

PFIN=(PP+EXS+2*EXF)/4.0;

if(EXF)

PFIN=(PP+EXP+2*EXS)/4.0;

cout<<"Su promedio final es: "<<PFIN<<endl; }

getch();}



void leer(float &n1,float &n2,float &n3, float &n4)

{ cout<<"\nIngrese las practicas dejando espacio :";

cin>>n1>>n2>>n3>>n4; }

float menor(float n1,float n2,float n3, float n4 )

{ float men;

men=n1;

if(n2<men)

men=n2;

if(n3<men)

men=n3;

if(n4<men)

men=n4;

return ( men); }

EJECUCION

3.- Este programa halla una raíz positiva de la ecuación cubica x3−x2−x−1=0 , en el intervalo [0,5] con un

error menor que 0.001.

PROGRAMA



OBJETIVO: Halla raiz en intervalo 0-5 con error menor que 0.001 */


# include<math.h>

# include<conio.h>

# define error 0.001

//# define x0 0.0

//# define x1 5.0

float fcub(float x);

float bisecar(float a, float b);

/*Programa principal*/

void main( )

{ float x0,x1;

clrscr();

cout<<"Ingrese intervalo donde se encuentra la raiz"<<endl;

cout<<"Ingrese xmin : ";cin>>x0;

cout<<"Ingrese xmax : ";cin>>x1;



cout<< " RAIZ = "<< bisecar( x0,x1);

getch();

}

/* Funciones*/

float fcub(float x)

{ return( pow(x,3) - pow(x,2) - x -1);}

float bisecar(float a, float b)

{float r ,medio ;

while ( fabs(a-b)>= error)

{cout<<fabs(a-b)<<endl;

medio = (a+b)/2.0;

if ((fcub(a) * fcub(medio))<= 0)

b= medio;

else

a= medio;

}

r = a;

return( r ); }

EJECUCION

4.- Escriba un programa que calcule la planilla para un trabajador, los datos que tienen que considerarse son:

Nombre : Nombre del empleado es una cadena de 40 caracteres.

Código : Código del empleado es una cadena de 11 caracteres.

Sueldo bruto : Sueldo mensual que percibe el empleado.

Faltas : Se le descontara 1/30 del sueldo bruto por cada falta.

Horas extras : Se le pagara (1/(30*8))*1.5 por cada hora extra.

Seguro : Por afp (1) será 13 % de descuento del total a percibir

Por ssp(2) será 11% de descuento del total a percibir.

Por ninguna(0) será 7% de descuento del total a percibir.

Bonificaciones: Tiempo de servicio (0=no,1=si), 5% del bruto.

PROGRAMA





OBJETIVO: CALCULO DE PLANILLA PARA UN TRABAJADOR.*/


# include<stdio.h>

# include<conio.h>

void leer( char nombre[40], char código[11],float *sueldob,int *faltas,int *horase,int *seguro,int *bonif);

float calcular_neto(float sueldob,int faltas,int horase,int seguro,int bonif,float *descuento);

void imprimir_boleta(char n[40],char c[11],float descuento,float sueldon);

void main( )

{ char name[40],code[11];

float sb,de,sn;

int fa,he,seg,bon;

clrscr();

leer(name,code,&sb, &fa,&he,&seg,&bon);

sn = calcular_neto(sb,fa,he,seg,bon,&de);

imprimir_boleta(name,code,de,sn);

getch(); }

/* Funciones*/

void leer( char nombre[40], char codigo[11],float *sueldob,int *faltas,int *horase,int *seguro,int *bonif)

{ clrscr;

cout<<"Ingrese nombre ==> ";gets(nombre);

cout<<"Ingrese codigo ==> ";gets(codigo);

cout<<"Ingrese sueldo bruto ==> ";cin>> (*sueldob);

cout<<"Ingrese faltas ==> ";cin>> (*faltas);

cout<<"Ingrese horas extras ==> ";cin>> (*horase);

cout<<"Ingrese seguro (0=ninguno,1=afp,2=ssp) ==> ";cin>> (*seguro);

cout<<"Ingrese bonificaciones(0=No,1=Si)==> ";cin>> (*bonif); }

float calcular_neto(float sueldob,int faltas,int horase,int seguro,int bonif,float *descuento)

{ float neto,sumabonif,des;

//calculo de bonificaciones

sumabonif=0;

sumabonif=sumabonif+horase*(sueldob/240)*1.5;

if(bonif==1)

sumabonif=sumabonif+sueldob*0.05;

//calculo de descuentos

des=0;

des = des + (sueldob/30)* faltas;

if (seguro==1)

(*descuento)= (sueldob+sumabonif-des)*0.13;

else

if(seguro==2)




else


(*descuento)=(*descuento)+des;

neto = sueldob - (*descuento)+ sumabonif;

return (neto); }

void imprimir_boleta(char n[40],char c[11],float descuento,float sueldon)

{ clrscr();

cout<<" Nombre : "<<n<<endl;

cout<<" Codigo : "<<c<<endl;

cout<<" Descuento: "<<descuento<<endl;

cout<<" Neto a >Recibir : "<<sueldon<<endl; }

EJECUCION

5.- Escriba un programa que halle un número de la serie de fibonacci en forma recursiva.

Para i=0 , F(0)= 0

Para i= 1 , F(1)= 1

Para i>=2 , F(i) = F(i-1) + F(i-2)

PROGRAMA



OBJETIVO: Halla fibonacci en forma recursiva */


#include<conio.h>

#include<math.h>

void leer(int *n);

int fib(int n);

/* Función principal*/

main()

{ int m;

leer(&m);

cout<<"\n El numero es = "<<fib(m);

getch(); }

/* Funciones */

void leer(int *n)

{ clrscr();

cout<<"Ingrese n=> "; cin>>(*n); }

int fib( int n)



{ if(n<=1)

return(1);

else

return(fib(n-1)+fib(n-2)); }

EJECUCION

6.- Escriba un programa que halle los factores primos de un número en forma recursiva.

PROGRAMA



OBJETIVO: Halla factores primos en forma recursiva */


# include<math.h>

# include<conio.h>

void fprimo(int num);

void main( )

{ int n;

clrscr();

do{

cout<< " NUMERO = ";

cin>> n;

}while(n<1);

fprimo(n);

getch();

}

void fprimo( int num)

{

int nr, k =1;

if (num > 1)

{do {

k = k +1;

} while( (num % k) != 0);

cout<< " "<< k <<" ";

nr = num / k;

fprimo( nr);

}

}

EJECUCION




1. Escriba un programa que utilizando funciones pueda realizar operaciones con números complejos: Suma, Resta,

Multiplicación y División. Cada operación debe realizarse con funciones además de la lectura y escritura. Debe

trabajar con un menú.

2. Escriba un programa que calcule áreas, debe calcular áreas para cuadrados, rectángulos, triángulos y círculos;

cada calculo debe realizarse con una función.

3. Escriba un programa que resuelva el mismo problema de planilla (problema 4)pero considere que hay tres tipos

de bonificaciones.

Tiempo de servicio (5%)

Carga familiar (5%)

Remuneración por dirección (10%)

4. Escriba un programa que utilizando el concepto de puntero a funciones evalúe una función para un argumento

variando en un rango de valores determinado.

5. Escriba un programa que me permita hallar la nota final de un alumno que rindió 4 practicas y 2 exámenes

considere, que el sistema de evaluación puede ser:

Sistema A : promedio de prácticas es el promedio de las cuatro practicas y el promedio final es la suma de los

dos exámenes mas el promedio de prácticas divididos entre tres.

Sistema B : promedio de prácticas es el promedio de tres practicas eliminando la menor y el promedio final es

la suma del primer examen más el segundo examen duplicado el promedio de prácticas divididos entre

cuatro.

6. Escriba un programa que resuelva el problema de las torres de Hanói para n discos utilizando una función

recursiva. En las torres de Hanói se trata de pasar “n discos” de un eje “Origen” a un eje “Destino” utilizando un

eje auxiliar. Las reglas son :

Solo se puede mover un disco a la vez.

Nunca un disco de mayor diámetro puede estar sobre un disco de menor diámetro.



CAPITULO V



ARREGLOS EN LENGUAJE “C”

5.1 Definición.- Un arreglo es una colección de elementos del mismo tipo; por lo tanto es una estructura

homogénea. Su declaración se realiza indicando al compilador sus características que son tipo, nombre y

tamaño. Ejemplo:

int datos[10]; la información que se entrega al compilador será:

Nombre del arreglo: datos

Tipo de componente: variable simple entera

Tamaño 10 elementos

Nombre de las componentes:

datos[0]

datos[1]

datos[2]

datos[3]

datos[4]

datos[5]

datos[6]

datos[7]

datos[8]

datos[9]

5.2 Acceso a elementos.- Los elementos de un arreglo se designan con un subíndice que comienza en cero: int

a[4] : a[0], a[1], a[2], a[3].

Un arreglo se puede inicializar así : int a[4] = { 20, 25, 35, 40}

a[0]

a[1]


25

35


20

a[2]

a[3]

5.3 Operaciones con Arrays unidimensionales (vectores).- Las operaciones iníciales son las de lectura y

escritura, las cuales vamos a ver en el siguiente programa ejemplo:

Ejemplo 1.- Lee e imprime un vector de “n” elementos.

PROGRAMA

/* CODIGO: POOC5E1 FECHA: 18 DE MARZO DE 2013 OBJETIVO: Entrada y salida de un vector */# include<iostream.h>

# include<conio.h>

void main( )

{ int vector[50],n,i;

clrscr();

//Lectura

cout << " Ingrese n => "; cin >> n;

for (i=1;i<=n;i++)

{ cout<< " Ingrese valor "<< i<<" : ";

cin>> vector[i]; }

clrscr();

//Escritura

cout<<" SALIDA "<<endl<<endl;

for ( i=1; i<=n;i++)

{ cout<< vector[i]<< endl; }

getch(); }

EJECUCION

Operaciones con arreglos: Las demás operaciones las analizaremos algorítmicamente y después los

presentaremos en un menú en los problemas desarrollados.

Las operaciones más importantes con arreglos unidimensionales son :

Adición

Eliminación

Búsqueda

Ordenamiento


40


ADICION: La operación de adición nos permite ingresar un elemento al vector de “n” componentes que están siendo

utilizadas.

Inicialmente tenemos: Vector A

N = 6

A [1] A [2] A [3] A [4] A [5] A[6] A[7]

3 5 12 20 15 25

J= 4

X

Vamos a insertar el valor x = 14 en la posición j=4

Tener en cuenta que al insertar un nuevo valor el vector crecerá en un elemento.

Al finalizar los valores deberían estar en las siguientes posiciones:

A[1] = 3, A[2] = 5, A[3] = 12, A[4] = 14, A[5] = 20, A[6] = 15, A[7] = 25.

Para realizar esta operación necesitamos tres pasos:

a) Realizar un corrimiento de una posición hacia la derecha de todos los valores desde la posición “N” (N=6) hasta

la posición “J” (J=4), el resultado sería:

N = 6

A [1] A [2] A [3] A [4] A [5] A[6] A[7]

3 5 12 20 20 15 25

El algoritmo es:

Para i = N,J,-1

A[i+1] A[i]

Fin Para

b) Adicionar el elemento X en la posición J

A[J] X

El resultado seria

N = 6

A [1] A [2] A [3] A [4] A [5] A[6] A[7]

3 5 12 14 20 15 25

c) Actualizar “N”

N = N +1

N = 7

A [1] A [2] A [3] A [4] A [5] A[6] A[7]

3 5 12 14 20 15 25

Las instrucciones en Borland “C” serán:


14

cout<<"Ingrese posición de inserción: ";

cin>> j;

cout<<"Ingrese valor a insertar : ";

cin>> x;

for( i=n; i>=j; i--)

v[i+1] = v[i];

v[j] = x;


ELIMINACION: La operación de eliminación nos permite sacar un elemento del vector de “n” componentes que están

siendo utilizadas.

Inicialmente tenemos: Vector A

N = 6

A [1] A [2] A [3] A [4] A [5] A[6]

3 5 12 20 15 25

J= 3

Vamos a eliminar el tercer elemento del vector.

Finalmente deberíamos tener A[1] = 3, A[2] = 5, A[3] = 20, A[4] = 15, A[5] = 25.

Y “N” decrecería y seria 5.

Para realizar esta operación necesitamos dos pasos:

a) Realizar un corrimiento de una posición hacia la izquierda todos los valores desde la

posición “J+1” (J=3) hasta la posición “N” (N=6).:

N = 6

A [1] A [2] A [3] A [4] A [5] A[6]

3 5 20 15 25 25

El algoritmo es:

Para i = J+1,N

A[i-1] A[i]

Fin Para

b) Actualizar “N”.

N N-1

El resultado seria

N = 5

A [1] A [2] A [3] A [4] A [5]

3 5 20 15 25



cout<<"Ingrese posición de inserción: ";

cin>> j;

cout<<"Ingrese valor a insertar : ";

cin>> x;

for( i=n; i>=j; i--)

v[i+1] = v[i];

v[j] = x;

cout<<"Ingrese posición de valor a eliminar : ";

cin>> j;

for( i=j+1 ; i<=n;i++)

v[i-1] = v[i];

n = n - 1;


BUSQUEDA: La operación de búsqueda es una de las más importantes. En todo proceso real siempre se buscara un

elemento dentro de un conjunto, o sea buscaremos información dentro de la data, labor fundamental en informática.

La operación buscara un elemento X en un vector A de N elementos.

N = 6

A [1] A [2] A [3] A [4] A [5] A[6]

3 5 12 20 15 25

¿X=A[1]? ¿X=A[2]? …… ¿X=A[i]?

X

Tenemos que tener en cuenta que la búsqueda terminara cuando encontremos el elemento buscado o cuando

llegamos al final de la estructura.

Algorítmicamente seria:

1.- Leer (x)

2.- Para i = 1,n

2.1 Si (A[i] ==x)

Entonces

2.1.1 pos i

2.1. 2 break;

Fin si

3.- Si ( x == A[i])

Entonces

3.1Escribir( “Valor hallado en posición “, pos)

Sino

3.2 Escribir( “Valor no hallado”)

Fin si



19

cout<<"Ingrese valor a buscar : ";

cin>> x;

for( i=1;i<=n;i++)

if ( v[i]== x)

{ pos = i;

break ; }

if ( v [i ]== x)

cout<< " Valor hallado en posición: "<<pos;

else

cout<< " Valor no hallado ";


ORDENAMIENTO: La operación de ordenamiento se realiza por etapas, en nuestro algoritmo por comparación

trataremos de poner el menor valor en la posición superior, pero en cada etapa ya no participa el menor ya

encontrado en la etapa anterior.

El método busca colocar el primer menor en la posición 1 en la etapa 1.

Colocar el segundo menor en la posición 2 en la etapa 2.

colocar el tercer menor en la posición 3 en la etapa 3.

En general se trata de colocar el i’esimo menor en la posición “i” en la etapa “i”.

Veamos

ETAPA 1

OBJETIVO. Llevar el menor 1(menor total) a la primera posición.

¿A[1] > A [2]? Si la respuesta es sí, se intercambian posiciones entre A[1] y A[2], como en este caso

A [1] A [2] A [3] A [4] A [5] A[6] A[7]

9 3 2 7 6 4 5

Después del intercambio tenemos

A [1] A [2] A [3] A [4] A [5] A[6] A[7]

3 9 2 7 6 4 5

¿A[1] > A [3]?. Si entonces.

A [1] A [2] A [3] A [4] A [5] A[6] A[7]

2 9 3 7 6 4 5

¿A[1] > A [4]?. No

¿A[1] > A [5]?. No

¿A[1] > A [6]?. No

¿A[1] > A [7]?. No

ETAPA 2

OBJETIVO. Llevar el menor 2(segundo menor ) a la segunda posición

Verificar que en la segunda etapa ya no participa el primer menor , pues ya encontró su posición final.

A [2] A [3] A [4] A [5] A[6] A[7]

9 3 7 6 4 5

¿A[2] > A [3]?. Si

A [2] A [3] A [4] A [5] A[6] A[7]

3 9 7 6 4 5

¿A[2] > A [4]?. No

¿A[2] > A [5]?. No

¿A[2] > A [6]?. No

¿A[2] > A [7]?. No

ETAPA 3

OBJETIVO. Llevar el menor 3 (tercer menor ) a la tercera posición

Verificar que en la tercera etapa ya no participa el primer menor y el segundo menor, ya alcanzaron su posición final.

A [3] A [4] A [5] A[6] A[7]

9 7 6 4 5



¿A[3] > A [4]?. Si. Intercambiar entre A[3] y A[4]

A [3] A [4] A [5] A[6] A[7]

7 9 6 4 5


A [3] A [4] A [5] A[6] A[7]

6 9 7 4 5


A [3] A [4] A [5] A[6] A[7]

4 9 7 6 5

¿A[3] > A [7]?. No.

ETAPA 4

OBJETIVO. Llevar el menor 4 (Cuarto menor ) a la cuarta posición

A [4] A [5] A[6] A[7]

9 7 6 5

¿A[4] > A [5]?. Si

A [4] A [5] A[6] A[7]

7 9 6 5

¿A[4] > A [6]?. Si

A [4] A [5] A[6] A[7]

6 9 7 5

¿A[4] > A [6]?. Si

A [4] A [5] A[6] A[7]

5 9 7 6

ETAPA 5

OBJETIVO. Llevar el menor 5 (Quinto menor ) a la quinta posición

A [5] A[6] A[7]

9 7 6

¿A[5] > A [6]?. Si

A [5] A[6] A[7]

7 9 6

¿A[5] > A [7]?. Si



A [5] A[6] A[7]

6 9 7

ETAPA 6 Se ordenan n (7) valores en n-1 etapas (6)

OBJETIVO. Llevar el menor 6 (Sexto menor ) a la sexta posición

A[6] A[7]

9 7

¿A[5] > A [6]?. Si

A[6] A[7]

7 9

Volvemos a verificar el vector y tendremos

A [1] A [2] A [3] A [4] A [5] A[6] A[7]

2 3 4 5 6 7 9

Planteando la i’esima etapa dentro de las n-1 etapas, en forma algorítmica tenemos.

1.- Para i= 1, n-1 // Numero de etapas

1.1.- Para j= i+1, n

1.1.1 Si ( A[i] > A[j])

Entonces

Temp A[i]

A[i] A(j)

A[j] temp

Fin si

Fin para

Fin Para

Programando en Borland C++:

PROGRAMAS BASICOS CON ARREGLOS UNIDIMENSIONALES

Ejemplo 2.- Realizar una adición al final del vector

PROGRAMA


int i,j,temp;

for ( i=1; i<n ;i++)

for (j=i+1;j<=n;j++)

if( v[i]> v[j])

{ temp = v[i];

v[i] = v[j];

v[j] = temp ;

}


/* CODIGO: POOC5E2


OBJETIVO: ADICIONAR UN ELEMENTO AL FINALIZAR EL VECTOR */


# include<conio.h>

void main( )

{ int vector[50],n,i,x;

clrscr();

//Lectura


for (i=1;i<=n;i++)


cin>> vector[i];

}

clrscr();

//Escritura


for ( i=1; i<=n;i++)


getch();

clrscr();

cout<<" Ingrese el valor para adicionar ";cin>>x;

vector[n+1]=x;

n=n+1;

cout<<" NUEVA SALIDA "<<endl<<endl;

for ( i=1; i<=n;i++)


getch(); }

EJECUCION

Ejemplo 3.- Realizar una búsqueda binaria sobre un vector ordenado.

PROGRAMA

/* CODIGO: POOC5E3


OBJETIVO: Realizar una búsqueda binaria sobre un vector ordenado */


# include<conio.h>

void main( )

{ int vector[50],n,i,x;



int inicio,final,medio,encontrado=0;

clrscr();

//Lectura

cout << " Ingrese n (Para vector ordenado) => "; cin >> n;

for (i=1;i<=n;i++)


cin>> vector[i]; }

clrscr();

//Escritura

cout<<" SALIDA VECTOR ORDENADO "<<endl<<endl;

for ( i=1; i<=n;i++)


getch();

clrscr();

inicio = 1;

final = n;

cout<<"Ingrese numero a buscar ==> ";cin>>x;

while((inicio<=final)&&(!encontrado))

{ medio = (inicio+final)/2;

if(x==vector[medio])

encontrado = 1;

else

if(x>vector[medio])

inicio =medio;

else

final = medio; }

cout<<endl;

cout<<"MENSAJE "<<endl;

if (encontrado)

cout<<"El numero esta en posición: "<<medio<<endl;

else

cout<<"Valor no hallado ... ";

getch(); }

EJECUCION

Ejemplo 4.- Realizar un ordenamiento usando la definición de vector ordenado. x1<=x2<=x3<=x4…….<=xn.

PROGRAMA

/* CODIGO: POOC5E4


OBJETIVO: Ordenamiento x1<=x2<=x3.... */




# include<conio.h>

void main( )

{ int vector[50],n,i;

int cambio,temp;

clrscr();

//Lectura


for (i=1;i<=n;i++)


cin>> vector[i]; }

clrscr();

//Escritura


for ( i=1; i<=n;i++)


getch();

clrscr();

cambio=1;

while (cambio)

{ cambio=0;

for(i=1;i<=n;i++)

if (vector[i]>vector[i+1])

{ temp=vector[i];

vector[i]=vector[i+1];

vector[i+1]= temp;

cambio=1; } }

cout<<" SALIDA ORDENADA"<<endl<<endl;

for ( i=1; i<=n;i++)


getch(); }

EJECUCION

5.4 Arreglos de 2 dimensiones(Matrices) Una matriz es un arreglo de 2 dimensiones donde el primer subíndice

indica fila y el segundo subíndice indica columna. Consideremos la siguiente declaración: const float maxf = 10;

const float maxc = 20;

float matriz [maxf] [maxc]

Estamos declarando una matriz de 10 filas por 20 columnas. La primera fila será: matriz[0] [[0], matriz[0][1],

matriz[0][2],......................, matriz[0][19]

5.5 Operaciones con matrices:

Ejemplo 5.- El procedimiento para leer una matriz será:



PROGRAMA

/* CODIGO: POOC5E5


OBJETIVO: Lectura y Escritura de una matriz */


# include<conio.h>

#include <stdlib.h>

#include <time.h>

void leer(int x[20][20],int *nf, int *nc);

void mostrar(int x[20][20], int nf, int nc);

void main( )

{ int mat[20][20],nf,nc;

leer(mat,&nf,&nc);

mostrar(mat,nf,nc); }

void leer(int x[20][20],int *nf, int *nc)

{ int i, j ;

clrscr( );

cout<<"Ingrese # filas de la matriz: "; cin>> *nf;

cout<<"Ingrese # columnas de la matriz: "; cin>> *nc;

randomize();

for(i = 1; i<=(*nf); i++)

for(j =1;j<=(*nc); j++)

x[i][j]=random(10); }

void mostrar(int x[20][20], int nf, int nc)

{ int i, j ;

for(i=1; i<=nf; i++)

{for(j=1; j<=nc; j++)

cout<<x [i] [j] << " ";

cout<<endl; }

getch( ); }

EJECUCION

Ejemplo 6.-Procedimiento para multiplicar una matriz

PROGRAMA

/* CODIGO: POOC5E6 FECHA: 18 DE MARZO DE 2013 OBJETIVO: MULTIPLICACION DE MATRICES */ #include<iostream.h>

#include<conio.h>



#include<stdlib.h>

#include<time.h>

void leer(int x[20][20],int *n);

void m_mat(int x[20][20],int n1,int b[20][20],int n2,int c[20][20], int *n3);

void mostrar(int x[20][20],int n);

void main()

{ int n1,n2,n3;

int a[20][20],b[20][20],c[20][20];

leer(a,&n1);

leer(b,&n2);

m_mat(a,n1,b,n2,c,&n3); }

void leer(int x[20][20],int *n)

{ int i,j;

cout<<"Ingrese el orden de la matriz: ";cin>>*n;

randomize();

for(i=1;i<=(*n);i++)

for(j=1;j<=(*n);j++)

x[i][j]=random(10);

mostrar(x,*n); }

void m_mat(int x[20][20],int n1,int b[20][20],int n2,int c[20][20], int *n3)

{ int i,j,k;

cout<<"\nEl producto de las matrices es:"<<endl;

if(n1==n2)

{ for(i=1;i<=n1;i++)

for(j=1;j<=n2;j++)

{ c[i][j]=0;

for(k=1;k<=n1;k++)

c[i][j]=c[i][j]+x[i][k]*b[k][j]; }

*n3=n1;

*n3=n2;

mostrar(c,*n3); }

else

cout<<"Matrices no se pueden multiplicar";getch(); }

void mostrar(int x[20][20],int n)

{ int i,j;

for(i=1;i<=n;i++)

{for(j=1;j<=n;j++)

cout<<x[i][j]<<" ";

cout<<endl; }

getch( ); }

EJECUCION



PROBLEMAS

1.- Dado un vector de números enteros escriba un programa que me permita hallar el número que más veces se

repite (MODA).

PROGRAMA

// Función que realiza la lectura

void lectura(int a[50], int *n)

{ int i;

clrscr();

cout << " Ingrese n => "; cin >> *n;

for ( i=1; i<=(*n);i++)

{ cout<< " Ingrese valor "<< i<<" : "; cin>>a[i]; } }

// Funcion que ordena el vector

void orden(int a[50], int n)

{ int i,j,temp;

for ( i=1; i<n ;i++)


if( a[i]> a[j])




OBJETIVO: Halla la moda de un conjunto de números enteros */


# include <conio.h>

void lectura (int a[50], int *n);

void orden(int a[50], int n);

int moda (int a[50], int n);

void escritura(int mo);

void main( )

{ int a[50];

int n,mo;

clrscr();

lectura (a, &n);

orden(a, n);

mo=moda (a, n);

escritura(mo); }


{ temp = a[i];

a[i] = a[j];

a[j] = temp ; } }

// Funcion que halla la moda

int moda(int a[50], int n)

{ int b[50],rep[50],nsr,i,j,k;

int nmoda,mayor;

clrscr();

nsr=1;

b[1]=a[1];

rep[1]=1;

for( i=2;i<=n;i++)

if(a[i-1]==a[i])

rep[nsr]=rep[nsr]+1;

else

{ nsr=nsr+1;

b[nsr]=a[i];

rep[nsr]=1; }

mayor=rep[1];

k=1;

for(j=2;j<=nsr;j++)

if (rep[j] > mayor)

{ mayor = rep[j];

k=j ; }

nmoda= b[k];

return(nmoda); }

// Función que presenta el resultado

void escritura(int mo)

{ clrscr();

cout<< " La moda es ="<< mo;

getch(); }

EJECUCION

2.- Escriba Un Programa Que Maneje Un Menu De Operaciones Con Arreglos

El programa debe tener el siguiente menú:



MENU ARREGLOS

1.- Lectura2.- Adición3.- Eliminación4.- Búsqueda5.- Ordenar

PROGRAMA



OBJETIVO: Programa que crea un menú para manejo de operaciones

con arreglos */


# include<conio.h>

void lectura(int v[50], int *n);

void adicion(int v[50], int *n);

void eliminacion(int v[50], int *n);

void busqueda(int v[50], int n);

void sorteo(int v[50], int n);

void escritura(int v[50], int n);

void main( )

{ int vector[50];

int n;

char opcion;

clrscr();

do {

clrscr();

gotoxy(30,2);

cout<< "MENU ARREGLOS";

gotoxy(30,5);

cout<< "1.- Lectura";

gotoxy(30,6);

cout<< "2.- Adicion";

gotoxy(30,7);

cout<< "3.- Eliminacion";

gotoxy(30,8);

cout<< "4.- Busqueda";

gotoxy(30,9);

cout<< "5.- Ordenar";

gotoxy(30,10);

cout<<"6.- Escritura";

gotoxy(30,11);

cout<< "7.- Salir";

gotoxy(25,16);

cout<< "Ingrese opcion ==> ";



MENU ARREGLOS

1.- Lectura2.- Adición3.- Eliminación4.- Búsqueda5.- Ordenar

cin>>opcion;

switch(opcion)

{ case '1' : lectura(vector, &n);break;

case '2' : adicion(vector, &n);break;

case '3' : eliminacion(vector, &n);break;

case '4' : busqueda(vector, n);break;

case '5' : sorteo(vector, n);break;

case '6' : escritura(vector, n);break;

}

}while(opcion != '7');

}

void lectura(int v[50], int *n)

{ int i; clrscr();

cout << " Ingrese n => ";

cin >> *n;

for ( i=1; i<=(*n);i++)

{ cout<< " Ingrese valor "<< i<<" : "; cin>> v[i]; }

}

void adicion(int v[50], int *n)

{ int i,j,x;

clrscr();

cout<<"Ingrese posición de inserción: "; cin>> j;

cout<<"Ingrese valor a insertar : "; cin>> x;

for( i=(*n);i>=j;i--)

v[i+1] = v[i];

v[j] = x;

(*n)=(*n) +1; }

void eliminacion(int v[50], int *n)

{ int i,j;

clrscr();

cout<<"Ingrese posición de valor a eliminar : ";

cin>> j;

for( i=j+1 ; i<=(*n);i++)

v[i-1] = v[i];

(*n)=(*n) - 1; }

void busqueda(int v[50], int n)

{ int i,x, pos;

clrscr();

cout<<"Ingrese valor a buscar : ";

cin>> x;

for( i=1;i<=n;i++)

if ( v[i]== x)

{ pos = i; break ; }

if ( v [i ]== x)

cout<< " Valor hallado en posición: "<<pos;

else



cout<< " Valor no hallado ";

getch(); }

void sorteo(int v[50], int n)

{ int i,j,temp;

for ( i=1; i<n ;i++)


if( v[i]> v[j])

{ temp = v[i];

v[i] = v[j];

v[j] = temp ; } }

void escritura(int v[50], int n)

{int i;

clrscr();

for ( i=1; i<=n;i++)

{ cout<< v[i]<< endl; }

getch(); }

EJECUCION

3.- Escriba un programa que lea un conjunto de ”n” nombres y “n” notas y me muestre en una pantalla los nombres

de los tres primeros alumnos por orden de mérito las tres mejores notas

SOLUCIÓN

PROGRAMA



OBJETIVO: halla las tres mejores notas de un grupo de alumnos y las muestra junto con los nombres*/


# include<conio.h>

# include<stdio.h>

# include<string.h>

void lectura(int vectornot[50], char vectornom[50][40], int *n);

void orden(int vectornot[50],char vectornom[50][40], int n);

void escritura(int vectornot[50],char vectornom[50][40], int n);



void main( )

{ int vectornot[50];

char vectornom[50][40];

int n;

clrscr();

lectura(vectornot,vectornom,&n);

orden(vectornot,vectornom, n);

escritura(vectornot, vectornom,n); }

void lectura(int vectornot[50],char vectornom[50][40], int *n)

{ int i;

clrscr();

cout << " Ingrese n => "; cin >> *n;

for ( i=1; i<=(*n);i++)

{ cout<< " Ingrese nota "<< i<<" : "; cin>> vectornot[i];

cout<< " Ingrese nombre "<< i<<" : "; gets(vectornom[i]); } }

void orden(int vectornot[50],char vectornom[50][40], int n)

{ int i,j,temp1;

char temp2[40];

for ( i=1; i<n ;i++)


if( vectornot[i]< vectornot[j])

{ temp1 = vectornot[i];

vectornot[i] = vectornot[j];

vectornot[j] = temp1 ;

strcpy(temp2,vectornom[i]);

strcpy(vectornom[i],vectornom[j]);

strcpy(vectornom[j],temp2) ; } }

void escritura(int vectornot[50],char vectornom[50][40],int n)

{int i;

clrscr();



gotoxy(35,2); cout<<"LISTA DE MERITO";

for ( i=1; i<=3;i++)

{ gotoxy(37,3+i);

cout<< vectornot[i]<<" "<<vectornom[i]; } getch(); }

EJECUCION

Nota: Este programa trabaja con el concepto de vectores paralelos o sea que la información de los vectores está

relacionada por el subíndice esto significa que la nota 5 pertenece al alumno que tiene el nombre 5, por lo tanto la

información se debe manejar en paralelo para que siga siendo consistente.

4.- Escriba un programa que halla el determinante de una matriz.

SOLUCIÓN:

PROGRAMA



OBJETIVO: Calcula determinante*/


#include<conio.h>

#include<math.h>

#include <stdlib.h>

#include <time.h>

void main()

{float m[50][50],m1[50][50];

int n;

int i,j,k,l;

clrscr();

cout<<"Ingrese el orden de la matriz:";cin>>n;

randomize();

for(i=1;i<=n;i++)

for(j=1;j<=n;j++)

m[i][j]=random(5)+5;

for(i=1;i<=n;i++)

{for(j=1;j<=n;j++)

cout<<m[i][j]<<" ";

cout<<endl;



}

getch();

for (i=1;i<=n;i++)

for (j=1;j<=n;j++)

m1[i][j]=m[i][j];

float det;

det=m[1][1];

for(k=1;k<=(n-1);k++)

{ l=k+1;

for(i=l;i<=n;i++)

for(j=l;j<=n;j++)

m[i][j]=(m[k][k]*m[i][j]-m[k][j]*m[i][k])/m[k][k];

det=det*m[k+1][k+1];

}

cout<<endl;

cout<<"Determinante = "<<det<<endl;

getch();

}

EJECUCION

5.- Escribir un programa que realice operaciones sobre la matriz, pero utilizando funciones dentro de una estructura.

PROGRAMA

/* CODIGO: POOC5PROB5 FECHA: 18 DE MARZO DE 2013 OBJETIVO: Utilizar funciones dentro de estructura, muestra valor central e Intercambia diagonal principal por columna central es una matriz de orden 5 */#include<iostream.h>

#include<conio.h>

#include<stdlib.h>

#include<time.h>

struct opmatriz

{ int a[6][6];

void generar( ) //no le entrego xq a[6][6](parámetro) está dentro

{ int i,j,k,primo,x;

randomize();

for(i=1;i<=5;i++)

for(j=1;j<=5;j++)



{ do { primo=1;

x=7+random(71);

for(k=2;k<x;k++)

if( (x%k)==0 )

{primo=0;

break; }

}while(primo==0);

a[i][j]=x; } }

void mostrarcentral ( )

{ cout<<endl;

cout<<a[3][3]<<endl;

getch(); }

void intercambiar ( )

{ int temp,i;

for(i=1;i<=5;i++)

{ temp=a[i][i];

a[i][i]=a[i][3];

a[i][3]=temp; } }

void escribir ( )

{ int i,j;

for(i=1;i<=5;i++)

{cout<<endl;

for(j=1;j<=5;j++)

cout<<" "<<a[i][j]; }

getch(); } };

void main( )

{ opmatriz x;

x.generar ( );

x.escribir ( );

x.mostrarcentral ( );

x.intercambiar ( );

x.escribir ( );}

EJECUCION

6.- Escribir un programa que lea un vector numérico y lo rote hacia la derecha, de tal manera que el primer termino

pase al segundo lugar, el segundo al tercero y así consecutivamente y finalmente el último pase a ser primero.

PROGRAMA





Objetivo: rota a la derecha los "n" elementos de un arreglo

Entrada: vector v[]

Salida: vector v[] rotado */


#include<conio.h>

void main()

{ int v[10];

int i,n;

clrscr();//limpia pantalla

cout<<endl<<endl;

cout<<"INGRESE N = "; cin>>n;

for (i=1;i<=n;i++)

{ cout<<" V["<<i<< "]: ";cin>>v[i];}

// Rotación

for (i=n;i>=1;i--)

v[i+1]=v[i];

v[1]=v[n+1];

cout << "VECTOR ROTADO = "<<endl;

for(i=1;i<=n;i++)

cout<<" V["<<i<< "]: "<<v[i]<<endl;

getch();

}

EJECUCION


1) Escribir un programa que inserte un elemento dentro de un vector ordenado, considere el programa utilizando

para su solución la estructura while.



2) Escribir un programa que realice una búsqueda dentro de un vector ordenado, este programa debe detenerse

cuando el valor es hallado, cuando se llegue al final o cuando el valor buscado es superado.

3) Escribir el código necesario para rotar un vector en sentido antihorario o sea al revés de lo hecho en el problema

9.

4) Se tiene una matriz de letras, escriba usted un programa para que realice la búsqueda de una cadena ingresada

dentro de la matriz(PUPILETRAS), la búsqueda debe ser de izquierda a derecha y de arriba hacia abajo en la

matriz, los mensajes de salida será “Hallado” y “No hallado”.

5) Escriba un programa que lea una matriz de “n” filas por “m” columnas y me imprima la transpuesta de dicha

matriz.

6) Escriba un programa que me permita hallar la inversa de una matriz.



CAPITULO VI

6 CADENAS EN LENGUAJE “C”,- Ahora veremos un caso especial de arrays, que es un tipo estandarizado. Se

trata de las cadenas de caracteres o "strings" (en inglés).



Una cadena en C es un conjunto de caracteres, o valores de tipo "char", terminados con el carácter nulo, es decir el

valor numérico 0. Internamente se almacenan en posiciones consecutivas de memoria. Este tipo de estructuras

recibe un tratamiento especial, y es de gran utilidad y de uso continuo.

La manera de definir una cadena es la siguiente:

char <identificador> [<longitud máxima>]

Nota: En este caso los corchetes no indican un valor opcional, sino que son realmente corchetes, por eso están en

negrita.

Cuando se declara una cadena hay que tener en cuenta que tendremos que reservar una posición para almacenar

el carácter nulo, de modo que si queremos almacenar la cadena "ahora", tendremos que declarar la cadena como:

char cad1[6];

Cinco caracteres para "ahora" y uno extra para el carácter '\0'.

También será posible hacer referencia a cada uno de los caracteres individuales que componen la cadena,

simplemente indicando la posición. Por ejemplo el tercer carácter de nuestra cadena de ejemplo será la ‘o’,

podemos hacer referencia a él como cad1[2]. Los índices tomarán valores empezando en el cero, así el primer

carácter de nuestra cadena sería cad1[0], que es la ‘a'.

Una cadena puede almacenar informaciones como nombres de personas, mensajes de error, números de teléfono, .

La asignación directa sólo está permitida cuando se hace junto con la declaración. Por ejemplo:

char cad1;

cad1 = “ahora”, producirá un error.

Producirá un error en el compilador, ya que una cadena definida de este modo se considera una constante, como

veremos en el capítulo de "arrays" o arreglos.

Lo que sí se puede hacer es: char cad1[6] = "ahora".

Existen muchas funciones para el tratamiento de cadenas, como veremos, que permiten compararlas, copiarlas,

calcular su longitud, imprimirlas, visualizarlas, guardarlas en disco, etc. Además, frecuentemente nos encontraremos

a nosotros mismos creando nuevas funciones que básicamente hacen un tratamiento de cadenas.

6.1 Lectura de una cadena del teclado

Veamos el siguiente código:

Esta lectura del teclado, leerá una cadena hasta que se encuentra el primer carácter blanco. Así, cuando se lee “Hola

que tal” la primera cadena, en cad sólo se almacena Hola. Para resolver el problema, utilizará la función gets () que

lee una cadena completa.

La sintaxis de la función gets será:

#include <stdio.h>

char *gets(char *s)




main ()

{char cad [80];

cout << “introduzca una cadena:”; // lectura del teclado cin » cad;

cin >> cad;

cout << “Su cadena es:”;

cout << cad;

return 0; }

Descripción: Captura una cadena desde el stdin. Esta cadena es tomada de una línea y colocada en s, en el fin de

línea se pondrá el carácter ‘\n’. esto nos permite considerar algunos blancos intermedios que de otra manera no se

considerarían.

El programa anterior quedaría así:

Ejemplo 1.- Escriba un programa que ingrese nombres y apellidos a una variable, usando cin y usando la función

gets y compare resultados al imprimirlos.

PROGRAMA

/* CODIGO: POOC6E1

Fecha : 18 de marzo de 2013

objetivo: compara la lectura de cadenas con cin y con gets

entrada: vector nombre_apellidos char 80, leído por cin y por gets

salida: escritura con cin y con gets de una cadena de caracteres.*/


#include<conio.h>

#include<stdio.h>

void main()

{ char nombre_apellidos1[50],nombre_apellidos2[50];


cout<<"Ingrese nombres y apellidos : "; cin>>nombre_apellidos1;

cout<<"Ingrese nombres y apellidos : "; gets(nombre_apellidos2);

cout<<endl<<endl;

cout<<"Salida del nombre y apellidos leídos con cin : "<<nombre_apellidos1<<endl;

cout<<"Salida del nombre y apellidos leídos con gets: "<<nombre_apellidos2;

getch(); }

EJECUCION

6.2 Funciones para manejar cadenas:

Copia una cadena en otra cadena. strcpy




#include <stdio.h>

main()

{ char cad[80];

cout « “Introduzca una cadena:”;

gets (cad);

cout « Su cadena es:”; cout << cad;

return 0; }

#include <string.h>

char *strcpy(char *destino, const char *origen)

Copia la cadena de caracteres de origen a destino.

Retorna destino.

Copia un número de bytes de una cadena a otra. strncpy

Ejemplo 2.- Escriba un programa que ingrese nombres y código sabiendo que en el código los cuatro primeros

caracteres son el año de ingreso, mostrar en la salida el nombre y el año de ingreso.

PROGRAMA

/* CODIGO: POOC6E2

fecha : 18 DE MARZO DE 2013

objetivo: Copia cadenas completas o parte de una cadena

entrada: nombre y código

salida: nombre, año de ingreso */


#include<conio.h>

#include<stdio.h>

void main()

{ char nombre[50],codigo[10];

char nomsal[50],ingreso[5];


cout<<"Ingrese nombre: "; gets(nombre);

cout<<"Ingrese cOdigo: "; gets(codigo);

strcpy(nomsal,nombre);

strncpy(ingreso,codigo,4);

ingreso [4]='\0';

cout<<endl<<endl;

cout<<"Nombre : "<<nomsal<<endl;

cout<<"Año de Ingreso : "<<ingreso;

getch(); }

EJECUCION

Compara dos cadenas. strcmp



#include<stdio.h>

char *strncpy(char *dest, const char *origen,size_t maxlen)

Copia un numero de bytes de origen a destino.

Retorna destino.

#include<string.h>

int strcmp(const char *s1, const char *s2)

Compara una cadena con otra, iniciando por el primer character hasta que difieran

o se alcanze el final.

Si s1 es menor que s2 devuelve un valor menor que 0.

Si s1 es igual que s2 devuelve un valor igual a 0.

Si s1 es mayor que s2 devuelve un valor mayor que 0.

Ejemplo 3.- Escriba un programa que ingrese 3 nombres y los ordene utilizando la función strcmp y también strcpy.

PROGRAMA

/* CODIGO: POOC6E3


objetivo: Ordena tres nombres en forma alfabética

entrada: nombre1,nombre2 y nombre3

salida: las tres entradas ordenadas alfabéticamente */


#include<conio.h>

#include<stdio.h>

void intercambio(char na[30],char nb[30]);

void main()

{ char nombre1[30],nombre2[30],nombre3[30];

int i;


cout<<"Ingrese nombre 1: "; gets(nombre1);



for(i=1;i<=2;i++)

{if (strcmp(nombre1,nombre2)>0)

intercambio(nombre1,nombre2);

if (strcmp(nombre2,nombre3)>0)

intercambio(nombre2,nombre3);

}

cout<< "Nombres Ordenados "<<endl;

cout<<nombre1<<endl;



getch();

}

void intercambio(char na[30],char nb[30])

{ char temp[30];

strcpy(temp,na);

strcpy(na,nb);

strcpy(nb,temp); }

EJECUCION



Adiciona una cadena a otra. strcat

Calcula la longitud de una cadena.strlen

Ejemplo 4.- Escriba un programa que ingrese año de ingreso, orden de merito y dos caracteres y genere su codigo

concatenando estos datos.

PROGRAMA

/* CODIGO: POOC6E4


objetivo: Ejemplo de la función strlen y strcat()

entrada: Ingresa un año y orden de merito mas dos letras

salida: Codigo generado */


#include<conio.h>

#include<stdlib.h>

#include<string.h>

void main()

{ int agno,merito;

char agnoc[5],meritoc[5],letras[3];

char codigo[13]="";

clrscr();

cout<<"Ingrese un año: ";cin>>agno;

cout<<"Ingrese orden de merito: ";cin>>merito;

cout<<"Ingrese 2 caracteres: ";cin>>letras;

cout<<agno<<endl;

cout<<merito<<endl;

cout<<letras<<endl;



Syntaxis

#include <string.h>

char *strcat(char *dest, const char *src);

Descripcion

Adiciona una cadena a otra, strcat adicion una copia src al final de dest. La

longitud de el resultado es strlen(dest) + strlen(src).

Syntax

#include <string.h>

size_t strlen(const char *s);

Descripcion

Calcula la longitud de una cadena. Strlen calcula la longitude de s.

itoa(agno,agnoc,10);

itoa(merito,meritoc,10);

cout<<agnoc<<" Cadena de longitud: "<<strlen(agnoc)<<endl;

cout<<meritoc<<" Cadena de longitud: "<<strlen(meritoc)<<endl;

cout<<letras<<" Cadena de longitud: "<<strlen(letras)<<endl;

strcat(codigo,agnoc);

strcat(codigo, meritoc);

strcat(codigo,letras);

cout<<"Codigo Generado= "<<codigo<<endl;

cout<<"Cadena de longitud: "<<strlen(codigo)<<endl;

getch(); }

EJECUCION

6.3 Vectores de cadenas: Cuando queremos trabajar con un arreglo de cadenas en realidad vamos a trabajar

con una matriz de caracteres, veamos esto, declaremos la variable codigo:

char codigo[3][4]

Se grafica

a 1 2 \0 b 2 2 \0 c 3 4 \0

Donde

codigo [0] “a12”

codigo [1] “b22”

codigo [2] “c34”

o sea que podemos trabajar con las cadenas, codigo[0], codigo[1], codigo[2] y todas las funciones estudiadas

se aplicaran a estas filas de las matrices de caracteres que viene a ser las cadenas que trabajaran como

argumentos de estas funciones.

Ejemplo 5.- Escribir un programa básico que nos permita lee un vector de cadenas donde almacenemos un

conjunto de “n” cursos

PROGRAMA

/* CODIGO: POOC6E5


objetivo: LECTURA Y ESCRITURA DE NOMBRES DE CURSOS

entrada: Ingresa un arreglo de cursos

salida: Muestra los cursos ingresados */


#include<conio.h>

#include<stdlib.h>

#include<string.h>



#include<stdio.h>

void main()

{ int i,n;

char curso[50][15];//Puede almacenar hasta 50 cursos

clrscr();

cout<<"Ingrese número de cursos ==> ";cin>>n;

for(i=1;i<=n;i++)

{ cout<<"Ingrese curso["<<i<<"]: ";

gets(curso[i]); }

//salida

clrscr();

gotoxy(35,2);cout<<" CURSOS ";

for(i=1;i<=n;i++)

{ gotoxy(33,4+i);cout<<curso[i];}

getch(); }

EJECUCION

Ejemplo 6.- Escribir un programa básico que nos permita lee un vector de cadenas donde almacenemos un

conjunto de “n” nombres y después lo ordene en forma alfabética.

PROGRAMA

/* CODIGO: POOC6E6


objetivo: Ordenamiento alfabético de nombres

entrada: Ingresa un arreglo de nombres

salida: Muestra los nombres ingresados ordenados alfabéticos */


#include<conio.h>

#include<stdlib.h>

#include<string.h>

#include<stdio.h>

void main()

{ int i,j,n;

char nombre[40][30],temp[30];//Puede almacenar hasta 40 nombres

clrscr();

cout<<"Ingrese numero de nombres ==> ";cin>>n;

for(i=1;i<=n;i++)

{ cout<<"Ingrese apellidos y nombres["<<i<<"]: ";

gets(nombre[i]);

}



//salida

clrscr();

gotoxy(35,2);cout<<" NOMBRES ";

for(i=1;i<=n;i++)

{ gotoxy(33,4+i);cout<<nombre[i];}

getch();

//ordenamiento de nombres

for(i=1;i<n;i++)

for(j=i+1;j<=n;j++)

if(strcmp(nombre[i],nombre[j])>0)

{strcpy(temp,nombre[i]);

strcpy(nombre[i],nombre[j]);

strcpy(nombre[j],temp);

}

clrscr();

gotoxy(35,2);cout<<" NOMBRES ORDENADOS";

for(i=1;i<=n;i++)

{ gotoxy(33,4+i);cout<<nombre[i];}

getch(); }

EJECUCION

PROBLEMAS

1.- Tenemos dos vectores de cadenas, el primero almacena códigos de los cursos de 5 caracteres de longitud y el

segundo almacena los nombres de los cursos, escriba usted un programa que lea un codigo y realice una búsqueda,

si encuentra el curso debe mostrar el nombre y si no lo encuentra un mensaje de no hallado.

PROGRAMA





objetivo: BUSQUEDA EN UN VECTOR PARALELO

entrada: INGRESA CODIGO DE UN CURSO

salida: NOMBRE DEL CURSO O MENSAJE DE BUSQUEDA FALLIDA */


#include<conio.h>

#include<stdlib.h>

#include<string.h>

#include<stdio.h>

void main()

{ int i,j,n;

char codcur[50][6],nomcur[50][30],codx[6];

clrscr();

cout<<"Ingrese numero de cursos ==> ";cin>>n;

for(i=1;i<=n;i++)

EJECUCION

2.- Deseamos generar Emails para un grupo de alumnos de la facultad de Ingeniería Mecánica (FIM), esto lo

haremos utilizando los dos primeros caracteres del nombre y el primer apellido mas la cadena “@fim.edu.pe”, por

ejemplo si el nombre es José cárdenas, el email generado seria: [email protected], utilice las funciones

necesaria que hemos revisado para generar los emails de un grupo de “n” alumnos de la facultad de ingeniería

mecánica (FIM).

PROGRAMA





objetivo: BUSQUEDA EN UN VECTOR PARALELO

entrada: INGRESA CODIGO DE UN CURSO

salida: NOMBRE DEL CURSO O MENSAJE DE BUSQUEDA FALLIDA */


#include<conio.h>

#include<stdlib.h>

#include<string.h>

#include<stdio.h>

void main()

{ int i,j,n;

char codcur[50][6],nomcur[50][30],codx[6];

clrscr();

cout<<"Ingrese numero de cursos ==> ";cin>>n;

for(i=1;i<=n;i++)



objetivo: Genera un Email para cada alumno FIM

entrada: nombre y apellido

salida: Email */


#include<conio.h>

#include<stdio.h>

#include<string.h>

void main()

{ char nombre[10][15],apellido[10][15];

char cadena1[10][3],cadena2[12]="@fim.edu.pe";

char email[10][30];

int i,n;


mailto:[email protected]

EJECUCION

3.- Tenemos dos vectores de cadenas, el primero tiene el nombre del alumno y el segundo tiene el curso en el cual

está matriculado, se desea escribir un programa que lea el nombre de un curso y me genere un listado alfabético de

todos los alumnos matriculados en el curso.

PROGRAMA



objetivo: Genera un listado alfabetico de un curso

entrada: nombre y curso matriculado ademas del curso para obtener el listado

salida: Listado */


#include<conio.h>

#include<stdio.h>

#include<string.h>

void main()

{ char nombre[40][20],curso[40][15],cursox[15];

char lista [40][20],temp[20];

int i,j,n,n1;





objetivo: Genera un Email para cada alumno FIM

entrada: nombre y apellido

salida: Email */


#include<conio.h>

#include<stdio.h>

#include<string.h>

void main()

{ char nombre[10][15],apellido[10][15];

char cadena1[10][3],cadena2[12]="@fim.edu.pe";

char email[10][30];

int i,n;



cout<<"Ingrese numero de alumnos ==> ";cin>>n;

for(i=1;i<=n;i++)

{ cout<<"Ingrese apellidos y nombres["<<i<<"]: "; gets(nombre[i]);

cout<<"Ingrese nombre del curso ["<<i<<"]: "; gets(curso[i]); }

cout<<"Ingrese nombre del curso";gets(cursox);

//salida

n1=0;

for(i=1;i<=n;i++)

if(strcmp(cursox,curso[i])==0)

{n1=n1+1;

strcpy(lista[n1],nombre[i]); }

clrscr();

//ordenamiento de la lista

for(i=1;i<n1;i++)

for(j=i+1;j<=n1;j++)

if(strcmp(lista[i],lista[j])>0)

{strcpy(temp,lista[i]);

strcpy(lista[i],lista[j]);

strcpy(lista[j],temp); }

clrscr();

gotoxy(35,2);cout<<" NOMBRES ORDENADOS";

for(i=1;i<=n1;i++)

{ gotoxy(33,4+i);cout<<lista[i];}

getch(); }

EJECUCION


1. Escribir un programa que lea el codigo de un alumno compuesto por año que ingreso + puesto que ingreso y

una letra y halle el año de ingreso y además orden de merito para “n” alumnos. Ejemplo lee “2005193c” y

muestra año de ingreso = 2005 y orden de merito 193. No olvidar que esto se tiene que realizar para líos “n”

alumnos.

2. Dados tres vectores paralelos, el primero con el codigo de n alumnos el segundo con el codigo del curso en el

que están matriculados y el tercero con la nota, escribir un programa que liste todos los aprobados además

del promedio total de un curso particular.

3. Se tiene un conjunto de códigos, escriba un programa que me permita encriptarlos intercambiando sus

caracteres y además tiene que mostrar también la rutina que los desencripta.



4. Escribir el código necesario para leer un conjunto de “n” cadenas de caracteres e imprimir cuantas veces se

presenta cada vocal.

5. Se tiene una vector de nombres, otro de direcciones y un último vector de teléfonos, se desea escribir un

listado de todos los que tienen celular. El listado debe incluir nombre y dirección.



CAPITULO VII

REGISTROS EN LENGUAJE “C”

7 Definición.- Un registro o una estructura en lenguaje “C” es una colección de variables simples que pueden

contener diferentes tipos de datos. Es un tipo de dato definido por el usuario.

7.1 Modelamiento de un registro de acuerdo a las entidades del mundo real: Cuando se crea un registro

se utiliza las entidades (elementos relevantes del proceso) del mundo real para crear la estructura del

registro. Veamos un ejemplo. Supongamos que el proceso matricula se automatiza, entonces cuales serian

las entidades del mundo real que participan en este proceso, algunas de ellas serian:

Alumno

Profesor

Curso

Aulas

Escuelas

Etc,

Tomemos la entidad alumno y la entidad curso, como estas entidades dan origen a sus respectivos registros.

ENTIDAD REGISTRO



ALUMNO

CODIGO

NOMBRE

DIRECCION

ESCUELA

TELEFONO

REGALU

codalu entero largo

nomalu carácter de longitud 30

diralu carácter de longitud 40

escalu carácter de longitud 2

telalu entero largo

Vemos que cada característica de la entidad alumno se convierte en un campo del registro regalu.

Continuemos con la entidad curso:

ENTIDAD REGISTRO

CURSO

CODIGO

NOMBRE

NOTAFIN

REGCUR

codcur carácter de longitud 5

nomcur carácter de longitud 30

notcur real

Vemos claramente que los campos son las características que definen a la entidad y almacenaran estos datos

de una entidad particular.

Si nosotros visualizamos un registro, seria de la siguiente forma:

Estructura de REGALU

codalu nomalu diralu escalu telalu

Estructura de REGCUR

codcur nomcur notcur

Si vemos un arreglo de estos registros se vería así

codalu nomalu diralu escalu telalu

7.2 Creación y manejo de registros

El proceso de crear una estructura o registro tiene dos etapas.064+70



Crear la variable estructurada

Ejemplo:

struct ciudadano

{ long dni; // dato miembro dni

char nombre[40];// dato miembro nombre

char dirección[50]; // dato miembro dirección

}

Posteriormente las variables persona1 y persona2 se definen como cualquier otra variable, en este caso del tipo de

nombre de la estructura.

ciudadano persona1, persona2; // se declaran dos variables tipo registro.

7.3 Acceso a miembros del registro.- Se realiza utilizando el nombre del registro seguido del nombre del campo

con un punto intermedio.

persona1.dni = 08234101;

persona2.dni = 91012345;

strcpy( persona1.nombre, “ Luis Rojas”);

strcpy( persona2.nombre, “ Jose Castañeda”);

strcpy( persona1.direccion, “ San Borja, Los alamos 257”);

strcpy( persona2.direccion, “ Surco, leoncio Prado 820”);

7.4 Inicialización de estructuras.- Los campos de un registro se pueden iniciar individualmente o todos a la vez :

Ejemplo:

struct caja

{ int largo;

int ancho;

int altura; };

Caja c1 = {4, 5,2}

caja c2, c3;

c2.largo = 3;

c3.ancho = 1;

7.5 Asignación de estructuras.- Podemos intercambiar información entre dos estructuras directamente de

registro a registro.

Ejemplo: De los casos anteriores es válido decir:

persona2 = persona1;

c1 = c3;

Los contenidos de los correspondientes campos de persona1 se copiaran en persona2, los de c3 en c1.

Estructuras anidadas.- Se pueden anidar estructuras dentro de otras estructuras.

Ejemplo: struct fecha

{ int dia;

int mes;

int año; }

struct empleado

{ fecha dia_ingreso;

char nombre[50]; }



EJEMPLO 1.- Vamos a desarrollar un programa que lea y escriba un arreglo de “n” registros, cuya estructura es :

Dni cadena de 10 caracteres

Nombre cadena de 30 caracteres

Dirección cadena de 40 caracteres

PROGRAMA

/* CODIGO: POOC7E1


OBJETIVO:PROGRAMA QUE LEE Y ESCRIBE UN ARREGLO DE REGISTROS*/


#include<conio.h>

#include<stdio.h>

#include<iomanip.h>

struct persona

{ char dniper[10]; // DNI DE LA PERSONA

char nomper[30]; // NOMBRE DE LA PERSONA

char dirper[40]; // DIRECCION DE LA PERSONA };

void main( )

{ int i,n;

persona p[50];

clrscr();

cout<< " Cuantos registros va a procesar ==> ";

cin >>n;

for(i=1;i<=n;i++)

{cout<< " REGISTRO "<<i<<" :"<<endl<<endl;

cout<< " DNI = ";cin>>p[i].dniper;

cout<< " NOMBRE = ";gets(p[i].nomper);

cout<< " DIRECCION= ";gets(p[i].dirper); }

cout<<setiosflags(ios::left);

// Salida de resultados

clrscr();

cout<< " LISTA DE REGISTROS "<<endl;

cout<< "==================== "<<endl;

cout<<setw(10)<<"DNI";

cout<<setw(20)<<"NOMBRE";

cout<<setw(30)<<"DIRECCION"<<endl;

cout<< "====================================================== "<<endl;

for(i=1;i<=n;i++)

{cout<<setw(10)<<p[i].dniper;

cout<<setw(20)<< p[i].nomper;

cout<<setw(30)<<p[i].dirper<<endl;

} getch(); }

EJECUCION



EJEMPLO 2.- Se tiene un arreglo de registros, cuya estructura es :

codigo cadena de 8 caracteres ‘Codigo de alumno

nombre cadena de 30 caracteres ‘Nombre del alumno

examen1 entero ‘Nota del examen parcial

examen2 entero ‘Nota del examen final

promediop real ‘promedio de practicas

notafinal real ‘Nota final

Primero debe ingresar los datos de cada alumno, la nota final será calculada, considerando examen1 (peso 1),

examen2 (peso2) y promediop(peso2). El codigo no puede ser repetido, esta condición debe ser probada en cada

ingreso. Finalmente presentar resultados.

PROGRAMA

/* CODIGO: POOC7E2


OBJETIVO: Ingresa registros sin codigo repetido */


#include<conio.h>

#include<stdio.h>

#include<iomanip.h>

struct notas

{ char codalu[9]; // Codigo de alumno

char nomalu[30]; // Nombre del alumno

int examen1;

int examen2;

float promediop;

float notafinal;

};

void main( )

{ int i,nr,m,j;

notas n[50];

int swr;

clrscr();

cout<< " Cuantos registros va a leer ==> ";

cin >>nr;

for(i=1;i<=nr;i++)

{ swr=1;

while (swr)

{ swr=0;



clrscr();

gotoxy(25,2);cout<<"INGRESO DE REGISTRO DE NOTAS";

gotoxy(26,5);cout<<" Ingrese codigo ==> ";gets(n[i].codalu);

m=i-1;

for (j=1;j<=m;j++)

if (strcmp(n[i].codalu,n[j].codalu)==0)

{swr=1;

break;

}

if(swr==1)

{gotoxy(30,18);

cout<<"Error codigo repetido..........";

getch();

}

else

{ gotoxy(26,18);cout<<"Por favor ingrese datos...." ;

gotoxy(26,6);cout<<" Ingrese nombre ==> ";gets(n[i].nomalu);

gotoxy(26,7);cout<<" Ingrese examen parcial ==> ";cin>>n[i].examen1;

gotoxy(26,8);cout<<" Ingrese examen final ==> ";cin>>n[i].examen2;

gotoxy(26,9);cout<<" Ingrese Promedio Prac. ==> ";cin>>n[i].promediop;

n[i].notafinal=(n[i].examen1+2*n[i].examen2+2*n[i].promediop)/5.0;

}

}

}


// Salida de resultados

clrscr();

cout<< " LISTADO DE ALUMNOS "<<endl;

cout<< "==================== "<<endl;

cout<<setw(10)<<"CODIGO";

cout<<setw(20)<<"NOMBRE";

cout<<setw(11)<<"EX.PARCIAL";

cout<<setw(11)<<"EX.FINAL ";

cout<<setw(11)<<"PROM.PRAC.";

cout<<setw(11)<<"NOTA FINAL"<<endl;

cout<< "========================================================================= "<<endl;

for(i=1;i<=nr;i++)

{cout<<setw(10)<<n[i].codalu;

cout<<setw(20)<< n[i].nomalu;

cout<<setw(11)<< n[i].examen1;

cout<<setw(11)<< n[i].examen2;

cout<<setw(11)<< n[i].promediop;

cout<<setw(11)<< n[i].notafinal<<endl;

} getch();

}

EJECUCION



PROBLEMAS

1. Desarrollar un programa que maneje todos los productos que una tienda de abarrotes vende, siendo nuestro

objetivo principal el automatizar el proceso de una tienda de abarrotes que nos permitirá realizar las siguientes

operaciones de manera eficiente:

Tener un listado actualizado del stock en todo momento

Eliminar los productos que ya no se venden.

Adicionar productos nuevos.

Consultar datos sobre un producto particular.

Realizar balances mensuales de la tienda de abarrotes para manejar la contabilidad eficientemente.

SOLUCION:

PROGRAMA



OBJETIVO: Pograma que crea un menú para manejo de registros que procesan stock de una tienda de abarrotes */


#include<conio.h>

#include<string.h>

#include<stdio.h>

#include<ctype.h>

struct item



{ int codite; // código del producto

char desite[20]; // descripción del producto

char ubiite[4]; // ubicación del producto

float nunite; // número de unidades del producto

int tunite;// tipo de unidades kilo(1), litro(2), c/u(3)

float pruite; // precio por cada unidad del producto

};

void lectura(item prod[50], int *n);

void adicion(item prod[50], int *n);

void eliminacion(item prod[50], int *n);

void busqueda(item prod[50], int n);

void orden1(item prod[50], int n);

void escritura(item prod[50], int n);

void main( )

{ item vprod[50];

int num;

char opcion;

do { clrscr();

gotoxy(30,2); cout<< "MENU ARREGLOS";

gotoxy(30,5); cout<< "1.- Lectura";

gotoxy(30,6); cout<< "2.- Adicion";

gotoxy(30,7); cout<< "3.- Eliminacion";

gotoxy(30,8); cout<< "4.- Búsqueda";

gotoxy(30,9); cout<< "5.- Ordenamiento ";

gotoxy(30,10);cout<< "6.- Escritura";

gotoxy(30,11);cout<< "7.- Salir ";

gotoxy(30,16);cout<< "Ingrese Opcion ==> ";cin >> opcion;

switch(opcion)

{ case '1' : lectura(vprod, &num);break;

case '2' : adicion(vprod, &num);break;

case '3' : eliminacion(vprod, &num);break;

case '4' : busqueda(vprod, num);break;

case '5' : orden1(vprod, num);break;

case '6' : escritura(vprod, num);break; }


}

void lectura(item prod[50], int *n)

{ int i;

clrscr();


cin >> (*n);

for ( i=1; i<=(*n);i++)

{ cout<< " Ingrese codigo "<< i<<" : "; cin>> prod[i].codite;

cout<< " Ingrese descripcion "<< i<<" : "; gets(prod[i].desite);

cout<< " Ingrese ubicación "<< i<<" : "; cin>> prod[i].ubiite;

cout<< " Ingrese # de unidades"<< i<<" : "; cin>> prod[i].nunite;



cout<< " Tipo de unidad kilo(1),litro(2),c/u(3) "<< i<<" : ";

cin>> prod[i].tunite;

cout<< " Ingrese precio por unidad del producto"<< i<<" : ";

cin>> prod[i].pruite; } }

void adicion(item prod[50], int *n)

{ int codx,i;

item reg1;

clrscr();

cout<<"Ingrese codigo : ";

cin>> codx;

for( i=1;i<=(*n);i++)

if(prod[i].codite == codx)

break;


{cout<< "error codigo ya existe "; getch();}

else

{ reg1.codite = codx;

cout<< " Ingrese descripcion : "; gets(reg1.desite);

cout<< " Ingrese ubicación : "; cin>> reg1.ubiite;

cout<< " Ingrese # de unidades : "; cin>> reg1.nunite;

cout<< " Tipo de unidad kilo(1),litro(2),c/u(3): ";

cin>> reg1.tunite;

cout<< " Ingrese precio por unidad del producto: ";

cin>> reg1.pruite;

prod[(*n)+1] = reg1;

(*n)=(*n) +1; cout<< " Registro adicionado..."; getch(); } }

void eliminacion(item prod[50], int *n)

{ int codx,i,j; char rpta;

clrscr();


cin>> codx;

for( i=1;i<=(*n);i++)


{ j=i;

break; }

if(prod[i].codite != codx)

{cout<< " Registro no existe... "; getch();}

else

{cout<< " Descripción : "<<prod[i].desite<<endl;

cout<< " Ubicación : "<<prod[i].ubiite<<endl;

cout<< " # de unidades : "; prod[i].nunite<<endl;

cout<< " Tipo de unidad kilo(1),litro(2),c/u(3): "<<prod[i].tunite<<endl;

cout<< " Ingrese precio por unidad del producto: "<<prod[i].pruite<<endl<<endl;

cout<<"Desea eliminar s/n"; cin>>rpta;

if (toupper(rpta)=='S')

{ for( i=j+1 ; i<=(*n);i++)



prod[i-1] = prod[i];

(*n)=(*n) - 1; }

getch();

} }

void busqueda(item prod[50], int n)

{ int codx,i;

clrscr();


cin>> codx;

for( i=1;i<=n;i++)


break;

if(prod[i].codite != codx)

{cout<< " Registro no existe... "; getch();}

else

{cout<< " Descripción : "<<prod[i].desite<<endl;

cout<< " Ubicación : "<<prod[i].ubiite<<endl;

cout<< " # de unidades : "<< prod[i].nunite<<endl;

cout<< " Tipo de unidad kilo(1),litro(2),c/u(3): "<<prod[i].tunite<<endl;

cout<< " Ingrese precio por unidad del producto: "<<prod[i].pruite<<endl;

getch(); } }

void orden1(item prod[50], int n)

{ int i, j; item temp;

for ( i=1; i<n ;i++)


if( prod[i].codite> prod[j].codite)

{ temp = prod[i];

prod[i] = prod[j];

prod[j] = temp ; } }

void escritura(item prod[50], int n)

{ int i;

clrscr();

cout<<" CODIGO PRODUCTO UBICACION # UNIDADES TIPO PRECIO/U ";

cout<<endl;

cout<<endl;

for ( i=1; i<=n;i++)

{ cout<< prod[i].codite<<" ";

cout<< prod[i].desite<<" ";

cout<< prod[i].ubiite<<" ";

cout<< prod[i].nunite<<" ";

cout<< prod[i].tunite<<" ";

cout<< prod[i].pruite<<endl; }

getch(); }

EJECUCION



2. Dada la siguiente estructura(registro)

codigo entero

nombre char 40

nivel char //solo existe A,B,C

sueldo real

a) Declarar la estructura.

b) Escribir el menú

Leer

Adicionar

Eliminar

Escribir

Salir

c) Escribir las funciones Leer, adicionar, eliminar y escribir.

SOLUCIÓN

PROGRAMA



OBJETIVO: Programa que crea un menú con registros de empleados */


#include<conio.h>

#include<string.h>

#include<stdio.h>

#include<iomanip.h>

struct empleado

{ int codemp; // código del empleado

char nomemp[40]; // nombre del empleado

char nivemp; // nivel remunerativo del empleado A,B,C

float sueemp; // sueldo del empleado

};

void leer(empleado p[50], int *n);



void adicionar (empleado p[50], int *n);

void eliminar (empleado p[50], int *n);

void escribir(empleado p[50], int n);

void main( )

{ empleado v[50];

int num;

char opcion;

clrscr();

do { clrscr();

gotoxy(26,2); cout<< "MANTENIMIENTO EMPLEADOS";

gotoxy(30,5); cout<< "1.- Leer";

gotoxy(30,6); cout<< "2.- Adicionar";

gotoxy(30,7); cout<< "3.- Eliminar";

gotoxy(30,8); cout<< "4.- Escribir";

gotoxy(30,9); cout<< "5.- Salir ";

gotoxy(26,16); cout<< "Ingrese Opcion ==> "; cin >> opcion;

switch(opcion)

{ case '1' : leer(v, &num);break;

case '2' : adicionar(v, &num);break;

case '3' : eliminar(v, &num);break;

case '4' : escribir(v, num);break; }


}

void leer(empleado p[50], int *n)

{ int i;

clrscr();


cin >> (*n);

clrscr();

gotoxy(30,2); cout<< "LECTURA";

gotoxy(30,3); cout<< "=======";

cout<<endl<<endl;

for ( i=1; i<=(*n);i++)

{ cout<< " Ingrese Codigo del Empleado "<< i<<" : "; cin>> p[i].codemp;

cout<< " Ingrese Nombre y Apellido "<< i<<" : "; gets(p[i].nomemp);

cout<< " Ingrese Nivel Remunerativo "<< i<<" : "; cin>> p[i].nivemp;

cout<< " Ingrese Sueldo del Empleado "<< i<<" : "; cin>> p[i].sueemp;

}

}

void adicionar (empleado p[50], int *n)

{ int codx,i;

empleado aux;

clrscr();

gotoxy(30,2); cout<< "ADICION";

gotoxy(30,3); cout<< "=======";

cout<<endl<<endl;



cout<<"Ingrese codigo : "; cin>> codx;

for( i=1;i<=(*n);i++)

if(p[i].codemp == codx)

break;

if(i==((*n)+1)) i--;

if(p[i].codemp == codx)

{cout<< "Error Codigo ya existe "; getch();}

else

{ aux.codemp = codx;

cout<< " Ingrese nombre : "; gets(aux.nomemp);

cout<< " Ingrese nivel remunerativo: "; cin>> aux.nivemp;

cout<< " Ingrese sueldo : "; cin>> aux.sueemp;

(*n)=(*n) +1; cout<< " Registro adicionado...";

p[*n] = aux;

getch();

}

}

void eliminar(empleado p[50], int *n)

{ int i,j, codx;

char rpta;

clrscr();

gotoxy(30,2); cout<< "ELIMINACION";

gotoxy(30,3); cout<< "===========";

cout<<endl<<endl;

cout<<"Ingrese Codigo a Buscar : ";

cin>> codx;

for( i=1;i<=(*n);i++)

if ( p[i].codemp == codx)

{ j = i;

break ;

}

if ( p[i].codemp == codx)

{cout<< " Registro Hallado "<<endl;

cout<< p[j].nomemp<<" ";

cout<< p[j].nivemp<<" ";

cout<< p[j].sueemp<<endl;

cout<<"Desea eliminar s/n => "; cin>> rpta;

if((rpta == 's') || (rpta == 'S'))

{ if ( j!=(*n))

for( i=j+1 ; i<=(*n);i++)

p[i-1] = p[i];

(*n)=(*n) - 1; }// Se elimina registro

}

else

{cout<< " Registro no Hallado ";

getch();



}

}

void escribir(empleado p[50], int n)

{int i;

clrscr();


cout<<setw(10)<<"|CODIGO |";

cout<<setw(20)<<"NOMBRE |";

cout<<setw(6)<<"NIVEL|";

cout<<setw(8)<<"SUELDO |";

cout<<endl;

cout<<"==========================================="<<endl;

for ( i=1; i<=n;i++)

{ cout<<setw(10)<<p[i].codemp;

cout<<setw(20)<<p[i].nomemp;

cout<<setw(5)<<p[i].nivemp;

cout<<setw(8)<<p[i].sueemp<<endl;

}

getch(); }

EJECUCION

3. Se desea escribir un programa que procese el examen sustitutorio de "n" alumnos, considerar el siguiente

registro:

struct notas

{ char codalu [10]; // Código del alumno

char codcur [7]; // Código del curso

float pp ; // Promedio de prácticas

int ep ; // Examen parcial

int ef ; // Examen final

int es ; // Examen sustitutorio

float pf ; // Promedio final }

para hallar el promedio final (pf) debe considerarse lo siguiente:

a. Si no se ha rendido un examen (ep, ef ) la nota que figura es 99.(OJO)



b. El promedio final se halla

pp=(ep+2ef+pp)/4

c. El examen sustitutorio solo se considera si pp 6.0

d. Al considerar el examen sustitutorio este reemplazara al examen no rendido

o al más desfavorable de haber rendido los dos.

e. Ordenar los promedios finales por merito y a quien corresponde.*/

PROGRAMA



OBJETIVO: Programa que procesa notas, considerando las pruebas no rendidas como 99, para cálculos el 99 se transforma en cero */


#include<conio.h>

#include<stdio.h>

#include<stdlib.h>

#include<iomanip.h>

struct notas

{

char codalu[10];

char codcur[7];

float pp;

int ep;

int ef;

int es;

float pf;

};

void leer( notas libreta[50] , int *n);

void promedio ( notas nota[50] , int n);

void orden( notas nota[50] , int n);

void main( )

{ int num;

notas registro[50];

cout<<"REGISTRO"<<endl;

leer ( registro , &num );

promedio ( registro , num );

orden( registro , num ); }

void leer( notas libreta[50] , int *n)

{ int i;

clrscr();

cout<<"REGISTRO DE NOTAS"<<endl<<endl;;

cout<<"Numero de alumnos: ";cin>>*n;

cout<<endl;

for(i=1;i<=*n;i++)

{ cout<<"CODIGO ALUMNO: ";cin>>libreta[i].codalu;

cout<<"CODIGO CURSO: ";cin>>libreta[i].codcur;

cout<<"PROM. PRACTICAS: ";cin>>libreta[i].pp;



cout<<"EX. PARCIAL: ";cin>>libreta[i].ep;

cout<<"EX. FINAL: ";cin>>libreta[i].ef;

cout<<"EX. SUSTITUTORIO: ";cin>>libreta[i].es; }

}

void promedio ( notas nota[50] , int n)

{ int i,condicion1,condicion2,condicion3;

for(i=1;i<=n;i++)

{ condicion1=(nota[i].es!=99);

condicion2=(nota[i].ep==99);

condicion3=(nota[i].ef==99);

if (nota[i].ep==99) nota[i].ep=0;

if (nota[i].ef==99) nota[i].ef=0;

nota[i].pf = ( nota[i].pp + nota[i].ep + 2*nota[i].ef )/4.0;

if( condicion1 )

{

if(nota[i].pp>=6.0)

{

if ( condicion2 || condicion3 )

{

if(condicion2)

nota[i].pf=( nota[i].pp+nota[i].es+2*nota[i].ef) /4.0;

if(condicion3)

nota[i].pf=( nota[i].pp+2*nota[i].es+nota[i].ep) /4.0;

}

else

if ( (nota[i].pp+nota[i].es+nota[i].ef*2)>(nota[i].pp+nota[i].ep+nota[i].es*2) )

nota[i].pf=(nota[i].pp+nota[i].es+nota[i].ef*2)/4.0;

else

nota[i].pf=(nota[i].pp+nota[i].ep+nota[i].es*2)/4.0;

}

}

}

}

void orden( notas nota[50] , int n)

{

int i,j;

notas temp;

for(i=1;i<n;i++)

for(j=i+1;j<=n;j++)

if( nota[i].pf<nota[j].pf )

{ temp=nota[i];

nota[i]=nota[j];

nota[j]=temp; }

clrscr( );

cout<<setiosflags(ios::fixed);

cout<<setiosflags(ios::showpoint);



cout<<setprecision(2);


cout<<" LISTADO POR ORDEN DE MERITO"<<endl;

cout<<" ==========================="<<endl;

cout<<endl<<endl;

cout<<setw(10)<<"|CODIGO ";

cout<<setw(7)<<"|CURSO ";

cout<<setw(8)<<"|PROM.FINAL|"<<endl;

cout<<"==========================="<<endl;

for(i=1;i<=n;i++)

{cout<<setw(10)<<nota[i].codalu;

cout<<setw(7)<<nota[i].codcur;

cout<<setw(8)<<nota[i].pf<<endl; }

getch(); }

EJECUCION

4.- Se desea escribir un programa que procese una agenda electrónica de clientes por dia de la semana, y elaborar

para el dia de la semana, un reporte alfabético de a-z.

SOLUCION

PROGRAMA



OBJETIVO: Elaborar una agenda electrónica de sus clientes por dia de la semana, y elaborar para el dia de la

semana, un reporte alfabético */


#include<conio.h>

#include<string.h>

#include<stdio.h>

struct clientes

{char nomcli[40];

char diasem[10];

char temcli[35];

};//variable definida por el usuario

struct agedia

{ char nomcli[40];

char temcli[35]; };

void main()



{ clientes agenda[100];

agedia diaria[25],temp;

char diax[10];

int i,j,k,n;

clrscr();

cout<<"Ingrese el número de clientes: "; cin>>n;

for(i=1;i<=n;i++)

{cout<<"Nombre: "; gets(agenda[i].nomcli);

cout<<"Dia: "; cin>>agenda[i].diasem;

cout<<"Tema: "; gets(agenda[i].temcli); }

//preparando agenda de un dia determinado

clrscr();

cout<<"Ingrese dia: "; cin>>diax; k=0;

for(i=1;i<=n;i++)

if(strcmp(diax,agenda[i].diasem)==0)

{k=k+1;

strcpy(diaria[k].nomcli,agenda[i].nomcli);

strcpy(diaria[k].temcli,agenda[i].temcli); }

for(i=1;i<k;i++)

for(j=i+1;j<=k;j++)

if(strcmp(diaria[i].nomcli,diaria[j].nomcli)>0)

{temp=diaria[i];

diaria[i]=diaria[j];

diaria[j]=temp; }

gotoxy(7,14);cout<<"NOMBRE";

gotoxy(48,14);cout<<"TEMA";

for(i=1;i<=k;i++)

{gotoxy(5,15+i);cout<<diaria[i].nomcli;

gotoxy(48,15+i);cout<<diaria[i].temcli;}

getch();

}

EJECUCION




1. Se desea realizar un mantenimiento de registros de los alumnos de COMPUTACION I, para esto vamos a

utilizar la siguiente estructura:

struct alumno{ int código;

char nombre [40];

int exampar; //Examen Parcial

int examfin; //Examen Final

float pp; }; // Promedio de Practicas

En el mantenimiento considere:

a) Adicionar Registros

b) Eliminar Registros.

c) Modificar Registros.

2. Se desea escribir un programa que procese el examen sustitutorio de “n” alumnos, considerar el registro.

struct notas

{ char codalu [10]; // Código del alumno

char codcur [7]; // Código del curso

float pp ; // Promedio de practicas

int ep ; // Examen parcial

int ef ; // Examen final

int es ; // Examen sustitutorio

float pf ; } // Promedio final

para hallar el promedio final (pf) debe considerarse lo siguiente:

a. Si no se ha rendido un examen (ep,ef) la nota que figura es 99(OJO).

b. El promedio final se hallapf= pp+ep+2∗ef

4

c. El examen sustitutorio solo se considera si pp 6.0

d. Al considerar el examen sustitutorio este reemplazara al examen no rendido o al mas desfavorable de

haber rendido los dos.

e. Ordenar los promedios finales por merito.

3. Se desea escribir un programa que procese la planilla de “n” trabajadores, considerar el registro dado.

struct empleado

{ int codemp; // Código del empleado

char nomemp [40]; // Nombre del empleado

float sb ; // Sueldo Bruto

int diasf; // Días faltos

int horase ; // Horas extras

float descuentos ; // Descuentos

float sn; // Sueldo Neto }

Para hallar los descuentos y el sueldo neto de cada trabajador debe considerar lo siguiente:

13% de descuento del sueldo bruto por seguro social.

Descuento por cada día falto.

50% de bonificación por cada hora extra.



CAPITULO VIII



8 CONCEPTOS DE LA PROGRAMACIÓN ORIENTADA A OBJETOS.-La programación orientada a objetos

existe desde la creación de los primeros lenguajes de programación. Los conceptos que se manejan de

abstracción de datos, herencia y Polimorfismo se manejaban en estos lenguajes, pero con el desarrollo del

lenguaje “C” y la programación visual se utiliza este tipo de programación con mayor profusión.

Programación estructurada, la programación estructurada se basa en la creación de una función principal y

una serie de rutinas(funciones) llamadas desde la función principal, que hacen que el desarrollo sea horizontal

contrastando con la programación lineal cuyo desarrollo es vertical. También podemos indicar que la informática

en su parte de programación era: Programa = Algoritmo + Estructura de datos. La ventaja de este modelo

era importante pero todavía se seguía manejando por separado el estado del sistema que descansa en la

estructura de datos y los procedimientos que actúan sobre el sistema, tampoco hay una consistencia de datos,

esto queda librado al criterio del programador, estas desventajas y otras más se van a superar con la

programación orientada a objetos.

8.1 Programación orientada a objetos.- La programación orientada a objetos es la ultima modificación, donde

ya se incorporan algunos aspectos tomando como modelo la vida real.

Tipos de Datos Abstractos

Algunos autores describen la programación orientada a objetos como programación de tipos de datos

abstractos y sus relaciones. Vamos a tratar de estudiar este aspecto de modelo de la vida real con mas

detalles en el concepto de “Tipos de Datos Abstractos”

Creando modelos.- La informática y la automatización en general trata de resolver o facilitar la vida real

creando programas y aplicaciones para esto. Sin embargo, los problemas de la vida real no están

claramente definidos por qué primeramente hay que crear un modelo de las entidades que actúan en la vida

real, entonces lo primero que se tiene que hacer es tratar de obtener tu propia perspectiva abstracta, o

modelo, del problema. Este proceso de modelado se llama abstracción y se ilustra en la Figura 8.1.

PROBLEMA

ABSTRACCION

MODELO

Figura 8.1

El modelo define una perspectiva abstracta del problema. Esto implica que el modelo se enfoca solamente

en aspectos relacionados con el problema y que tú tratas de definir propiedades del problema. Estas

propiedades incluyen

Los datos que son afectados

Las operaciones que son identificadas por el problema.

Vamos a plantear un caso, deseamos manejar los alumnos de un instituto. Que información es

necesaria, que funciones necesitamos que trabajen: Algunas propiedades serian

DNI



Nombre

Fecha de nacimiento,

Talla

Domicilio,

Color de ojos

Teléfono

pero nosotros nos abstraeremos y tomaremos solo las propiedades necesarias para resolver el problema.

Este modelo solo implica propiedades que son necesarias para cumplir con los requerimientos de la

aplicación, por ejemplo el nombre, fecha de nacimiento y el DNI. A estas propiedades se les llama los datos

del modelo ( alumno). Ahora ya se tienen descritas a los alumnos reales por medio de un alumno abstracto.

Definiremos algunas operaciones para manejar los alumnos:

Matricula de un alumno nuevo.

Evaluación del alumno en un curso.

Para resumir, la abstracción es la estructuración de un problema en entidades bien definidas por medio de

la definición de sus datos y operaciones. Entonces, estas entidades combinan datos y operaciones. No

están desacoplados unos de otras.

Propiedades de los Tipos de Datos Abstractos

El ejemplo de la sección anterior muestra que por medio de la abstracción tú creas una entidad bien definida

que puede ser adecuadamente manejada. Estas entidades definen la estructura de datos de un conjunto de

elementos. Por ejemplo para cada alumno del Instituto un nombre, fecha de nacimiento y DNI.

La estructura de los datos puede ser accesada solamente por medio de operaciones definidas. Este

conjunto de operaciones es llamada interface y es exportada por la entidad. Una entidad con las

propiedades recién descritas se conoce como un tipo de datos abstracto (TDA).

Figura 8.2 Un tipo de datos abstracto (TDA)

La Figura 8.2 muestra un TDA que consiste en una estructura de datos abstracta y operaciones. Solamente

las operaciones son visibles desde afuera y definen la interface.

Definición (Tipo de Datos Abstracto) Un tipo de datos abstracto (TDA) se caracteriza por que tiene dos

elementos diferenciados:

La interfaz de utilización.

La representación

La representación debe permanecer oculta y solo utilizaremos sus operaciones para trabajar con los

elementos.

Para construir un tipo abstracto debemos:

1. Exponer una definición de tipo.

2.Definir las operaciones (funciones) que permitan operar con instancias de ese tipo.



TIPO DE DATOS ABSTRACTO

ESTRUCTURA DE DATOS

OPERACIONES CON EL TDA

3.Ocultar la representación de los elementos del tipo de modo que solo se pueda actuar sobre ellos con las

operaciones proporcionadas..

4. Poder hacer instancias múltiples del tipo..

Tipos básicos de operaciones en un TDA.

Las operaciones básicas que deberíamos tener pueden ser:

Constructores: Crean una nueva instancia del tipo.

Transformación: Cambian el valor de uno o más elementos de una instancia del tipo.

Observación: Accesamos sin modificarlos.

Iteradores: Procesa componentes en forma secuencial.

Tipos Genéricos de Datos Abstractos

Los TDAs se usan para definir un nuevo tipo a partir del cual se pueden crear instancias. Como se mostró

en el ejemplo de la lista, algunas veces estas instancias deberían operar del mismo modo sobre otros tipos

de datos. Por ejemplo, uno puede pensar en listas de manzanas, carros o aún listas. La definición

semántica de una lista siempre es la misma. Solamente el tipo de los elementos de datos cambia de

acuerdo al tipo sobre el cuál debía operar la lista..

Esta información adicional podría ser especificada por un parámetro genérico que es especificado al

momento de la creación de la instancia. Así, una instancia de un TDA genérico es en la práctica una

instancia de una variante particular del TDA. Una lista de manzanas puede ser declarada como sigue :

List<Apple> listOfApples;

Los corchetes angulares encierran ahora el tipo de datos para el cuál una variante del TDA genérico List

sería creada. listOfApples ofrece la misma interface que cualquiera otra lista, pero opera en el tipo Apple.

Conceptos de Orientación a Objetos

Las secciones anteriores introducen ya algunos conceptos "de orientación a objetos". Sin embargo, éstos

fueron aplicados de una manera teórica, ahora pasemos ya a visualizar las características del C++ y les

damos nombres tal y como se usan en los lenguajes de programación orientada a objetos existentes.

Las características de C++ como lenguaje orientado a objetos son:

o Abstracción

Variables de instancia

Métodos de instancia

Variables de clase

Métodos de clase

o Encapsulación

De variables: privada, pública y protegida.

De métodos: privada, pública y protegida

o Herencia

Sencilla y múltiple

Unidades genéricas

Polimorfismo

Teniendo en cuenta los conceptos de herencia y Polimorfismo tenemos todo el panorama de la

programación orientada a objetos. La comunicación entre objetos es por medios de mensajes que viene a

ser la forma de invocar a un objeto. Hemos dicho que un objeto tiene características llamadas atributos y



procedimientos llamados métodos. Los mensajes tienen un método (procedimiento) que se ejecutara

cuando es invocado.

Mensaje (Se Invoca Método)

Objeto Emisor Objeto Receptor

Resultado De La Ejecución Del Método Figura 8.3

8.2 Clases.- Un programa utiliza un grupo de objetos y estos objetos se crean utilizando un tipo de dato

denominado clase. Podemos decir que la clase es un registro (struct) evolucionado que ha encapsulado los

datos y las funciones incorporándoles además niveles de visibilidad. En la clase los datos son las

propiedades de la entidad que este representa y las funciones son las tareas representativas de la entidad.

De esta manera las clases representan las entidades del mundo real de una manera más precisas que los

registros. Además las clases tienen dos características que la hacen elementos muy eficientes en la

programación, estas son:

Herencia

Polimorfismo

8.3 Objeto.- Son las instancias de una clase, pues esta es la plantilla que nos permite crear los objetos de

acuerdo a la declaración de clase.

Ejemplo:

Dada la siguiente declaración de clase:

class rectangulo

{ private:

int largo;

int ancho;

public:

void set_largo( int l)

{ largo = l;}

void set_ancho( int a)

{ ancho = a;}

int get_largo( )

{ return(largo);}

int get_ancho( )

{ return(ancho);}

int calcular_ área( )

{ int A;

A = largo * ancho;

return ( A);} };



Representación Gráfica

Clase Rectángulo

Largo Ancho Datos

Métodos

Figura 8.4

Posteriormente nosotros podemos declarar un objeto de la clase rectángulo de la siguiente manera:

rectángulo R1;

Esto significa que R1 tendrá 4 componentes

R1.largo dato miembro de tipo entero.

R1.ancho dato miembro de tipo entero

R1.set_largo(int l) función miembro que nos permite asignar un valor a un dato miembro.

R1.set_ancho(int a) función miembro que nos permite asignar un valor a un dato miembro.

R1.get_largo( ) función miembro que nos permite devolver valor de dato miembro

R1.get_ancho( ) función miembro que nos permite devolver valor de dato miembro

R1.calcular_area( ) función miembro que calcula el área y devuelve el valor.

PROGRAMA

/* CODIGO: POOC8E1


OBJETIVO: Desarrollar un ejemplo básico de POO */


#include<conio.h>

class rectangulo

{ private:

int largo;

int ancho;

public:


{ largo = l;}


{ ancho = a;}

int get_largo( )

{ return(largo);}

int get_ancho( )

{ return(ancho);}

int calcular_area( )


Set_largo

Calcular _area


Set_ancho

{int A;

A = largo * ancho;

return ( A); }

};

void main()

{ int L,A;

rectangulo r1;

clrscr();

cout<<"Ingrese largo: ";cin>>L;

cout<<"Ingrese ancho: ";cin>>A;

r1.set_largo(L);

r1.set_ancho(A);

cout<<"El área es : "<<r1.calcular_area();

getch(); }

EJECUCION

8.4 Herencia: Característica mediante la cual podemos reutilizar una declaración de una clase y crear otra clase.

Por ejemplo:

Creamos la clase estudiante.a clase estudiante_universitario hereda de la clase estudiante y adiciona.

La clase estudiante_universitario_uni hereda de la anterior y también adiciona.Ver ejemplo 4.

8.5 Polimorfismo: Característica que nos permite crear funciones que utilizando un mismo nombre responderán

de forma diferente de acuerdo a la clase a la cual pertenecen. Por ejemplo: Dada la siguiente declaración de

claseen el ejemplo 2:

PROGRAMA

/* CODIGO: POOC8E2


OBJETIVO: Desarrollar un ejemplo básico de POO */


#include<conio.h>

class rectangulo

{ private:

int largo;

int ancho;

public:


{ largo = l;}


{ ancho = a;}

int get_largo( )

{ return(largo);}

int get_ancho( )

{ return(ancho);}



int area( )

{ int A;

A = largo * ancho;

return ( A); }

};

class cuadrado

{ private:

int lado;

public:

void set_lado( int l)

{ lado = l;}

int get_lado( )

{ return(lado);}

int area( )

{ int A;

A = lado * lado;

return ( A);

} };

void main( )

{ rectangulo R1;

cuadrado C1;

R1.set_largo( 5);

R1.set_ancho( 4);

C1.set_lado(4);

clrscr();

cout << R1.area( )<<endl;

cout << C1.area( )<<endl;

getch(); }

EJECUCION

Ventajas de la programación orientada a objetos.- Son las siguientes:

Facilidad de Mantenimiento: Los programas son más fáciles de leer y de entender.

Facilidad de modificación: Se pueden modificar los objetos al modificar rápidamente la herencia.

Reusabilidad: Se pueden utilizar varias veces.

Fiabilidad: Se utilizan modelos ya comprobados.

PROBLEMAS

1.- Desarrollar 3 programas de aplicación para ver la evolución desde la primera etapa de registro (struct) hasta el

objeto. Los programas son:

A) Programa con registros lee 2 notas y calcula el promedio con una función externa al registro.

B) Programa con registros lee 2 notas y calcula el promedio con una componente función.

C) Programa con objetos lee 2 notas y calcula el promedio con una función miembro.

PROGRAMA(A)



/* CODIGO: POOC8PROB1A


OBJETIVO: Primer programa ejemplo de una estructura clásica*/


#include<conio.h>

struct notas

{ float nota1;

float nota2; };

float calcula_prom (float p1, float p2);

void main ( )

{notas n;

clrscr( );

cout << "ingrese 1ra. Nota => "; cin >> n.nota1;

cout << "ingrese 2da. Nota => "; cin >> n.nota2;

cout << " El promedio es = " << calcula_prom ( n.nota1, n.nota2);

getch( ); }

float calcula_prom (float p1, float p2)

{ float prom ;

prom = (p1 + p2)/2.0;

return(prom); }

EJECUCION

PROGRAMA(B)

/* CODIGO: POOC8PROB1B


OBJETIVO: Segundo programa ejemplo tenemos la estructura pero ya tenemos una componente función miembro de la estructura y por lo

tanto ya tiende a una clase*/


#include<conio.h>

struct notas

{ float nota1;

float nota2;

float calcula_prom (float p1, float p2)

{ return( (p1 + p2) / 2.0); }

};

void main ( )

{ notas n;

clrscr( );

cout << "ingrese 1ra. Nota => ";

cin >> n.nota1;

cout << "ingrese 2da. Nota => ";



cin >> n.nota2;

cout << " El promedio es = " << n.calcula_prom ( n.nota1, n.nota2);

getch( );

}

EJECUCION

PROGRAMA(C)/* CODIGO: POOC8PROB1C


OBJETIVO: Tercer programa realiza lo mismo que los anteriores pero usando clases y objetos*/


# include<conio.h>

class notas

{ private:

float nota1;

float nota2;

public:

void set_nota1(float n1)

{ nota1 = n1; }

void set_nota2(float n2)

{ nota2 = n2; }

float calcula_prom ( )

{ return( (nota1 + nota2) / 2.0); }

};

void main ( )

{ float a1, a2;

notas n;

clrscr( );

cout << "ingrese 1ra. Nota => "; cin >> a1;

cout << "ingrese 2da. Nota => "; cin >> a2;

n.set_nota1( a1);

n.set_nota2( a2);

cout << " El promedio es = " << n.calcula_prom ( );

getch( ); }

EJECUCION

2.- Escriba un programa que defina la clase cuadrado y cubo además debe calcular el área del cuadrado, el área del

cubo y el volumen.



SOLUCIÓN

PROGRAMA



OBJETIVO: Programa que define la clase cuadrado y cubo, calculando el área del cuadrado, el área del cubo y el volumen. */


#include<conio.h>

class cuadrado

{ private:

int lado;

public:

void set_lado( int l )

{ lado = l; }

int area( )

{ int A;

A = lado * lado;

return ( A); } };

class cubo

{ private:

int lado;

public:

void set_lado( int l )

{ lado = l; }

int area( )

{ int A;

A = 6*lado * lado;

return ( A); }

int volumen( )

{ int A;

A = lado*lado * lado;

return ( A); } };

void main( )

{ cuadrado C1;

cubo C2;

int LADO;

clrscr();

cout<< "Ingrese Lado del cuadrado: ";

cin>> LADO;

C1.set_lado(LADO);

cout<< "Ingrese Lado del Cubo: ";

cin>> LADO;

C2.set_lado(LADO);

cout<<"Resultados del Cuadrado: "<<endl;

cout<<" Area = "<<C1.area()<<endl;

cout<<"Resultados del Cubo: "<<endl;



cout<<" Area = "<<C2.area()<<endl;

cout<<" Volumen = "<<C2.volumen()<<endl;

getch(); }

EJECUCION


1) Escribir un programa que me permita crear la clase persona, considerando, dni,nombre, fecha de nacimiento ,

distrito donde vive y teléfono. El programa debe crear la clase y declarando objetos de esta clase ingreasr

datos y después mostrarlos.

2) Escribir un programa que considere la clase anterior y declare un vector de objetos de esa clase, además

debe poder consultar este vector de objetos y listar los dni y nombres que viven en un determinado distrito.

3) Se tiene la clase empleado con código, sueldo, nombre y categoría, escribir las declaraciones de datos

miembros y crear las funciones miembro, de lectura, mostrar_datos y asignación de sueldos, esta ultima debe

realizarse de la siguiente manera:

Categoría A sueldo de 4500 mensual

Categoría B sueldo de 4000 mensual

Categoría C sueldo de 3000 mensual

Categoría D sueldo de 2000 mensual

4) Escriba un programa que trabaje con la clase anterior pero con vectores de objetos y que visualize todos los

empledaos por categoría..

5) Escriba un programa que me permita ingresar varios cursos creando la clase curso y finalmente me entrege

un listado. La clase curso debe considerar código, nombre, costo y duración en horas.



CAPITULO IX

9 CLASES Y CONSTRUCTORES.-

9.1 SECCIONES Y FUNCIONES MIEMBRO

9.1.1 Secciones.- Los miembros de una clase que son variables y métodos (datos y funciones) pueden ser

públicos (public), protegidos (protected) y privados (private). Las secciones privadas y protegidas tienen

como objetivo el ocultamiento de datos. A los miembros de la sección privada se puede acceder solo por

las funciones miembro de esa clase, o por otras funciones declaradas amigas (friend) de la clase. A los

miembros públicos de una clase se pueden acceder desde fuera de la clase, pero no se puede acceder

desde una clase derivada de la clase base. Los miembros protegidos son accesibles dentro de la clase en

que estén definidas y en cualquier clase derivada de la clase original. De acuerdo a lo dicho la

declaración de una clase en forma general será:



class nombre_clase{

private: datos miembro funciones miembro

9.1.2 Funciones miembro.- Las funciones miembro con componentes de una clase y normalmente se

definen dentro de la clase como funciones de línea(inline). Pero también podemos definir el cuerpo de

la función fuera de la clase. El ámbito de una función se debe indicar por el operador ámbito (:: ) con el

nombre de la clase. Ej:

PROGRAMA

/* CODIGO: POOC9E1


OBJETIVO: Programa de funciones que utilizan el operador de ambito */


#include <conio.h>

class nota

{ private:

int practica1;

int practica2;

public:

void set_practica1( int p1);

void set_practica2( int p2);

float promedio( ); };

void nota :: set_practica1( int p1) { practica1 = p1;}

void nota :: set_practica2( int p2) { practica2 = p2;}

float nota :: promedio(void)

{ return ((practica1+practica2)/2.0); }

void main ( )

{ int prac1, prac2;

nota practicas;

clrscr( );

cout<< "Primera practica: "; cin >>prac1;

cout<< "Segunda practica: "; cin >>prac2;

practicas.set_practica1(prac1);

practicas.set_practica2(prac2);

cout << " El promedio sera = "<< practicas.promedio( );

getch();}

EJECUCION



class nombre_clase{

protected: datos miembro protegidos funciones miembro protegidos

public: datos miembro publicos funciones miembro publicos

9.2 Constructores y Destructores.- Cuando se menciono a los punteros se dijo que se puede crear

variables apuntadas en forma dinámica (en ejecución), para crear estas se utiliza el operador new y para

liberarlas el operador delete, en la POO existen mecanismos similares. Cuando se crea un objeto es

llamado un método que se denomina constructor y al terminar (salir) se llama a otro método conocido

como destructor.

9.2.1 Constructor.- Es un método especial que construye objetos. Un constructor es llamado para crear

una instancia de ese objeto asignando espacio a un objeto pude también asignar valores a sus miembros

datos. El constructor realiza una inicialización automática y no devuelve ningún valor. Tiene el mismo

nombre que la clase con la cual está asociada. Puede tener parámetros como cualquier otra función y tener

por lo tanto distintas formas. Si no se define para una clase, el compilador generara un constructor por

defecto.

Ejemplo:

class circulo { private:

int c_x, c_y;

double radio;

public:

// constructor

circulo( int x, int y, double r)

{ radio = r;

c_x = x;

c_y = y; }

};

Tipos de constructores: Los constructores pueden ser:

Constructores sin argumento

Constructores con argumento

Constructores de copia

Esto lo veremos en el ejemplo:

class nota

{ private : int dato;

public:

nota( )

{ }

nota(int d )

{ dato = d; }

nota( nota&y )

{ dato = y.dato; }

};

Ejemplo 2.- De un ejemplo de constructores con la estructura indicada



PROGRAMA

/* CODIGO: POOC9E2


OBJETIVO: Programa que muestra los diferentes tipos de constructores*/


#include<conio.h>

#include<stdio.h>

#include<string.h>

class nota

{ private : int dato;

public:

nota( ) { } //CONSTRUCTOR SIN ARGUMENTOS

nota(int d )//CONSTRUCTOR CON ARGUMENTOS

{ dato = d; }

nota( nota&y )//CONSTRUCTOR DE COPIA

{ dato = y.dato; }

void set_dato(const int val){dato=val;}

int get_dato() { return dato; }

};

void main()

{ nota d1, d2(5), d3(d2);

d1.set_dato(7);

cout<<"dato1 = "<<d1.get_dato()<<endl;



getch(); }

EJECUCION

Destructores: Un destructores lo opuesto a un constructor, así como el constructor separa memoria, el

destructor libera esa memoria que fue asignada al objeto por el constructor. El destructor es una función

miembro con el mismo nombre que la clase mas una tilde que se añade al principio. Una clase puede poseer

un destructor que no tiene argumentos y no devuelve valores. Ejemplo:

class punto

{ private :

int x;

int y;

public:

punto( )

{

x= 0;

y = 0



}

~punto( )

{ }

};

Ejemplo 3.- De un ejemplo de constructores y de destructores, definiendo la

clase complejo , que tiene componente real y componente imaginaria.

PROGRAMA

/* CODIGO: POOC9E3


OBJETIVO: Programa que muestra los diferentes tipos de constructores y el destructor */


#include<conio.h>

#include<string.h>

class complejo

{ private:

int r, i;

public:

complejo()//constructor sin argumentos

{ r = i = 0; }

complejo(const int re, const int im)//constructor con argumentos

{ r = re;

i = im; }

complejo(const complejo &comp)//constructor de copia

{ r = comp.r;

i = comp.i; }

~complejo() { cout<<"El destructor ha sido llamado"<<endl;getch(); }//destructor

int get_r() { return r; }

int get_i() { return i; }

};

void main()

{complejo c1(5,7);

complejo c2;

complejo c3(c1);

cout<<"Parte real de c1= "<<c1.get_r()<<endl;

cout<<"Parte imaginaria de c1= "<<c1.get_i()<<endl;

cout<<"Parte real de c2= "<<c2.get_r()<<endl;

cout<<"Parte Imaginaria de c2= "<<c2.get_i()<<endl;

cout<<"Parte Real de c3= "<<c3.get_r()<<endl;

cout<<"Parte Imaginaria de c3= "<<c3.get_i()<<endl;

getch(); }

EJECUCION



Constructor new y destructor delete Estos dos operadores también construyen y destruyen, que es una

forma de decir también reservan y liberan memoria.

El operador new obtiene memoria del sistema operativo, y proporciona un puntero a su punto inicial. Su

sintaxis es: tipo *p ;

p = new tipo;

El operador delete libera memoria reservada con new

Ejemplo 3: Manejo de new y delete

PROGRAMA

/* CODIGO: POOC9E4

FECHA: 23 DE 2013

OBJETIVO: Programa ejemplo de new y delete */


#include <conio.h>

void main( )

{int *p1, *p2;

p1 = new int;//asigna la dirección de un campo entero a p1 que es puntero

cout << " Ingrese valor = > ";

cin >> (*p1);// almacena un valor en el campo apuntado por p1

p2=p1;//p2 toma la dirección de p1

p1 = new int;

cout << " Ingrese valor = > "; cin >> (*p1);// almacena un valor en el campo apuntado por p1

cout<<(*p1)<<endl;

cout<<(*p2)<<endl;

delete p1;//libera memoria de p1

delete p2;//libera memoria de p2

getch ( );}

EJECUCION

Analizando el ejemplo que hemos ejecutado:

Primero: podemos ver que el operador new busca un campo o estructura del tipo indicado, en nuestro caso

entero y cuando lo encuentra asigna la dirección al puntero respectivo y después bloquea el acceso de otra

variable a ese campo,

Segundo: el campo no tiene nombre propio sino que se le llama campo apuntado por, en nuestro caso, p1 y esto

se indica con *p1.



Tercero: El intercambio de información puede ser de puntero a puntero (p2=p1) o de campo apuntado a campo

apuntado (*p1) = (p2), sería un error lo siguiente: p1 = *p2.

Cuarto: La forma correcta de liberar a la memoria es delete p1 o delete p2.

PROBLEMAS

1.- Desarrollar un programa que maneje la clase empleado utilizando funciones fuera de la clase y que nos permitan

manejar el operador ámbito. La clase empleado tendrá los siguientes datos miembro y las funciones indicadas.

class empleado

{ private:

int codemp;

char nomemp[40];

float hotemp;

float phoemp;

float pagemp;

public:

void ingreso_datos( int c, char[40], flota h, flota p);

float pago_neto( );

};

SOLUCION

PROGRAMA



OBJETIVO: Programa que calcula pagos considerando funciones construidas fuera

de la clase pero que trabajan con el operador ámbito :: */


#include <conio.h>

#include <string.h>

#include <stdio.h>

class empleado

{ private:

int codemp;

char nomemp[40];

float hotemp;

float phoemp;

float pagemp;

public:

void set_codemp( int c);

void set_nomemp( char n[40]);

void set_hotemp( float h);

void set_phoemp( float p);

float pago_neto( ); };

void empleado::set_codemp( int c)

{ codemp=c; }

void empleado::set_nomemp( char n[40])

{ strcpy(nomemp,n); }



void empleado::set_hotemp( float h)

{ hotemp=h; }

void empleado::set_phoemp( float p)

{ phoemp=p; }

float empleado::pago_neto( )

{ return ((hotemp*phoemp)*0.89);}//considerando un 11% de descuento

void main()

{ int codigo;

char nombre[40];

float horas_trabajadas;

float pago_hora;

float sueldo_neto;

empleado emp1;

clrscr();

cout<<"Ingrese codigo del trabajador --> "; cin>>codigo; emp1.set_codemp(codigo);

cout<<"Ingrese nombre del trabajador --> "; gets(nombre); emp1.set_nomemp(nombre);

cout<<"Ingrese Horas trabajadas --> "; cin>>horas_trabajadas;emp1.set_hotemp( horas_trabajadas);

cout<<"Ingrese Pago por Hora --> "; cin>>pago_hora; emp1.set_phoemp(pago_hora);

sueldo_neto= emp1.pago_neto();

cout<<"Neto a pagar = "<<sueldo_neto;

getch(); }

EJECUCION

2.- Desarrollar un programa que maneje constructores y destructores de la clase caja que tiene las características

indicadas.

class caja

{ private:

int alto;

int ancho;

int largo;

public: …………………..

SOLUCION

PROGRAMA



OBJETIVO: Programa que maneja constructores de la clase caja. */




#include <conio.h>

class caja

{ private:

int alto;

int ancho;

int largo;

public:

// constructor

caja ( int al, int an, int l) { alto = al; ancho = an; largo = l; }

// destructor

~caja ( ) { }

// función inline

int volumen ( ) { return ( alto*ancho*largo); }

};

void main ( )

{ caja caja1(2,3,4);

caja caja2(5,6,7);

clrscr( );

cout << "El volumen de la primera caja sera => " << caja1.volumen( )<<endl;

cout << "El volumen de la segunda caja sera => " << caja2.volumen( )<<endl;

getch( ); }

EJECUCION

3.- Desarrollar un programa que trabaje con aritmetica de punteros y maneje polinomios pudiendo desarrollar

operaciones simples con estos polinomios.

SOLUCION

PROGRAMA



OBJETIVO: Programa que maneja la Aritmética de punteros*/


#include<conio.h>

#include<math.h>

void main( )

{ int a[10],b[10],n,i;

float pola,polb,x;

int *p1,*p2;

clrscr( );

cout<<"Ingrese valor n: ";cin>>n;

for(i=1;i<=n;i++)



{ cout<<"Ingrese valor de a["<<i<<"]= ";cin>>a[i];

cout<<"Ingrese valor de b["<<i<<"]= ";cin>>b[i]; }

cout<<"Ingrese x: ";cin>>x;

p1=&a[1];

p2=&b[1];

//hallando polinomios

pola=0;

polb=0;

for(i=1;i<=n;i++)

{ pola=pola+(*p1)*pow(x,n+1-i);

polb=polb+(*p2)*pow(x,n+1-i);

p1++; //en aritmética de punteros se asigna p1++ para

p2++; } //suma 1 CAMPO!! al puntero no una unidad

cout<<pola<<endl;

cout<<polb<<endl;

cout<<pola+polb;

getch(); }

EJECUCION

CAPITULO X



10. CLASES DERIVADAS

10.1. Definición.- La forma sintáctica para indicar que una clase es derivada de otra clase existente será:

class nombre_clase: [(public| private)] clase_base

{

declaraciones de miembros

};

La palabra reservada class puede ser sustituida por la palabra reservada struct, con la implicación de que

los miembros son públicos por defecto.

Una de las dos palabras, public y private, en la clase derivada son opcionales, para especificar como los

miembros de la clase base tienen que ser accesibles a la clase derivada:

10.2. Clases derivadas: Mediante la propiedad de la herencia podemos derivar una clase de otra ya

existente. Podemos entonces indicar que las clases derivadas heredan los miembros de las clases que

les dan origen, a estas últimas se les llama clases bases

Ejemplo 1:

class persona // CLASE BASE

{ protected:

char nombre[30];

char dni[9];



public:

void set_nombre (char n[30])

{ strcpy (nombre, n); }

void set_dni ( char d[9])

{ strcpy (dni, d); }

char* get_nombre ( )

{ return(nombre);}

char* get_dni ( )

{ return(dni);}

};

class empleado : public persona // CLASE DERIVADA

{ private:

int codigo;

float sueldo;

public:

void set_codigo( int c)

{ codigo = c; }

void set_sueldo(float s)

{ sueldo = s; }

int get_codigo()

{ return (código);}

float get_sueldo { return(sueldo);}

};

10.3. Herencia múltiple.- Este concepto nos indica que una clase puede derivarse de más de una clase,

un ejemplo es el siguiente:

class base1

{ protected:

int dato1;

public:

void set_dato1 (int d1)

{ dato1 = d1; }

};

class base2

{ private:

int dato2;

public:

void set_dato2 (int d2)

{ dato2 = d2; }

int get_dato2 ( )

{ return(dato2); }

};

class derivada12 : public base1, private base2

{ public:

void imprimir ( )

{ cout << b1<<get_dato2( ); }

};



10.4. Funciones amigas (friend)

Sabemos que a un dato privado se puede acceder desde la misma clase o desde una función amiga. El

concepto de función amiga se refiere a una función que no es miembro de esa clase, pero que necesita

acceder a los miembros privados de una clase. Estas se declaran colocando su prototipo en la clase que

son amigas, indicando esto don la palabra reservada friend.

class empleado

{ private:

int code;

char nombre[40];

float sueldo;

public:

friend void planilla (empleado e1, int valor); };

void planilla (empleado e1, int valor)

{ e1.code =.....;

e1.sueldo; }

10.5. Funciones virtuales.- Esta característica permite a una función estar definida en una clase base y

su clase derivada bajo el mismo nombre.

La declaración de virtual solo debe hacerse en la clase base, la función será llamada de acuerdo al objeto al

cual está asociada.

class cuadrado

{ protected:

int lado;

public:

virtual int área ( )

{ return (lado * lado); }

};

class cubo: public cuadrado

{ public:

int área ( )

{ return ( 6 * lado * lado); } };

PROBLEMAS

1.- Construya un programa orientado a objetos que utilice la clase base persona, con su datos miembro nombre y

DNI, además de considerar las funciones miembro asignar y mostrar; derivada de esta clase se manejara la clase

empleado que añade datos miembro código y sueldo, y redefina las funciones de la clase base.

SOLUCION

PROGRAMA



OBJETIVO: Programa que declara la clase empleado que es derivada de la clase base persona*/


#include<conio.h>

#include<string.h>

#include<stdio.h>

class persona // CLASE BASE



{ protected:

char nombre[30];

char dni[9];

public:

void set_nombre (char n[30])

{ strcpy (nombre, n); }

void set_dni ( char d[9])

{ strcpy (dni, d); }

char* get_nombre ( )

{ return(nombre);}

char* get_dni ( )

{ return(dni);} };

class empleado : public persona // CLASE DERIVADA

{ private:

int codigo;

float sueldo;

public:

void set_codigo( int c)

{ codigo = c; }

void set_sueldo(float s)

{ sueldo = s; }

int get_codigo()

{ return (codigo);}

float get_sueldo( ) {return(sueldo);} };

void main ( )

{ persona p1;

empleado e1;

char name[30];

char di[9];

int code;

float sb;

clrscr( );

cout << " Ingrese Nombre => "; gets(name);

cout << " Ingrese DNI => "; cin >> di;

p1.set_nombre( name);

p1.set_dni( di);

cout << " Ingrese Nombre => "; gets(name);

cout << " Ingrese DNI => "; cin >> di;

cout << " Ingrese Codigo => "; cin >> code;

cout << " Ingrese sueldo bruto => "; cin >> sb;

e1.set_nombre( name);

e1.set_dni( di);

e1.set_codigo( code);

e1.set_sueldo( sb);

cout<<"Nombre: "<< p1.get_nombre( )<<endl;

cout<<"DNI : "<<p1.get_dni( )<<endl;



cout<<"Nombre: "<< e1.get_nombre( )<<endl;

cout<<"DNI : "<<e1.get_dni( )<<endl;

cout<<"Nombre: "<< e1.get_codigo( )<<endl;

cout<<"DNI : "<<e1.get_sueldo( )<<endl;

getch( ); }

EJECUCION

2.- Escriba un programa que simule un procesamiento de notas con dos sistemas de evaluación diferentes, el sistema

A : promedio de prácticas = (p1+p2+p3)/3.0. Nota final = (exapar + exafin + propra)/3.0 y el sistema B :

promedio de prácticas = (p1+p2+p3+p4)/4.0; Nota final = (exapar + 2*exafin +2* propra)/5.0.

Use clases derivadas para este fin.

SOLUCION:

PROGRAMA



OBJETIVO: Programa que trabaja con dos clases derivadas simulando dos sistemas de evaluacion de notas*/


#include<conio.h>

#include<stdio.h>

#include<string.h>

#include<ctype.h>

class notas

{ protected:

char code[10];

char name[40];

int exapar;

int exafin ;

float propra;

float notafin;

public:

void set_code( char c[10]) { strcpy(code, c); }

void set_name(char n[40]) { strcpy( name,n); }

void set_exapar( int ep) { exapar = ep; }

void set_exafin( int ef) { exafin = ef; }

char* get_codigo( ) { return(code); }

char* get_name( ) { return(name); }



int get_exapar( ) { return(exapar); }

int get_exafin( ) { return(exafin); }

float get_propra( ) { return(propra); }

float get_notafin( ) { return(notafin); }

};

class sistemaA : public notas

{ public:

int p1, p2 , p3;

public :

void calcula_notafin ( )

{ propra = (p1+p2+p3)/3.0;

notafin = (exapar + exafin + propra)/3.0; }

};

class sistemaB : public notas

{ public:

int p1, p2 , p3, p4;

public :

void calcula_notafin ( )

{ propra = (p1+p2+p3+p4)/4.0;

notafin = (exapar + 2*exafin +2* propra)/5.0; }

};

void main ( )

{ char a1[10]; // almacena código

char a2[40]; //almacena nombre

int a3; //almacena examen parcial

int a4; //almacena examen final

char sistema;

sistemaA al1;

sistemaB al2;

clrscr( );

gotoxy(30,3);cout<<"INGRESO DE DATOS";

gotoxy(31,6);

cout<< " CODIGO : "; cin >> a1;

gotoxy(31,8);

cout<< " NOMBRE : "; gets(a2);

gotoxy(31,10);

cout<< " Examen Parcial : "; cin >> a3 ;

gotoxy(31,12);

cout<< " Examen Final : "; cin >> a4;

gotoxy(31,14);

cout<< " Sistema de evaluación A/B: "; cin >> sistema;

sistema = toupper( sistema);

// calculo de promedio de prácticas y nota final

if ( sistema == 'A')

{ cout << " Practica 1 : "; cin>>al1.p1;

cout << " Practica 2 : "; cin>>al1.p2;




al1.set_code(a1);

al1.set_name(a2);

al1.set_exapar(a3);

al1.set_exafin(a4);

al1.calcula_notafin( );

cout<<”Promedio Practicas = “<< al1.get_propra( )<<endl;

cout<<”Nota Final = “<< al1.get_notafin( )<<endl;getch();}

if ( sistema == 'B')

{ cout << " Practica 1 : "; cin>>al2.p1;




al2.set_code(a1);

al2.set_name(a2);

al2.set_exapar(a3);

al2.set_exafin(a4);

al2.calcula_notafin( );

cout<<”Promedio Practicas = “<< al2.get_propra( )<<endl;

cout<<”Nota Final = “<< al2.get_notafin( )<<endl;getch();} }

EJECUCION

3.- Desarrolle un programa que nos muestre claramente el concepto de Herencia múltiple, esto debe hacerlo

derivando una nueva clase de dos clases bases.

SOLUCION:

PROGRAMA



OBJETIVO: PROGRAMA QUE TRABAJA CON HERENCIA DE DOS CLASES BASES */


#include<conio.h>



#include<stdio.h>

#include<string.h>

class alumno

{ protected:

char codalu[10];

char nomalu[40];

};

class curso

{ protected:

char codcur[7];

char nomcur[30];

float notcur;

};

class matricula: public alumno, public curso

{ private:

float pagoma;

int ok;//1 matriculado 0 no matriculado

public:

void asignar( char ca[10], char na[40],char cc[7], char nc[30],float nt, float pm, int sm)

{strcpy(codalu,ca);

strcpy(nomalu,na);

strcpy(codcur,cc);

strcpy(nomcur,nc);

notcur =nt;

pagoma=pm;

ok=sm;

}

void mostrar()

{ clrscr();

gotoxy(30,2); cout<< "DATOS DE MATRICULA ";

gotoxy(31,6); cout<< "Codigo : "<<codalu;

gotoxy(31,8); cout<< "Nombre : "<<nomalu;

gotoxy(31,10); cout<< "Cod. Curso : "<<codcur;

gotoxy(31,12); cout<< "Curso : "<<nomcur;

gotoxy(31,14); cout<< "Nota : "<<notcur;

gotoxy(31,16); if (ok ==1)

cout<<"MATRICULADO";

else

cout<<"MATRICULA PENDIENTE";

getch();

}

};

void main ( )

{ matricula alu1;

char codigo[10],nombre[40], ccurso[7],ncurso[30];



float nota,pago;

int sm;

clrscr();

//Ingreso de Datos

gotoxy(30,2); cout<<"INGRESO DE DATOS";

gotoxy(31,6); cout<<"CODIGO : ";gets(codigo);

gotoxy(31,8); cout<<"NOMBRE : ";gets(nombre);

gotoxy(31,10); cout<<"COD. CURSO : ";gets(ccurso);

gotoxy(31,12); cout<<"CURSO : ";gets(ncurso);

gotoxy(31,14); cout<<"NOTA : ";cin>>nota;

gotoxy(31,16); cout<<"PAGO : ";cin>> pago;

gotoxy(31,18); cout<<"MATRICULA SI=1 NO=0 : ";cin>>sm;

alu1.asignar(codigo,nombre,ccurso,ncurso,nota,pago,sm);

alu1.mostrar();

}

EJECUCION

4.- Escribir un programa que maneje el concepto de funciones amigas:

SOLUCION:

PROGRAMA



OBJETIVO: PROGRAMA QUE TRABAJA CON FUNCIONES AMIGAS */


#include<conio.h>

#include<string.h>

class empleado

{ private:

char nombre[20];

int codigo;

public :

empleado( char *nomb, int cod) // constructor

{ strcpy (nombre,nomb);



codigo = cod; }

friend void imprime_dat_emp(empleado c); // declaración de función amiga

} ;

void imprime_dat_emp(empleado c)

{ cout << "Nombre del cliente : " << c.nombre<< endl;

cout << "Codigo del cliente : " << c.codigo << endl; }

void main ( )

{clrscr( );

empleado Perez ("Juan Perez", 1111);

imprime_dat_emp(Perez);

empleado Rosas ("Néstor Rosas", 2222);

imprime_dat_emp(Rosas);

getch( ); }

EJECUCION



CAPITULO XI



11. POLIMORFISMO Es la capacidad de los objetos de responder de manera diferente a las mismas ordenes,

dependiendo a la clase a la cual pertenecen. El Polimorfismo se implementa de dos maneras:

Vía funciones virtuales

Por sobrecarga.

11.1. VIA FUNCIONES VIRTUALES El concepto de función virtual ya lo vimos anteriormente, veamos

ahora un ejemplo

Ejemplo:

/ * Ejemplo de Polimorfismo con funciones virtuales * /


# include<conio.h>

class figura

{ protected:

float par1;

public:

void asignar ( float p1)

{

par1 = p1;

}

virtual float area( )

{ return (0);}

};

class circulo : public figura

{ public:


{ return (3.1416*par1*par1);}

};

class cuadrado : public figura

{ public:


{ return (par1*par1);} };

11.2. SOBRECARGA DE OPERADORES Y FUNCIONES

11.2.1. Introducción.- La sobrecarga de operadores, nos permite definir un operador de diferente

forma, es una forma de realizar el Polimorfismo. La sobrecarga es la técnica de redefinir un existente para

que trabaje con otro tipo de datos. Como sabemos no podemos crear un operador nuevo pero aquellos

que ya existen podemos sobrecargarlos.

11.2.2. Sobrecarga de Operadores.- Un operador puede ser sobrecargado. Los operadores

sobrecargados cumplen las siguientes propiedades.

Sobrecargados, no cambiaran su número de operandos (unitarios o binarios).

Sobrecargados, no cambiaran su prioridad.

No se pueden inventar operadores que no existan en C++.



La palabra reservada operator.- Para hacer que un operador de C++ actúe como un operador definido por

el usuario, se debe utilizar la palabra reservada operator. El formato de sobrecarga es:

Tipo operator <op> ( lista de argumentos)

Los operadores que se pueden sobrecargar son:

Operadores Unarios.

Operadores Binarios.

Operadores De Asignación

Además de los operadores: , (coma), new y delete

Ejemplo de sobrecarga.-


#include <conio.h>

class duplicado

{public:

int x;

duplicado operator++ ()

{ x = x + x; return *this; }

};



Operador * (Indireccion) Operador -> (Indireccion) Operador + Operador - Operador ++ Operador --

Operador + Operador - Operador * Operador / Operador % Operador << Operador >> Operador & Operador ^ Operador | Operador [] Operador ()

Operador = Operador += Operador -= Operador *= Operador /= Operador %= Operador <<= Operador >>= Operador &= Operador ^=| Operador |=

void main () { // (Comprobación)

duplicado e1 = {5}, e2;

e2 = ++e1; // M.2 uso de operador ++ sobrecargado

cout << "e1 == " << e1.x << endl;

cout << "e2 == " << e2.x << endl;

getch(); }

11.2.3. Sobrecarga de funciones.- Cuando una función tiene más de una definición decimos que es una

función sobrecargada. Sabemos que dos o más funciones pueden tener el mismo nombre pero para estar

sobrecargadas no deben diferir en el tipo de sus argumentos o el número de sus argumentos.

Es muy importante considerar que bastante común es sobrecargar las funciones constructoras.

Ejemplo de sobrecarga de funciones

PROBLEMAS

1.- Construya un programa orientado a objetos desarrolle el polimorfismo utilizando el concepto de función virtual.



/ * Ejemplo de sobrecarga de funciones * /


# include<conio.h>

class vector

{ private:

float xm, ym;

public:

vector ( float x = 0, float y = 0)

{ xm = x;

ym = y; }

void vervector ( );

void leervector ( float &x, float &y)

{ x = xm;

y = ym; }

};

void vector :: vervector( )

{ cout << xm << “ “ <<ym<<endl; }

vector operator+ ( vector &a, vector &b)

{ float xa, ya, xb, yb;

leervector (xa, ya);

leervector (xb, yb);

return vector ( xa+ xb, ya+ yb); }

void main ( )

{ vector u(3,1), v(4,2),s;

s = u + v;

s.vervector ( ); // debe salir 7,3

getch(); }

SOLUCION

PROGRAMA



OBJETIVO: Ejemplo de Polimorfismo con funciones virtuales */


#include<conio.h>

class figura

{ protected:

float par1;

public:

void set_par1( float p1)

{ par1 = p1; }


{ return (0) ; } };

class circulo : public figura

{ public:


{ return (3.1416*par1*par1); } };

class cuadrado : public figura

{ public:


{ return (par1*par1); } };

void main ( )

{ circulo cir1;

cuadrado cua1;

float a1;

clrscr();

cout<<"Ingrese radio circulo=> "; cin>> a1;

cir1.set_par1(a1);

cout<< " Área = "<< cir1. area()<< endl;

cout<<"Ingrese lado cuadrado=> "; cin>> a1;

cua1.set_par1(a1);

cout<< " Area = "<< cua1. area();

getch(); }

EJECUCION

2.- Construya un programa que sobrecargue un operador realizando una operación para un objeto.

SOLUCION

PROGRAMA


FECHA: 23 DE MARZO



OBJETIVO: Sobrecarga de operadores es la facultad que tiene un operador de funcionar de forma diferente según el tipo de dato con el que

se utilice,es decir, hacer que el operador funcione con los datos que el usuario cree.

En el cuerpo de la función habrá que poner las operaciones que queramos que realice el operador */


#include<conio.h>

class clase

{ int x,y;

public:

clase(int x=0,int y=0);

clase operator +(clase &);

void visualizar( );

~clase(){cout<<"\nDestruyendo el Objeto ";}

};

clase ::clase(int m,int n)

{ x=m;y=n;}

clase clase::operator +(clase &obj) //pasa un objeto de tipo clase

{ clase aux;

aux.x=x+obj.x; //x del objeto más x que pasa

aux.y=y+obj.y;

return(aux); }

void clase::visualizar()

{ cout<<"\nx= "<<x<<' '<<"y= "<<y; }

main( )

{ clase a(5,7); clase b(3,4); clase c;

c=a+b; //x de a más x de b ; y de a más y de b

c.visualizar( ); //c=operator +b;

getch(); }

EJECUCION

3.- Construya un programa que sobrecargue una función utilizando dos tipos de datos diferentes, la función debe ser

simple.

SOLUCION

PROGRAMA



OBJETIVO: Función fecha recargada */


#include<conio.h>

#include<stdio.h>

void fecha(char *fecha);



void fecha(int anno,int mes, int dia);

void main()

{ clrscr();

fecha("20/3/2007");

fecha(07,3,21);

getch(); }

void fecha(char *fecha)

{cout <<"Fecha: "<<fecha<<endl;}

void fecha(int anno,int mes, int dia)

{cout<<"Fecha: "<<dia<<"/"<<mes<<"/"<<anno;}

EJECUCION

4.- Construya un programa que sobrecargue un constructor y que nos permita inicializar un arreglo y otro constructor

que no inicialice

SOLUCION

PROGRAMA



OBJETIVO: Vamos a trabajar sobrecargando un constructor para permitir que tanto los objetos como los arrays de objetos aparezcan dentro

de un programa, como se sabe es común inicializar variables que inicializar arrays, de modo que para admitir arrays de objetos sin inicializar,

junto con objetos inicializados debe incluirse un constructor que permita la inicialización y otro que no. */


#include<conio.h>

class base

{ protected:

int j;

public:

base();//sin inicializador

base(int n);//con inicializador

int getx(); };

base::base()

{j=0;}

base::base(int n)

{j=n;}

base::getx()

{return j;}

main()

{ int i;

base v1[10];//declaracion del array sin inicialización

base v2[10]={1,2,3,4,5,6,7,8,9,10}; //declaracion del Array con Inicializaciones

for(i=0;i<10;i++)

{ cout<<"v1["<<i<<"]-> "<<v1[i].getx()<<' ';cout<<endl;



cout<<"\t v2["<<i<<"]-> "<<v2[i].getx()<<" ";}

getch(); }

EJECUCION



CAPITULO XII

FLUJOS Y ARCHIVOS

12. ARCHIVOS.- Sabemos que la única estructura que permite acceder dispositivos externos de memoria y por lo

tanto posibilita que los datos sobrevivan a los procesos son los archivos, nosotros en este libro veremos los dos

tipos de archivos más importantes y son:

Archivos de texto (legibles)

Archivos binarios (Poco legibles)

12.1. ARCHIVOS DE TEXTO

Usar streams facilita mucho el acceso a ficheros en disco, veremos que una vez que creemos un stream para un

fichero, podremos trabajar con él igual que lo hacemos con cin o cout.



Mediante las clases ofstream, ifstream y fstream tendremos acceso a todas las funciones de las clases base de las

que se derivan estas: ios, istream, ostream, fstreambase, y como también contienen un objeto filebuf, podremos

acceder a las funciones de filebuf y streambuf.

Evidentemente, muchas de estas funciones puede que nunca nos sean de utilidad, pero algunas de ellas se usan con

frecuencia, y facilitan mucho el trabajo con ficheros.

Crear un archivo de salida, abrir un archivo de entrada

Empezaremos con algo sencillo. Vamos a crear un fichero mediante un objeto de la clase ofstream, y posteriormente

lo leeremos mediante un objeto de la clase ifstream:

Ejemplo 1:

//POOC12E1

#include <iostream>

#include <fstream>

int main() {

char cadena[128];

// Crea un fichero de salida

ofstream fs("nombre.txt");

// Enviamos una cadena al fichero de salida:

fs << "Hola, mundo" << endl;

// Cerrar el fichero,

// para luego poder abrirlo para lectura:

fs.close();

// Abre un fichero de entrada

ifstream fe("nombre.txt");

// Leeremos mediante getline, si lo hiciéramos

// mediante el operador >> sólo leeríamos

// parte de la cadena:

fe.getline(cadena, 128);

cout << cadena << endl;

cin.get();

return 0;}

Este sencillo ejemplo crea un fichero de texto y después visualiza su contenido en pantalla.

Ejemplo 2. Un ejemplo sencillo, para ilustrar algunas limitaciones del operador >> para hacer lecturas, cuando no

queremos perder caracteres.

Supongamos que llamamos a este programa "streams.cpp", y que pretendemos que se autoimprima en pantalla:

PROGRAMA

//POOC12E2

#include <iostream>

#include <fstream>

using namespace std;

int main() {

char cadena[128];

ifstream fe("streams.cpp");

while(!fe.eof()) {

fe >> cadena;

cout << cadena << endl;



}

fe.close();

cin.get();

return 0;

}

El resultado quizá no sea el esperado. El motivo es que el operador >> interpreta los espacios, tabuladores y retornos

de línea como separadores, y los elimina de la cadena de entrada.

PROBLEMA 1.- Escribir Un programa que cree un archivo de texto donde se almacene el código y las cuatro notas de

prácticas de 10 alumnos. Escribir también el programa que las lea.

PROGRAMA 1

//POOC12E3


#include <fstream.h>

#include <stdlib.h>

#include <stdio.h>

void main()

{char *nomarch="practicas.txt";

ofstream f01;

int practica[4];

char nombre[10];

f01.open(nomarch);

for(int i=0;i<10;i++)

{ cout << " Ingrese nombre: ";

gets(nombre);

cout<< " Ingrese practica 1: ";cin>>practica[0];




f01 << nombre << ' '

<< practica[0]<<' '

<< practica[1]<<' '

<< practica[2]<<' '

<< practica[3]<<endl; }

f01.close(); }

PROGRAMA 2

//POOC12E4


#include <fstream.h>

#include <stdlib.h>

#include <stdio.h>

#include <conio.h>

void main()

{char *nomarch="practicas.txt";

ifstream f02;



int practica[10][4];

char nombre[10][10];

f02.open(nomarch);


{ f02>>nombre[i];

f02>>practica[i][0];



f02>>practica[i][3]; }

f02.close();


{ cout<<nombre[i]<<' '<<practica[i][0]<<' '<<practica[i][1]<<' '

<<practica[i][2]<<' '<<practica[i][3]<<endl; }

getch(); }

PROBLEMA 2.- Escribir un programa que pueda crear un archivo simple con salida formateada y otro que lea dicho archivo.PROGRAMA 1//POOC12E5/* Abrir archivo y luego escribir en el archivo */

#include <fstream>

#include <stdlib.h>

#include <iomanip.h>

#include <conio.h>

int main()

{ char nomarch[10]="dato1.txt";

ofstream f03; //salida

//abrir archivo para escritura

f03.open(nomarch);

if (f03.fail()) //verificar si se abrio con éxito

{ cerr<<"El archivo "<<nomarch<<" no se puede abrir con éxito\n"

<<" verifique si el archivo en realidad existe\n";

getch();

exit(1); }

//establecer los formatos del flujo de archivo de salida de datos

f03<<setiosflags(ios::fixed)

<<setiosflags(ios::showpoint)

<<setprecision(2);

//enviar datos al archivo

f03<<"CPU "<<600.80<<endl

<<"DISCOD "<<400.00<<endl

<<"TECLADO "<<50.70<<endl

<<"MOUSE "<<15.00<<endl

<<"IMPRESORA "<<300.00;

//cerrar archivo

f03.close();

cout<<"Los datos se guardaron con éxito en el archivo: "<<nomarch<<endl;

getch();



return 0;}

PROGRAMA 2//POOC12E6/* Abrir un archivo para escritura y luego leer y

desplegar los datos contenidos en el */

#include <fstream>

#include <stdlib.h>

#include <iomanip.h>

#include <conio.h>

int main() //archiv4.cpp

{ char nomarch[10]="dato1.txt";

char descripcion[15];

int ch;

float precio;

ifstream f04;

//abrir archivo para lectura

f04.open(nomarch);

if (f04.fail()) //verificar si se abrio con éxito

{ cout<<"El archivo no se puede abrir con éxito\n"

<<" verifique si el archivo en realidad existe\n";

getch();

exit(1); }

//establecer los formatos del flujo de archivo de salida de datos

cout<<setiosflags(ios::fixed)

<<setiosflags(ios::showpoint)

<<setprecision(2);

//empezar en una nueva línea

cout<<endl;

//leer y desplegar el contenido del archivo

while ((ch = f04.peek()) != EOF) // verificar el siguiente carácter

{ f04>>descripcion>>precio; //introducir datos al flujo

cout<<descripcion<<' '<<precio<<endl; }

//cerrar archivo

f04.close();

cout<<"\nLos datos se leyeron con éxito en el archivo: "<<nomarch<<endl;;

getch(); return 0;}

12.2. ARCHIVOS BINARIOS

12.2.1. Introducción.- Cuando manejamos sistemas de información los datos (archivos) permanecen y los

procesos son los que se ejecutan y desaparecen, esto significa que la información existe antes del procesos

y sobrevive a este. El almacenamiento permanente se realiza en discos ópticos o magnéticos, este capítulo

trata del método más utilizado para estas tareas el manejo de archivos.

12.2.2. Entrada/Salida por archivos.- Para manejar entrada/salida en archivos debemos incluir la clase

fstream que maneja los flujos hacia y desde los archivos al programa. Las clases dedicadas a la gestión de

entrada/salida en disco son fstreambase, ifstream, ofstream y fstream que se derivan por herencia a su vez

de los ios, ostream, istream e iostream.

12.2.3. Apertura y cierre de un archivo.- Para realizar E/S de disco se crea los siguientes objetos:



Para asociar un flujo de salida a un archivo se debe crear un objeto de tipo ofstream (output file stream).

Para asociar un flujo de entrada a un archivo se debe crear un objeto de tipo ifstream (input file stream)

Para realizar tareas de entrada/salida debemos utilizar un objeto de la clase fstream (file stream).

Una vez que se ha creado un flujo con cualquiera de las formas:

ifstream fentra;

ofstream fsal;

fstream fensa;

A continuación asociamos el flujo al archivo con la función open.

El prototipo de la función open es:

void open(char *nombrearch, int modo, int acceso);

Donde: nombreach ...... es el nombre del archivo.

modo .................la forma en que se abre el archivo.

acceso ..............como se puede acceder al archivo.

Modos de apertura de archivos

Programas básicos de creación y lectura de un archivo de nombres

a) // Programa que crea un archivo de nombres llamado nombres.dat en A

//POOC12E7

-#include<iostream.h>

#include<conio.h>

#include<stdio.h>

#include<fstream.h>

void main()

{ ofstream f1;

char nomper[30];

int i,n;

f1.open("C:nombres.dat",ios::out|ios::binary);

clrscr();

cout<< " Ingrese numero de registros a crear => ";

cin >>n;

for(i=1;i<=n;i++)

{ cout<<"Ingrese nombre"<<i<<": ";

gets(nomper);

f1.write(nomper,sizeof(nomper)); }

f1.close(); }

EJECUCION


in : Abre el archivo para lectura (entrada)

out : Abre el archivo para escritura (salida)

app : Abre el archivo para escritura, añade al final

binary : Abre el archivo en modo binario

ate : Abre el archivo y toma posición al final

trunc : Si el archivo existe, destruye su contenido, si no existe, se crea un nuevo archivo

nocreate :Abre un archivo existente. Si el archivo no existe, la apertura falla

noreplace :Si el archivo existe la apertura falla


c) /* POOC12E8

FECHA: 23 DE MARZO DE 2013*/


#include<conio.h>

#include<stdio.h>

#include<fstream.h>

void main()

{ ifstream f2;

char nomper[30];

f2.open("C:nombres.dat",ios::in|ios::binary);

clrscr();

cout<< " Lista de nombres"<<endl;

cout<< "==============="<<endl<<endl;

while(!(f2.eof()))

{ f2.read(nomper,sizeof(nomper));

If(!(f2.eof()))

cout<<nomper<<endl; }

getch();

f2.close(); }

EJECUCION

12.3. Operaciones con archivos.- Sabemos que un archivo es una colección de registros y cada registro

es un conjunto de variables con un nombre común pero con su propio identificador

Las operaciones con archivos son en realidad operaciones sobre sus registros que son las componentes

unitarias de los archivos. Estas son:

Creación



Eliminación

Adición

Modificación

Consulta

Proceso

El detalle de cada operación la veremos en los problemas resueltos.

12.4. Archivos binarios con acceso aleatorio.- Si nosotros utilizamos registros como las componentes

naturales de un archivo entonces al tener estos registros una longitud fija podremos realizar operaciones con

acceso aleatorio o directo. Podemos manejar el acceso el acceso directo mediante la función seekg( ) que

nos permite acceder al archivo de un modo directo. La función seekg() pertenece a la clase ifstream.

Forma General

flujoarch.seekg( desplazamiento, origen)

Donde:

desplazamiento: indica a cuantos bytes (con signo) se desea acceder con respecto al origen

origen: representa un valor predefinido en ios.(Ver tabla)

Ejemplos:

a) Posicionarse al inicio del archivo alumnos.dat que reside en el disco A.

Solucion: indicaremos las líneas principales del programa

struct regalu

{ char codalu[10];

char nomalu[40];

char diralu[40];

}

fstream f01;

f01.open(“A:alumnos.dat”,ios::in|ios::out|ios::binary);

f01.seekg(ios::beg)

b) Posicionarse en el segundo registro del archivo anterior:

tamano= sizeof(regalu);

f01.seekg(tamano*(2-1),ios::beg)

c) Posicionarse en el registro anterior al registro actual:

f01.seekg(-tamano,ios::cur);

PROBLEMAS

1.- Construya un programa que nos permita crear un archivo, cuyo registro contenga los siguientes campos:

Registro de almacen:

codalm char[8] …………..Codigo del item de almacen

desalm char[40] …………Descripción del item de almacen


Constante Significado

ios:: beg Principio del archivo

ios:: cur Posición actual del archivo

ios:: end Fin del archivo


codpro char[8] …………Codigo del proveedor del almacen

ubialm char[4] …………..Ubicación del item dentro del almacen ej:A17, D121

nunalm entero ………… Stock del producto(item).

coualm real ……………Costo unitario del ítem

SOLUCION

PROGRAMA



OBJETIVO: Programa crea archivo de almacen */

/* PROGRAMA QUE CREA UN ARCHIVO COMPUESTO DE REGISTROS */


# include<conio.h>

# include<fstream.h>

# include<stdio.h>

struct almacen

{ char codalm[8] ; // código del ítem

char desalm[40] ; // descripción del ítem

char codpro[8] ; // código del proveedor

char ubialm [4] ; // ubicación del ítem

int nunalm ; // número de unidades del ítem

float coualm ; // costo unitario del ítem

} ;

void main( )

{ almacen registro ;

int n, i;

ofstream flusal;

clrscr( );

flusal.open( "C:stock.dat", ios :: out | ios:: binary); // Se abre archivo para escritura

cout << " Cuantos registros desea grabar --> " ; cin >> n;

for ( i = 1; i <= n ; i++ )

{ cout << " Ingrese codigo del item "<< i << " : "; gets ( registro.codalm);

cout << " Ingrese descripcion del item "<< i << " : "; gets ( registro.desalm);

cout << " Ingrese codigo del proveedor "<< i << " : "; gets ( registro.codpro);

cout << " Ingrese ubicacion del item "<< i << " : "; gets ( registro.ubialm);

cout << " Ingrese # de unidades del item "<< i << " : "; cin >> registro.nunalm;

cout << " Ingrese costo uni. del item "<< i << " : "; cin >> registro.coualm;

flusal.write( (const unsigned char *) &registro, sizeof(registro)); } // se graba registro

flusal.close ( ); } // se cierra archivo

EJECUCION



2.- Construya un programa que nos permita leer el archivo anteriormente creado.

SOLUCION

PROGRAMA



OBJETIVO: Programa lee archivo de almacen */


# include<conio.h>


struct almacen






float coualm ; } ;// costo unitario del ítem

void main( )

{ int cont=2;

almacen registro ;

fstream fluent;

clrscr( );

fluent.open( "C:stock.dat", ios :: in | ios:: binary); // Se abre archivo para lectura

gotoxy(2,cont);cout<< "CODIGO DESCRIPCION PROVEEDOR UBICACION #UNIDADES COSTO/UNIT ";

cont=cont+1;



gotoxy(2,cont);cout<< "================================================================";

cont=cont+2;

while ( ! fluent.eof( ) )

{ fluent.read( ( unsigned char *) &registro, sizeof(registro)); // se lee registro

if (!fluent.eof())

{gotoxy(2,cont);cout <<registro.codalm;

gotoxy(10,cont);cout <<registro.desalm ;

gotoxy(30,cont);cout<<registro.codpro;

gotoxy(40,cont);cout<<registro.ubialm ;

gotoxy(50,cont);cout<<registro.nunalm ;

gotoxy(63,cont);cout<<registro.coualm ;

cont=cont+1;} }

getch(); fluent.close ( ); }

EJECUCION

3.- Escriba un programa que liste a todos los proveedores de los items de nuestro almacen. Se debe mostrar la

descripción del producto y el proveedor

PROGRAMA



OBJETIVO: Lista proveedores de almacen */


# include<conio.h>


# include<string.h>

struct almacen

{ char codalm[8] ;

char desalm[40] ;

char codpro[8] ;

char ubialm [4] ;

int nunalm ;

float coualm ; } ;

struct lista

{ char desalm[40] ;

char codpro[8] ; };



void main( )


fstream fr;

int i,n=0;

lista l[50];

clrscr( );

fr.open( "A:stock.dat", ios :: in | ios:: binary);

gotoxy(4,3);cout<< "CODIGO DESCRIPCION"<<endl;

while ( ! fr.eof( ) )

{fr.read( ( unsigned char *) &registro, sizeof(registro));

if (! fr.eof())

{ n = n +1;

strcpy(l[n].desalm,registro.desalm);

strcpy(l[n].codpro,registro.codpro); }

}

for( i = 1; i <=n; i++)

{ gotoxy(4,i+3);cout <<l[i].codpro;

gotoxy(14,i+3);cout <<l[i].desalm; }

getch(); fr.close ( ); }

EJECUCION

4.- Escriba un programa que me permita crear y mostrar el archivo de proveedores, el registro debe tener la siguiente

estructura:

Registro proveedor

codpro char[8]………………Código del proveedor

nompro char[40] …………….Nombre del proveedor



teluro char[9] ……………..Teléfono del proveedor

Solucion

PROGRAMA



OBJETIVO: CREA Y MUESTRA ARCHIVO DE PROOVEDORES*/


#include<conio.h>

#include<fstream.h>

#include<stdio.h>

struct proveedor

{ char codpro[8] ; // código del proveedor

char nompro [40] ; // nombre proveedor

char telpro[9] ; // teléfono del proveedor

} ;

void main( )

{proveedor buf ;

int n, i;

ofstream flusal;

fstream f1;

clrscr( );

flusal.open( "C:proveedor.dat", ios :: out | ios:: binary);

cout << " Cuantos registros desea grabar => " ; cin >> n;

for ( i = 1; i <= n ; i++ )

{cout << " codigo "<< i << " : "; gets ( buf.codpro);

cout << " nombre "<< i << " : "; gets ( buf.nompro);

cout << " telefono "<< i << " : "; gets ( buf.telpro);

flusal.write( (const unsigned char *) &buf, sizeof(buf));

}

flusal.close ( ); // se cierra archivo

/* Programa que lista los registros de proveedores */

clrscr( );

i=0;

i=i+3;

gotoxy(5,i);cout<<"Codigo";

gotoxy(15,i);cout<<"Nombre";

gotoxy(50,i);cout<<"Telefono";

i=i+1;

gotoxy(5,i);cout<<"=======";

gotoxy(15,i);cout<<"========================================";



gotoxy(50,i);cout<<"========";

i=1+i;

f1.open( "A:proveedor.dat", ios :: in | ios:: binary);

while (! f1.eof( ))

{f1.read( ( unsigned char *) &buf, sizeof(buf));

if (! f1.eof( ))

{i=i+1;

gotoxy(5,i);cout<< buf.codpro;

gotoxy(15,i);cout<< buf.nompro;

gotoxy(50,i);cout<< buf.telpro;

}

}

f1.close ( );

getch();

} // se cierra archivo

EJECUCION

5.- Escriba un programa que me permita consultar el proveedor de un producto (item) de almacen. Este programa

debe manejar dos archivos que tienen la siguiente estructura:



Registro proveedor

codpro char[8]………………….Código del proveedor

nompro char[40] ………………..Nombre del proveedor

teluro char[9] …………………Teléfono del proveedor

Registro de almacen:

codalm char[8] …………..Codigo del item de almacen

desalm char[40] …………Descripción del item de almacen

codpro char[8] …………Codigo del proveedor del almacen

ubialm char[4] ………….Ubicación del item dentro del almacen ej:A17, D121

nunalm entero …………..Stock del producto(item).

coualm real ……………Costo unitario del ítem

PROGRAMA



OBJETIVO: CONSULTA ITEM DE ALMACEN PARA INDICARME CUAL ES EL PROVEEDOR DEL PRODUCTO*/


#include<conio.h>

#include<fstream.h>

#include<stdio.h>

struct proveedor

{ char codpro[8] ; // código del proveedor

char nompro[40] ; // nombre del proveedor

char telpro[9] ; // teléfono del proveedor

} ;

struct almacen






float coualm ; // costo unitario del ítem

} ;

void main( )

{proveedor buf ;

almacen registro;

fstream f1,f2;

char codx[8];

clrscr( );

cout << "Ingrese Codigo del Item: ";

cin >>codx;

f1.open( "C:stock.dat", ios :: in | ios:: binary);

while ( (! f1.eof( )) && strcmp(codx,registro.codalm)!= 0)

f1.read( ( unsigned char *) &registro, sizeof(registro));



if (strcmp(codx,registro.codalm)!= 0)

cout << "Registro no hallado";

else

{ f2.open( "A:proveedor.dat", ios :: in | ios:: binary);

while((!f2.eof())&& strcmp(buf.codpro,registro.codpro)!= 0)

f2.read( ( unsigned char *) &buf, sizeof(buf));

if( strcmp(buf.codpro, registro.codpro)== 0)

{cout<< "CODIGO :"<< buf.codpro<<endl;

cout<< "NOMBRE :"<< buf.nompro<<endl;

cout<< "TELEFONO:"<< buf.telpro<<endl;}

f2.close(); }

f1.close ( );

getch(); // se cierra archivo }

6.- Escriba un programa que liste todos los proveedores de los productos del stock.

PROGRAMA



OBJETIVO: Consulta item de almacen para indicarme cual es el proveedor del producto, lista de proveedores */


#include<conio.h>

#include<fstream.h>

#include<string.h>

struct almacen

{ char codalm[8] ;

char desalm[40] ;

char codpro[8] ;

char ubialm [4] ;

int nunalm ;

float coualm ; } ;

struct lista

{ char desalm[40] ;

char codpro[8] ; };

void main( )


fstream fr;

int i,n=0;

lista l[50];

clrscr( );

fr.open( "C:stock.dat", ios :: in | ios::binary);

gotoxy(5,3);cout<< " CODIGO DESCRIPCION";

while ( ! fr.eof( ) )

{ fr.read( ( unsigned char *) &registro, sizeof(registro));



if (! fr.eof())

{ n = n +1;

strcpy(l[n].desalm, registro.desalm);

strcpy(l[n].codpro, registro.codpro); }

}

for( i = 1; i <=n; i++)

{ gotoxy(5,4+i);cout << l[i].desalm ;

gotoxy(30,4+i);cout << l[i].codpro ; }

getch();

fr.close ( );

}

7.- Escriba un programa que actualice el registro de almacen en cuanto al número de unidades, posteriormente usted

actualícelo en precio unitario.

SOLUCION

PROGRAMA



OBJETIVO: PROGRAMA ACTUALIZA UNIDADES DE UN REGISTRO */


# include<conio.h>


# include<string.h>

struct almacen

{ char codalm[8] ;

char desalm[40] ;

char codpro[8] ;

char ubialm [4] ;

int nunalm ;

float coualm ; } ;

void main( )

{ char codx[8];

almacen registro ;

fstream ff;

clrscr( );

ff.open( "C:stock.dat", ios :: in | ios :: out | ios:: binary);

cout<< " Ingrese codigo : ";

cin >>codx;

do

{ ff.read( ( unsigned char *)&registro , sizeof(registro));

} while ( (! ff.eof( )) && strcmp(codx,registro.codalm) !=0 );

if( strcmp(codx,registro.codalm) ==0)

{gotoxy(30,2);cout<<"REGISTRO HALLADO";



gotoxy(25,4);cout <<"Codigo : "<<registro.codalm;

gotoxy(25,5);cout <<"Descripcion : "<<registro.desalm;

gotoxy(25,6);cout <<"Ubicacion : "<<registro.ubialm;

gotoxy(25,7);cout <<"Nro. Unidades: "<<registro.nunalm ;

gotoxy(25,8);cout <<"Nuevo número de unidades: "; cin >> registro.nunalm;

ff.seekg (- sizeof(registro), ios::cur);

ff.write( (const unsigned char *)

&registro , sizeof(registro)); }

else

cout << "CODIGO NO HALLADO";

getch(); ff.close ( ); }



programacion orientada a objetos

Documents