poo
TRANSCRIPT
PROGRAMACION ORIENTADA A OBJETOS 2013
UNIVERSIDAD NACIONAL DE INGENIERÍA
FACULTAD DE INGENIERÍA MECÁNICA
INDICE
1 CONCEPTOS GENERALES DE COMPUTACION……...…………………….…………………. 06
1 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
PROGRAMACION ORIENTADA A OBJETOS 2013
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…………….………………………………………………………………….………..………
Ejercicio propuestos.………………………………………………………………….………..………
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……………………………………………….…………………………………………………
Ejercicio propuestos.………………………………………………………………….………..………
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……………………………………………….…………………………………………………
Ejercicio propuestos.………………………………………………………………….………..………
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
3 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
4 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
5 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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.
6 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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:
7 Ing. Ricardo Castañeda
mov ah,9int 21hmov ah,10………….push cs
Programación Lineal
Programa 1xxx………………..………………….………………………………………..…………………………………………..……………………..
Programa 1xxx, con mas tareas………………..………………….………………………………………………………..…………………………………………..
INICIALIZAR
PROCESAR
LEER
ESCRIBIR
FACULTAD DE INGENIERIA MECANICA 2013
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:
8 Ing.Ricardo Castañeda
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
Leer (Nota)¿Nota >= 10? V F
Escribir“Aprobado”
Escribir“Desaprobado”
FIN
INICIO
PROGRAMACION ORIENTADA A OBJETOS 2013
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
9 Ing. Ricardo Castañeda
/* 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( ); }
FACULTAD DE INGENIERIA MECANICA 2013
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
10 Ing.Ricardo Castañeda
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>
PROGRAMACION ORIENTADA A OBJETOS 2013
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
11 Ing. Ricardo Castañeda
/* 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>
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
FACULTAD DE INGENIERIA MECANICA 2013
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
12 Ing.Ricardo Castañeda
/* CODIGO: POOC1E4
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 17 DE MARZO DE 2013
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 <iostream.h>
#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(); }
PROGRAMACION ORIENTADA A OBJETOS 2013
...............
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
Segmento de AlgoritmoNota = 9
Si (Nota > 10) Entonces Escribir(“Aprobado”) FinSi
Escribir(“FIN”)
Salida de Ejecución
FIN
Segmento de AlgoritmoNota = 8
Si (Nota > 10) Entonces Escribir(“Aprobado”) Sino Escribir(“Desaprobado”) FinSi
Escribir(“FIN”)
Salida de Ejecución
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
13 Ing. Ricardo Castañeda
/* CODIGO: POOC1E7
FECHA: 17 DE MARZO DE 2013
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;
FACULTAD DE INGENIERIA MECANICA 2013
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
14 Ing.Ricardo Castañeda
/* CODIGO: POOC1E7
FECHA: 17 DE MARZO DE 2013
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;
/* CODIGO: POOC1E8
FECHA: 17 DE MARZO DE 2013
OBJETIVO: Programa que halla el volumen y area de un cilindro
Datos de Entrada:: RADIO Y ALTURA
Salida: AREA Y VOLUMEN.*/
# include<iostream.h>
# include<conio.h>
PROGRAMACION ORIENTADA A OBJETOS 2013
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)
15 Ing. Ricardo Castañeda
/* CODIGO: POOC1E8
FECHA: 17 DE MARZO DE 2013
OBJETIVO: Programa que halla el volumen y area de un cilindro
Datos de Entrada:: RADIO Y ALTURA
Salida: AREA Y VOLUMEN.*/
# include<iostream.h>
# include<conio.h>
FACULTAD DE INGENIERIA MECANICA 2013
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
16 Ing.Ricardo Castañeda
/* CODIGO: POOC1E9
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 17 DE MARZO DE 2013
OBJETIVO: Lee nota e imprime condicion academica.*/
# include<iostream.h>
# 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)
PROGRAMACION ORIENTADA A OBJETOS 2013
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
17 Ing. Ricardo Castañeda
/* CODIGO: POOC1E9
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 17 DE MARZO DE 2013
OBJETIVO: Lee nota e imprime condicion academica.*/
# include<iostream.h>
# 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)
FACULTAD DE INGENIERIA MECANICA 2013
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
18 Ing.Ricardo Castañeda
/* CODIGO: POOC1E10
FECHA: 17 DE MARZO DE 2013
OBJETIVO: Lee operandos y operador y realiza la operacion.*/
# include<iostream.h>
# 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;
cout<<"resultado="<<res;break;
case '*' : res=v1*v2;
cout<<"resultado="<<res;break;
case '/' : res=v1/v2;
cout<<"resultado="<<res;break;
default : cout<< " No es operación"; }
getch( ); }
PROGRAMACION ORIENTADA A OBJETOS 2013
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
19 Ing. Ricardo Castañeda
/* CODIGO: POOC1E11
FECHA: 17 DE MARZO DE 2013
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;
FACULTAD DE INGENIERIA MECANICA 2013
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
20 Ing.Ricardo Castañeda
/* CODIGO: POOC1E11
FECHA: 17 DE MARZO DE 2013
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;
/* 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
PROGRAMACION ORIENTADA A OBJETOS 2013
PROGRAMA
EJECUCION
21 Ing. Ricardo Castañeda
/* 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
/* CODIGO: POOC1E12
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 17 DE MARZO DE 2013
OBJETIVO: Hallar suma y promedio de 10 valores leídos */
# include<iostream.h>
# 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( ); }
FACULTAD DE INGENIERIA MECANICA 2013
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 */
valor, suma , cont son enteros
promedio es real
22 Ing.Ricardo Castañeda
PROBAR
EJECUTAR
EJECUTAR
PROBAR
PROGRAMACION ORIENTADA A OBJETOS 2013
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
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 17 DE MARZO DE 2013
OBJETIVO: Hallar suma y promedio de 10 valores leídos, con el do while */
# include<iostream.h>
# include<conio.h>
void main( )
{ int valor, suma, cont;
float promedio;
clrscr( );
cont =suma= 0;
do { cout<< " valor = "; cin >> valor;
suma = suma + valor;
cont ++;
} while ( cont<10);
promedio = suma/10.0;
cout << " Suma = "<< suma<< endl;
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 ( )
23 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
1.2 Escribir ( “MENU VERTICAL”)
1.3 Escribir ( “1.- Tarea 1 ”)
1.4 Escribir ( “2.- Tarea 2 ”)
1.5 Escribir ( “3.- Tarea 3 ”)
1.6 Escribir ( “4.- Tarea 4 ”)
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
24 Ing.Ricardo Castañeda
/* CODIGO: POOC1E14
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 17 DE MARZO DE 2013
OBJETIVO: Muestra un menu vertical general */
# include<iostream.h>
# include<conio.h>
void main( )
{ char opcion;
do
{ clrscr( );
gotoxy(30,2);cout<<"MENU VERTICAL";
gotoxy(30,6);cout<<"1.- Tarea 1";
gotoxy(30,7);cout<<"2.- Tarea 2";
gotoxy(30,8);cout<<"3.- Tarea 3";
gotoxy(30,9);cout<<"4.- Tarea 4";
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;
PROGRAMACION ORIENTADA A OBJETOS 2013
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.
25 Ing. Ricardo Castañeda
/* CODIGO: POOC1E14
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 17 DE MARZO DE 2013
OBJETIVO: Muestra un menu vertical general */
# include<iostream.h>
# include<conio.h>
void main( )
{ char opcion;
do
{ clrscr( );
gotoxy(30,2);cout<<"MENU VERTICAL";
gotoxy(30,6);cout<<"1.- Tarea 1";
gotoxy(30,7);cout<<"2.- Tarea 2";
gotoxy(30,8);cout<<"3.- Tarea 3";
gotoxy(30,9);cout<<"4.- Tarea 4";
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;
FACULTAD DE INGENIERIA MECANICA 2013
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
26 Ing.Ricardo Castañeda
1
3
5
7
9
11
FIN
PROGRAMACION ORIENTADA A OBJETOS 2013
4. Escribir ( “Suma = “, suma)
5. Escribir ( “ Promedio =”, promedio)
6. Fin
PROGRAMA
/* CODIGO: POOC1E16
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 17 DE MARZO DE 2013
OBJETIVO: Halla la suma y el promedio utilizando una instruccion for. */
#include<iostream.h>
#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;
suma = suma + valor;
}
promedio = suma/10.0;
cout << " Suma = "<< suma<< endl;
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.
27 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
28 Ing.Ricardo Castañeda
/* CODIGO: POOC1PROB1
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 17 DE MARZO DE 2013
OBJETIVO: LEER UNA CANTIDAD EN GRADOS CENTIGRADOS Y MOSTRAR SU EQUIVALENTE EN GRADOS FARENHEIT*/
#include<iostream.h>
#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
}
PROGRAMACION ORIENTADA A OBJETOS 2013
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
/* CODIGO: POOC1PROB2
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 17 DE MARZO DE 2013
OBJETIVO: LEER DATOS DE PLANILLA DE UN EMPLEADO Y CALCULA SUELDO NETO A PAGAR */
29 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
#include<iostream.h>
#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
30 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
/* CODIGO: POOC1PROB3
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 17 DE MARZO DE 2013
OBJETIVO: CALCULA LAS RAICES DE UNA ECUACION CUADRATICA */
#include<iostream.h>
#include<conio.h>
#include<math.h>
void main()
{ float a,b,c;
31 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
/*Declaración de Variables*/
p1, p2, p3, p4, menor1, menor2, menort son enteras
promedio es real
32 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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.2. Si (p3=99) Entonces p3 0 FinSi
5.3. Si (p4=99) Entonces p4 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
33 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
FinSi
FinSi
FinSi
FinSi
6. Escribir(“El promedio es : “,promedio)
7. FIN
PROGRAMA
/* CODIGO:POOC1PROB4
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 17 DE MARZO DE 2013
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<iostream.h>
#include<conio.h>
void main()
{ int p1, p2, p3, p4;
float promedio;
int menor1, menor2, menort;
clrscr();
cout<<" P1= ";cin>>p1;
cout<<" P2= ";cin>>p2;
cout<<" P3= ";cin>>p3;
cout<<" P4= ";cin>>p4;
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;
promedio =(p1+p3+p4)/3.0; }
else
if (p3==99)
{if (p4==99) p4=0;
promedio =(p1+p2+p4)/3.0; }
else
if (p4==99)
promedio = (p1+p2+p3)/3.0;
else
{if(p1<p2)
34 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
35 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
/*Declaración de Variables*/
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
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA : 17 DE MARZO DE 2013
OBJETIVO: LEE UNA FECHA Y ESCRIBE FECHA DEL DIA SIGUIENTE */
#include<iostream.h>
#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;
36 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
- 5 cuotas 9% de interés.
- 10 cuotas 20% de interés.
- 12 cuotas 25% de interés.
- 24 cuotas 60% 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)
4: pago_mes precio*(1+0.07)/numero_c
escribir(pago_mes)
5: pago_mes precio*(1+0.09)/numero_c
escribir(pago_mes)
10: pago_mes precio*(1+0.20)/numero_c
escribir(pago_mes)
12: pago_mes precio*(1+0.25)/numero_c
escribir(pago_mes)
24: pago_mes precio*(1+0.60)/numero_c
escribir(pago_mes)
37 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
Sino: escribir(“Error el numero de cuotas no es válido”)
Fin Case
5. FIN
PROGRAMA/* CODIGO: POOC1PROB6
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 17 DE MARZO DE 2013
OBJETIVO: Lee precio de un articulo y numero de cuotas y calcula pago mensual */
# include<iostream.h>
# 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;
cout<< "Pago mensual= "<<pago_mes;
break;
case 4: pago_mes = precio*(1+0.07)/numero_c;
cout<< "Pago mensual= "<<pago_mes;
break;
case 5: pago_mes = precio*(1+0.09)/numero_c;
cout<< "Pago mensual= "<<pago_mes;
break;
case 10:pago_mes = precio*(1+0.20)/numero_c;
cout<< "Pago mensual= "<<pago_mes;
break;
case 12:pago_mes = precio*(1+0.25)/numero_c;
cout<< "Pago mensual= "<<pago_mes;
break;
case 24:pago_mes = precio*(1+0.60)/numero_c;
cout<< "Pago mensual= "<<pago_mes;
break;
default : cout<< " Error el numero de cuotas no es valido"; }
getch( );}
EJECUCION
38 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
/*Declaración de Variables*/
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
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 17 DE MARZO DE 2013
39 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
OBJETIVO: CALCULA LA SERIE EXPONENCIAL CON 3 DIGITOS DECIMALES EXACTOS */
#include<iostream.h>
#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 entrada serana ,b y x .
7. Escriba un algoritmo que nos permita hallar la fecha del dia anterior, dada la fecha de cualquier dia.
40 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
41 Ing. Ricardo Castañeda
Directivas del PreProcesadorIncludeMacros
Datos y funciones externas
Datos y Funciones Globales
void main( ){………. ........... ………… }
FACULTAD DE INGENIERIA MECANICA 2013
CAPITULO II
2 ESTRUCTURA DE UN PROGRAMA BORLAND C++.
2.1 Organización de un Programa Borland C++: Se compone de los bloques:
42 Ing.Ricardo Castañeda
void procesar_planillar( ){ }
void main(){ }
void leer( ){ }
void inprimir_planillar( ){ }
PROGRAMACION ORIENTADA A OBJETOS 2013
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í:
43 Ing. Ricardo Castañeda
# 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(); }
FACULTAD DE INGENIERIA MECANICA 2013
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<iostream.h>
# 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).
44 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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 “---------------“
45 Ing. Ricardo Castañeda
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
FACULTAD DE INGENIERIA MECANICA 2013
#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.-
46 Ing.Ricardo Castañeda
Tipo nombre [= valor];
/* CODIGO: POOC2E1
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Mostrar la salida en pantalla utilizando el operador << y el flujo cout, con constantes y variables. */
# include<iostream.h>
# 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
PROGRAMACION ORIENTADA A OBJETOS 2013
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
47 Ing. Ricardo Castañeda
/* CODIGO: POOC2E2
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Mostrar las diferentes formas de leer valores y almacenarlos en las variables */
#include<iostream.h>
#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
FECHA: 18 DE MARZO DE 2013
OBJETIVO: MANEJO DE SECUENCIAS DE ESCAPE */
#include<iostream.h>
#include<conio.h>
FACULTAD DE INGENIERIA MECANICA 2013
EJECUCION
EJECUCION
48 Ing.Ricardo Castañeda
/* CODIGO: POOC2E3
FECHA: 18 DE MARZO DE 2013
OBJETIVO: MANEJO DE SECUENCIAS DE ESCAPE */
#include<iostream.h>
#include<conio.h>
PROGRAMACION ORIENTADA A OBJETOS 2013
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.
49 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
50 Ing.Ricardo Castañeda
/* CODIGO: POOC2E4
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Utilizacion de manipuladores de flujo de salida */
#include<iostream.h>
#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();
}
PROGRAMACION ORIENTADA A OBJETOS 2013
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
51 Ing. Ricardo Castañeda
/* CODIGO: POOC2E5
FECHA: 18 DE MARZO DE 2013
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;
cout << setprecision( 1 ) << valor << endl;
cout << setprecision( 2 ) << valor << endl;
cout << setprecision( 3 ) << valor << endl;
cout << setprecision( 4 ) << valor << endl;
cout << setprecision( 5 ) << valor << endl;
cout << setprecision( 6 ) << valor << endl;
getch(); }
FACULTAD DE INGENIERIA MECANICA 2013
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
/* CODIGO: POOC2PROB2
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Halla suma, resta y multiplicación de números complejos */
52 Ing.Ricardo Castañeda
/* CODIGO: POOC2PROB1
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 18 DE MARZO DE 2013
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<iostream.h>
# 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(); }
PROGRAMACION ORIENTADA A OBJETOS 2013
# include<iostream.h>
# 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);
cout<<"Opcion --> ";
cin >> opcion;
switch ( opcion)
{ case '1': clrscr();
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";
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 '3': clrscr();
gotoxy(30,2); cout<<"MULTIPLICACION";
gotoxy(30,6);cout<<"ar = "; cin >> ar;
53 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
gotoxy(30,7);cout<<"ai = "; cin >> ai;
gotoxy(30,8);cout<<"br = "; cin >> br;
gotoxy(30,9);cout<<"bi = "; cin >> bi;
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;
54 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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)
{ 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(c3)
{ 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; }
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
/* CODIGO: POOC2PROB4
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Maneja la función gotoxy y presenta resultados de una boleta de ventas con una salida formateada. */
# include<iostream.h>
# 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<<"========";
55 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
56 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
CAPITULO III
57 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
58 Ing.Ricardo Castañeda
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
PROGRAMACION ORIENTADA A OBJETOS 2013
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
59 Ing. Ricardo Castañeda
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
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA:18 DE MARZO DE 2013
OBJETIVO: Lee un numero y lo invierte */
# include<iostream.h>
# 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(); }
FACULTAD DE INGENIERIA MECANICA 2013
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
60 Ing.Ricardo Castañeda
/* CODIGO: POOC3E2
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 18 de MARZO DE 2013
OBJETIVO: Observar manejo de punteros en forma basica */
# include<iostream.h>
# 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
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA:18 DE MARZO DE 2013
OBJETIVO: Lee un numero y lo invierte */
# include<iostream.h>
# 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(); }
PROGRAMACION ORIENTADA A OBJETOS 2013
“.” 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
61 Ing. Ricardo Castañeda
expresion_c ? expresion_v : expresion_f
v1 > v2 ? v1 : v2
devuelve el mayor valor de v1 , v2
/* CODIGO: POOC3E3
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Escribir un programa que simula un juego de dados */
# include<iostream.h>
# include<conio.h>
# include<stdlib.h>
# include<time.h>
void main( )
{ int juego1, juego, dado1,dado2;
clrscr ();
randomize();
dado1 = random(6) + 1;
dado2 = 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;
dado2 = random(6) + 1;
FACULTAD DE INGENIERIA MECANICA 2013
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:
62 Ing.Ricardo Castañeda
/* CODIGO: POOC3E3
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Escribir un programa que simula un juego de dados */
# include<iostream.h>
# include<conio.h>
# include<stdlib.h>
# include<time.h>
void main( )
{ int juego1, juego, dado1,dado2;
clrscr ();
randomize();
dado1 = random(6) + 1;
dado2 = 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;
dado2 = random(6) + 1;
PROGRAMACION ORIENTADA A OBJETOS 2013
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.
63 Ing. Ricardo Castañeda
/* CODIGO: POOC3E4
FECHA: 18 DE MARZO DE 2013
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<iostream.h>
# 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";
FACULTAD DE INGENIERIA MECANICA 2013
EJECUCION
Ejemplo 5.- Programa que lee tres notas y halla el promedio eliminando la menor y duplicando la mayor.
PROGRAMA
64 Ing.Ricardo Castañeda
/* CODIGO: POOC3E4
FECHA: 18 DE MARZO DE 2013
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<iostream.h>
# 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
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Ejemplo de if que lee tres notas y calcula mayor, menor y halla
promedio, duplicando la mayor y eliminando la menor */
# include<iostream.h>
# include<conio.h>
void main( )
{ int nota1,nota2,nota3,menor,mayor;
float promedio;
clrscr ();
cout<< " ingrese nota1 : "; cin>>nota1;
cout<< " ingrese nota2 : "; cin>>nota2;
cout<< " ingrese nota3 : "; cin>>nota3;
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;
cout<<"El promedio es : "<<promedio;
getch(); }
PROGRAMACION ORIENTADA A OBJETOS 2013
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<iostream.h>
# 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;
65 Ing. Ricardo Castañeda
/* CODIGO: POOC3E5
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Ejemplo de if que lee tres notas y calcula mayor, menor y halla
promedio, duplicando la mayor y eliminando la menor */
# include<iostream.h>
# include<conio.h>
void main( )
{ int nota1,nota2,nota3,menor,mayor;
float promedio;
clrscr ();
cout<< " ingrese nota1 : "; cin>>nota1;
cout<< " ingrese nota2 : "; cin>>nota2;
cout<< " ingrese nota3 : "; cin>>nota3;
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;
cout<<"El promedio es : "<<promedio;
getch(); }
FACULTAD DE INGENIERIA MECANICA 2013
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 : ................... ;
....................;
66 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Elige una opción de un menú simple usando la sentencia condicional SWITCH. */
#include <iostream.h>
#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
67 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
68 Ing.Ricardo Castañeda
/* CODIGO: POOC3E8
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Ejemplo de estructura repetitiva while */
# include<iostream.h>
# 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(); }
.
PROGRAMACION ORIENTADA A OBJETOS 2013
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
69 Ing. Ricardo Castañeda
/* CODIGO: POOC3E9
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Presenta cuadrados y cubos de los 20 primeros numeros. Usando el do while */
# include<iostream.h>
# 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(); }
FACULTAD DE INGENIERIA MECANICA 2013
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
70 Ing.Ricardo Castañeda
/* CODIGO: POOC3E10
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Imprime los primos menores que 100 o sea dos digitos. Usando el lazo repetitivo for */
# include<iostream.h>
# 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(); }
PROGRAMACION ORIENTADA A OBJETOS 2013
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
71 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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:
/* CODIGO: POOC3PROB1
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 18 DE MARZO DE 2013
OBJETIVO: LEE TRES NOMBRES Y EDADES E IMPRIME LOS NOMBRES EN FORMA CRECIENTE POR EDAD */
# include<iostream.h>
# 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<< " Ingrese nombre 2 ==> "; cin>> nombre2;
cout<< " Ingrese edad 2 ==> "; cin>> edad2;
cout<< " Ingrese nombre 3 ==> "; cin>> nombre3;
cout<< " Ingrese edad 3 ==> "; cin>> edad3;
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)
cout<< nombre1<< " "<<nombre3<< " "<<nombre2<<endl;
else
cout<< nombre3<< " "<<nombre1<< " "<<nombre2<<endl;
else
if (edad1 <edad3)
cout<< nombre2<< " "<<nombre1<< " "<<nombre3<<endl;
else
if(edad2<edad3)
cout<< nombre2<< " "<<nombre3<< " "<<nombre1<<endl;
else
cout<< nombre3<< " "<<nombre2<< " "<<nombre1<<endl;
getch( );
}
B) RESULTADOS:
72 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
/* CODIGO: POOC3PROB2
PROGRAMA CREADO POR RICARDO CASTAÑEDA DE LA ROSA
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Lee nombres y edades e imprime el periodo en el que se encuentra la persona*/
# include<iostream.h>
# 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
73 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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( ); }
74 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
/* CODIGO: POOC3PROB4
FECHA: 18 DE MARZO DE 2013
OBJETIVO: LISTA INGRESANTES POR FACULTAD DE UN EXAMEN DE ADMISION */
# include<iostream.h>
# include<conio.h>
# include<ctype.h>
75 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
# 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( );}
76 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
/* CODIGO: POOC3PROB5
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Muestra veces que aparece el digito 3 en los números leídos antes de encontrar un negativo.*/
# include<iostream.h>
# 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
77 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
/* CODIGO: POOC3PROB6
FECHA: 18DE MARZO DE 2013
OBJETIVO: Muestra la mayor de las temperaturas negativas y cuantas veces se presenta.*/
# include<iostream.h>
# 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
78 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
EJERCICIOS PROPUESTOS
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.
79 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
80 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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 <iostream.h>
#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;
cout<<"Ingrese valor 2 ==> "; cin >>valor2;
cout<<"Ingrese valor 3 ==> "; cin >>valor3;
x = abs(valor1);
y = fabs(valor2);
z = fabs(valor3);
if (x>y)
mayor= x;
else
81 Ing. Ricardo Castañeda
Syntax
#include <math.h>
double sqrt(double x);
Syntax
#include <math.h>
#include <stdlib.h>
int abs(int x);
FACULTAD DE INGENIERIA MECANICA 2013
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
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Ejemplo de las funciones ceil() y floor().*/
#include <iostream.h>
#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(); }
82 Ing.Ricardo Castañeda
Syntax
#include <math.h>
double ceil(double x);
long double ceill(long double x);
double floor(double x);
long double floorl(long double x);
PROGRAMACION ORIENTADA A OBJETOS 2013
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
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Ejemplo de las funciones SIN() y COS().*/
#include <iostream.h>
#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()
83 Ing. Ricardo Castañeda
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);
FACULTAD DE INGENIERIA MECANICA 2013
Exp() calcula el valor “e” elevado a la x.
Ejemplo 4.- Escribir un programa con exp(x)
PROGRAMA
/* CODIGO: POOC4E4
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Ejemplo de las funciones exp()*/
#include <iostream.h>
#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
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Utiliza pow() y sqrt() para calcular raiz cuadrada*/
84 Ing.Ricardo Castañeda
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);
PROGRAMACION ORIENTADA A OBJETOS 2013
#include <iostream.h>
#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
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Utilizar la funcio gets() y la función printf().*/
#include <iostream.h>
#include <conio.h>
#include <stdio.h>
#include <math.h>
void main()
{ char nombre[30];
float nota;
clrscr();
85 Ing. Ricardo Castañeda
Syntax#include <stdio.h>char *gets(char *s);
Syntax
#include <stdio.h>
int printf(const char *format[, argument, ...]);
FACULTAD DE INGENIERIA MECANICA 2013
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
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Maneja la función clock*/
#include <iostream.h>
#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
86 Ing.Ricardo Castañeda
Syntax
#include <time.h>
clock_t clock(void);
PROGRAMACION ORIENTADA A OBJETOS 2013
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>
#include <iostream.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()
87 Ing. Ricardo Castañeda
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);
FACULTAD DE INGENIERIA MECANICA 2013
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
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Genera valores aleatorios entre dos valores dados */
#include <stdlib.h>
#include <iostream.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
88 Ing.Ricardo Castañeda
Syntax
#include <stdlib.h>
int random(int num);
PROGRAMACION ORIENTADA A OBJETOS 2013
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
89 Ing. Ricardo Castañeda
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);
// PROTOTIPO DE LA FUNCION (ES EL ENCABEZADO)
int suma(int operando1, int operando2);
// LA LLAMADA SE REALIZA DE LA FUNCION MAIN
void main( ){ int valor1, valor2;
……………………; ……………………….; S = suma( valor1, valor2); …………………………;…………………………..;…………………………..;
}
FACULTAD DE INGENIERIA MECANICA 2013
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 <iostream.h>
#include <conio.h>
90 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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 <iostream.h>
#include <conio.h>
// VARIABLES GLOBALES
int a,b,c;
91 Ing. Ricardo Castañeda
// 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( )
FACULTAD DE INGENIERIA MECANICA 2013
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):
92 Ing.Ricardo Castañeda
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( )
PROGRAMACION ORIENTADA A OBJETOS 2013
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
FECHA: 18 DE MARZO DE 2013
OBJETIVO: UTILIZA FUNCIONES INLINE. */
#include <iostream.h>
#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;
93 Ing. Ricardo Castañeda
main() f2()_
a1 p1
a2 p2
a3 p3
a4 p4
FACULTAD DE INGENIERIA MECANICA 2013
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
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Halla factorial en forma recursiva */
# include<iostream.h>
# include<conio.h>
int facto (int num);
94 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Ejemplo de puntero a función. */
# include<iostream.h>
# 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();
95 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
}
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:
/* CODIGO: POOC4PROB1
FECHA: 16 de agosto de 2007
OBJETIVO: Halla raíz cuadrada por aproximación*/
#include<iostream.h>
#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;
96 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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();}
97 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
/* CODIGO: POOC4PROB3
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Halla raiz en intervalo 0-5 con error menor que 0.001 */
# include<iostream.h>
# 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;
98 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
99 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
/* CODIGO: POOC4PROB4
FECHA: 18 DE MARZO DE 2013
OBJETIVO: CALCULO DE PLANILLA PARA UN TRABAJADOR.*/
# include<iostream.h>
# 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)
(*descuento)= (sueldob+sumabonif-des)*0.11;
100 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
else
(*descuento)= (sueldob+sumabonif-des)*0.07;
(*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
/* CODIGO: POOC4PROB5
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Halla fibonacci en forma recursiva */
#include<iostream.h>
#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)
101 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
{ 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
/* CODIGO: POOC4PROB6
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Halla factores primos en forma recursiva */
# include<iostream.h>
# 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
102 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
EJERCICIOS PROPUESTOS
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.
103 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
CAPITULO V
104 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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]
105 Ing. Ricardo Castañeda
25
35
20
FACULTAD DE INGENIERIA MECANICA 2013
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
106 Ing.Ricardo Castañeda
40
PROGRAMACION ORIENTADA A OBJETOS 2013
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:
107 Ing. Ricardo Castañeda
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;
FACULTAD DE INGENIERIA MECANICA 2013
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
Las instrucciones en Borland “C” serán:
108 Ing.Ricardo Castañeda
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;
PROGRAMACION ORIENTADA A OBJETOS 2013
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
Las instrucciones en Borland “C” serán:
109 Ing. Ricardo Castañeda
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 ";
FACULTAD DE INGENIERIA MECANICA 2013
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
110 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
¿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 [5]?. Si. Intercambiar entre A[3] y A[5]
A [3] A [4] A [5] A[6] A[7]
6 9 7 4 5
¿A[3] > A [6]?. Si. Intercambiar entre A[3] y A[6]
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
111 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
112 Ing.Ricardo Castañeda
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 ;
}
PROGRAMACION ORIENTADA A OBJETOS 2013
/* CODIGO: POOC5E2
FECHA: 18 DE MARZO DE 2013
OBJETIVO: ADICIONAR UN ELEMENTO AL FINALIZAR EL VECTOR */
# include<iostream.h>
# include<conio.h>
void main( )
{ int vector[50],n,i,x;
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();
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++)
{ cout<< vector[i]<< endl; }
getch(); }
EJECUCION
Ejemplo 3.- Realizar una búsqueda binaria sobre un vector ordenado.
PROGRAMA
/* CODIGO: POOC5E3
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Realizar una búsqueda binaria sobre un vector ordenado */
# include<iostream.h>
# include<conio.h>
void main( )
{ int vector[50],n,i,x;
113 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
int inicio,final,medio,encontrado=0;
clrscr();
//Lectura
cout << " Ingrese n (Para vector ordenado) => "; cin >> n;
for (i=1;i<=n;i++)
{ cout<< " Ingrese valor "<< i<<" : ";
cin>> vector[i]; }
clrscr();
//Escritura
cout<<" SALIDA VECTOR ORDENADO "<<endl<<endl;
for ( i=1; i<=n;i++)
{ cout<< vector[i]<< endl; }
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
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Ordenamiento x1<=x2<=x3.... */
# include<iostream.h>
114 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
# include<conio.h>
void main( )
{ int vector[50],n,i;
int cambio,temp;
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();
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++)
{ cout<< vector[i]<< endl; }
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á:
115 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
PROGRAMA
/* CODIGO: POOC5E5
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Lectura y Escritura de una matriz */
# include<iostream.h>
# 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>
116 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
#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
117 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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++)
for (j=i+1;j<=n;j++)
if( a[i]> a[j])
118 Ing.Ricardo Castañeda
/* CODIGO: POOC5PROB1
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Halla la moda de un conjunto de números enteros */
# include <iostream.h>
# 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); }
PROGRAMACION ORIENTADA A OBJETOS 2013
{ 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ú:
119 Ing. Ricardo Castañeda MENU ARREGLOS
1.- Lectura2.- Adición3.- Eliminación4.- Búsqueda5.- Ordenar
FACULTAD DE INGENIERIA MECANICA 2013
PROGRAMA
/* CODIGO: POOC5PROB2
FECHA: 18 DE MARZO DE 2013
OBJETIVO: Programa que crea un menú para manejo de operaciones
con arreglos */
# include<iostream.h>
# 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 ==> ";
120 Ing.Ricardo Castañeda
MENU ARREGLOS
1.- Lectura2.- Adición3.- Eliminación4.- Búsqueda5.- Ordenar
PROGRAMACION ORIENTADA A OBJETOS 2013
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
121 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
cout<< " Valor no hallado ";
getch(); }
void sorteo(int v[50], int n)
{ 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 ; } }
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
/* CODIGO: POOC5PROB3
FECHA: 18 DE MARZO DE 2013
OBJETIVO: halla las tres mejores notas de un grupo de alumnos y las muestra junto con los nombres*/
# include<iostream.h>
# 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);
122 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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++)
for (j=i+1;j<=n;j++)
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();
123 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
/* CODIGO: POOC5PROB4
FECHA: 18 DE MARZO DE 201
OBJETIVO: Calcula determinante*/
#include<iostream.h>
#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;
124 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
}
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++)
125 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
{ 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
/* CODIGO: POOC5PROB6
126 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
FECHA: 18 DE MARZO DE 2013
Objetivo: rota a la derecha los "n" elementos de un arreglo
Entrada: vector v[]
Salida: vector v[] rotado */
#include<iostream.h>
#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
EJERCICIOS PROPUESTOS
1) Escribir un programa que inserte un elemento dentro de un vector ordenado, considere el programa utilizando
para su solución la estructura while.
127 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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.
128 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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).
129 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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)
130 Ing.Ricardo Castañeda
#include <iostream.h>
main ()
{char cad [80];
cout << “introduzca una cadena:”; // lectura del teclado cin » cad;
cin >> cad;
cout << “Su cadena es:”;
cout << cad;
return 0; }
PROGRAMACION ORIENTADA A OBJETOS 2013
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<iostream.h>
#include<conio.h>
#include<stdio.h>
void main()
{ char nombre_apellidos1[50],nombre_apellidos2[50];
clrscr();//limpia pantalla
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
131 Ing. Ricardo Castañeda
#include <iostream.h>
#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.
FACULTAD DE INGENIERIA MECANICA 2013
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<iostream.h>
#include<conio.h>
#include<stdio.h>
void main()
{ char nombre[50],codigo[10];
char nomsal[50],ingreso[5];
clrscr();//limpia pantalla
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
132 Ing.Ricardo Castañeda
#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.
PROGRAMACION ORIENTADA A OBJETOS 2013
Ejemplo 3.- Escriba un programa que ingrese 3 nombres y los ordene utilizando la función strcmp y también strcpy.
PROGRAMA
/* CODIGO: POOC6E3
fecha : 18 DE MARZO DE 2013
objetivo: Ordena tres nombres en forma alfabética
entrada: nombre1,nombre2 y nombre3
salida: las tres entradas ordenadas alfabéticamente */
#include<iostream.h>
#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;
clrscr();//limpia pantalla
cout<<"Ingrese nombre 1: "; gets(nombre1);
cout<<"Ingrese nombre 2: "; gets(nombre2);
cout<<"Ingrese nombre 3: "; gets(nombre3);
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;
cout<<nombre2<<endl;
cout<<nombre3<<endl;
getch();
}
void intercambio(char na[30],char nb[30])
{ char temp[30];
strcpy(temp,na);
strcpy(na,nb);
strcpy(nb,temp); }
EJECUCION
133 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
fecha : 18 DE MARZO DE 2013
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<iostream.h>
#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;
134 Ing.Ricardo Castañeda
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.
PROGRAMACION ORIENTADA A OBJETOS 2013
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
fecha : 18 DE MARZO DE 2013
objetivo: LECTURA Y ESCRITURA DE NOMBRES DE CURSOS
entrada: Ingresa un arreglo de cursos
salida: Muestra los cursos ingresados */
#include<iostream.h>
#include<conio.h>
#include<stdlib.h>
#include<string.h>
135 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
#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
fecha : 18 DE MARZO DE 2013
objetivo: Ordenamiento alfabético de nombres
entrada: Ingresa un arreglo de nombres
salida: Muestra los nombres ingresados ordenados alfabéticos */
#include<iostream.h>
#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]);
}
136 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
//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
137 Ing. Ricardo Castañeda
/* CODIGO: POOC6PROB1
fecha : 18 DE MARZO DE 2013
objetivo: BUSQUEDA EN UN VECTOR PARALELO
entrada: INGRESA CODIGO DE UN CURSO
salida: NOMBRE DEL CURSO O MENSAJE DE BUSQUEDA FALLIDA */
#include<iostream.h>
#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++)
FACULTAD DE INGENIERIA MECANICA 2013
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
138 Ing.Ricardo Castañeda
/* CODIGO: POOC6PROB1
fecha : 18 DE MARZO DE 2013
objetivo: BUSQUEDA EN UN VECTOR PARALELO
entrada: INGRESA CODIGO DE UN CURSO
salida: NOMBRE DEL CURSO O MENSAJE DE BUSQUEDA FALLIDA */
#include<iostream.h>
#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++)
/* CODIGO: POOC6PROB2
fecha : 18 DE MARZO DE 2013
objetivo: Genera un Email para cada alumno FIM
entrada: nombre y apellido
salida: Email */
#include<iostream.h>
#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;
clrscr();//limpia pantalla
PROGRAMACION ORIENTADA A OBJETOS 2013
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
/* CODIGO: POOC6PROB3
fecha : 18 DE MARZO DE 2013
objetivo: Genera un listado alfabetico de un curso
entrada: nombre y curso matriculado ademas del curso para obtener el listado
salida: Listado */
#include<iostream.h>
#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;
139 Ing. Ricardo Castañeda
/* CODIGO: POOC6PROB2
fecha : 18 DE MARZO DE 2013
objetivo: Genera un Email para cada alumno FIM
entrada: nombre y apellido
salida: Email */
#include<iostream.h>
#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;
clrscr();//limpia pantalla
FACULTAD DE INGENIERIA MECANICA 2013
clrscr();//limpia pantalla
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
EJERCICIOS PROPUESTOS
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.
140 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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.
141 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
142 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
143 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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]; }
144 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
FECHA: 21 DE MARZO DE 2013
OBJETIVO:PROGRAMA QUE LEE Y ESCRIBE UN ARREGLO DE REGISTROS*/
#include<iostream.h>
#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
145 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
FECHA: 21 DE MARZO DE 2013
OBJETIVO: Ingresa registros sin codigo repetido */
#include<iostream.h>
#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;
146 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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;
}
}
}
cout<<setiosflags(ios::left);
// 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
147 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
/* CODIGO: POOC7PROB1
FECHA: 21 DE MARZO DE 2013
OBJETIVO: Pograma que crea un menú para manejo de registros que procesan stock de una tienda de abarrotes */
#include<iostream.h>
#include<conio.h>
#include<string.h>
#include<stdio.h>
#include<ctype.h>
struct item
148 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
{ 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; }
}while(opcion != '7');
}
void lectura(item prod[50], int *n)
{ int i;
clrscr();
cout << " Ingrese n => ";
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;
149 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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;
if(prod[i].codite == codx)
{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();
cout<<"Ingrese codigo : ";
cin>> codx;
for( i=1;i<=(*n);i++)
if(prod[i].codite == codx)
{ 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++)
150 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
prod[i-1] = prod[i];
(*n)=(*n) - 1; }
getch();
} }
void busqueda(item prod[50], int n)
{ int codx,i;
clrscr();
cout<<"Ingrese codigo : ";
cin>> codx;
for( i=1;i<=n;i++)
if(prod[i].codite == codx)
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++)
for (j=i+1;j<=n;j++)
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
151 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
/* CODIGO: POOC7PROB2
FECHA: 21 DE MARZO DE 2013
OBJETIVO: Programa que crea un menú con registros de empleados */
#include<iostream.h>
#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);
152 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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; }
}while(opcion != '5');
}
void leer(empleado p[50], int *n)
{ int i;
clrscr();
cout << " Ingrese n => ";
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;
153 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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();
154 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
}
}
void escribir(empleado p[50], int n)
{int i;
clrscr();
cout<<setiosflags(ios::left);
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)
155 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
/* CODIGO: POOC7PROB3
FECHA: 21 DE MARZO DE 2013
OBJETIVO: Programa que procesa notas, considerando las pruebas no rendidas como 99, para cálculos el 99 se transforma en cero */
#include<iostream.h>
#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;
156 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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);
157 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
cout<<setprecision(2);
cout<<setiosflags(ios::left);
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
/* CODIGO: POOC7PROB4
FECHA: 21 DE MARZO DE 2013
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<iostream.h>
#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()
158 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
{ 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
159 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
EJERCICIOS PROPUESTOS
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.
160 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
CAPITULO VIII
161 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
162 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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.
163 Ing. Ricardo Castañeda
TIPO DE DATOS ABSTRACTO
ESTRUCTURA DE DATOS
OPERACIONES CON EL TDA
FACULTAD DE INGENIERIA MECANICA 2013
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
164 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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);} };
165 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
FECHA: 21 DE MARZO DE 2013
OBJETIVO: Desarrollar un ejemplo básico de POO */
#include<iostream.h>
#include<conio.h>
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_area( )
166 Ing.Ricardo Castañeda
Set_largo
Calcular _area
Set_ancho
PROGRAMACION ORIENTADA A OBJETOS 2013
{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
FECHA: 21 DE MARZO DE 2013
OBJETIVO: Desarrollar un ejemplo básico de POO */
#include<iostream.h>
#include<conio.h>
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);}
167 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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)
168 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
/* CODIGO: POOC8PROB1A
FECHA: 21 DE MARZO DE 2013
OBJETIVO: Primer programa ejemplo de una estructura clásica*/
#include<iostream.h>
#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
FECHA: 21 DE MARZO DE 2013
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 <iostream.h>
#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 => ";
169 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
cin >> n.nota2;
cout << " El promedio es = " << n.calcula_prom ( n.nota1, n.nota2);
getch( );
}
EJECUCION
PROGRAMA(C)/* CODIGO: POOC8PROB1C
FECHA: 21 DE MARZO DE 2013
OBJETIVO: Tercer programa realiza lo mismo que los anteriores pero usando clases y objetos*/
# include <iostream.h>
# 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.
170 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
SOLUCIÓN
PROGRAMA
/* CODIGO: POOC8PROB2
FECHA: 21 DE MARZO DE 2013
OBJETIVO: Programa que define la clase cuadrado y cubo, calculando el área del cuadrado, el área del cubo y el volumen. */
#include <iostream.h>
#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;
171 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
cout<<" Area = "<<C2.area()<<endl;
cout<<" Volumen = "<<C2.volumen()<<endl;
getch(); }
EJECUCION
EJERCICIOS PROPUESTOS
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.
172 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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á:
173 Ing. Ricardo Castañeda
class nombre_clase{
private: datos miembro funciones miembro
FACULTAD DE INGENIERIA MECANICA 2013
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
FECHA: 21 DE MARZO DE 2013
OBJETIVO: Programa de funciones que utilizan el operador de ambito */
#include <iostream.h>
#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
174 Ing.Ricardo Castañeda
class nombre_clase{
protected: datos miembro protegidos funciones miembro protegidos
public: datos miembro publicos funciones miembro publicos
PROGRAMACION ORIENTADA A OBJETOS 2013
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
175 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
PROGRAMA
/* CODIGO: POOC9E2
FECHA: 23 DE MARZO DE 2013
OBJETIVO: Programa que muestra los diferentes tipos de constructores*/
#include <iostream.h>
#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;
cout<<"dato2 = "<<d2.get_dato()<<endl;
cout<<"dato3 = "<<d3.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
176 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
}
~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
FECHA: 23 DE MARZO DE 2013
OBJETIVO: Programa que muestra los diferentes tipos de constructores y el destructor */
#include <iostream.h>
#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
177 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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 <iostream.h>
#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.
178 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
/* CODIGO: POOC9PROB1
FECHA: 23 DE MARZO DE 2013
OBJETIVO: Programa que calcula pagos considerando funciones construidas fuera
de la clase pero que trabajan con el operador ámbito :: */
#include <iostream.h>
#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); }
179 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
/* CODIGO: POOC9PROB2
FECHA: 23 DE MARZO DE 2013
OBJETIVO: Programa que maneja constructores de la clase caja. */
#include <iostream.h>
180 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
#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
/* CODIGO: POOC9PROB3
FECHA: 23 DE MARZO DE 2013
OBJETIVO: Programa que maneja la Aritmética de punteros*/
#include<iostream.h>
#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++)
181 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
{ 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
182 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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];
183 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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( ); }
};
184 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
/* CODIGO: POOC10PROB1
FECHA: 24 DE MARZO DE 2013
OBJETIVO: Programa que declara la clase empleado que es derivada de la clase base persona*/
#include<iostream.h>
#include<conio.h>
#include<string.h>
#include<stdio.h>
class persona // CLASE BASE
185 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
{ 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;
186 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
/* CODIGO: POOC10PROB2
FECHA: 23 DE MARZO DE 2013
OBJETIVO: Programa que trabaja con dos clases derivadas simulando dos sistemas de evaluacion de notas*/
#include<iostream.h>
#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); }
187 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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;
188 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
cout << " Practica 3 : "; cin>>al1.p3;
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;
cout << " Practica 2 : "; cin>>al2.p2;
cout << " Practica 3 : "; cin>>al2.p3;
cout << " Practica 4 : "; cin>>al2.p4;
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
/* CODIGO: POOC10PROB3
FECHA: 23 DE MARZO DE 2013
OBJETIVO: PROGRAMA QUE TRABAJA CON HERENCIA DE DOS CLASES BASES */
#include<iostream.h>
#include<conio.h>
189 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
#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];
190 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
/* CODIGO: POOC10PROB4
FECHA: 23 DE MARZO DE 2013
OBJETIVO: PROGRAMA QUE TRABAJA CON FUNCIONES AMIGAS */
#include<iostream.h>
#include<conio.h>
#include<string.h>
class empleado
{ private:
char nombre[20];
int codigo;
public :
empleado( char *nomb, int cod) // constructor
{ strcpy (nombre,nomb);
191 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
192 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
CAPITULO XI
193 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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<iostream.h>
# 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:
virtual float area( )
{ return (3.1416*par1*par1);}
};
class cuadrado : public figura
{ public:
virtual float area( )
{ 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++.
194 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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 <iostream.h>
#include <conio.h>
class duplicado
{public:
int x;
duplicado operator++ ()
{ x = x + x; return *this; }
};
195 Ing. Ricardo Castañeda
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 |=
FACULTAD DE INGENIERIA MECANICA 2013
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.
196 Ing.Ricardo Castañeda
/ * Ejemplo de sobrecarga de funciones * /
# include<iostream.h>
# 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(); }
PROGRAMACION ORIENTADA A OBJETOS 2013
SOLUCION
PROGRAMA
/* CODIGO: POOC11PROB1
FECHA: 23 DE MARZO DE 2013
OBJETIVO: Ejemplo de Polimorfismo con funciones virtuales */
#include<iostream.h>
#include<conio.h>
class figura
{ protected:
float par1;
public:
void set_par1( float p1)
{ par1 = p1; }
virtual float area( )
{ return (0) ; } };
class circulo : public figura
{ public:
virtual float area( )
{ return (3.1416*par1*par1); } };
class cuadrado : public figura
{ public:
virtual float area( )
{ 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
/* CODIGO: POOC11PROB2
FECHA: 23 DE MARZO
197 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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<iostream.h>
#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
/* CODIGO: POOC11PROB3
FECHA: 23 DE MARZO DE 2013
OBJETIVO: Función fecha recargada */
#include<iostream.h>
#include<conio.h>
#include<stdio.h>
void fecha(char *fecha);
198 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
/* CODIGO: POOC11PROB4
FECHA: 23 DE MARZO DE 2013
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<iostream.h>
#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;
199 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
cout<<"\t v2["<<i<<"]-> "<<v2[i].getx()<<" ";}
getch(); }
EJECUCION
200 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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.
201 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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;
202 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
}
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 <iostream.h>
#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];
cout<< " Ingrese practica 2: ";cin>>practica[1];
cout<< " Ingrese practica 3: ";cin>>practica[2];
cout<< " Ingrese practica 4: ";cin>>practica[3];
f01 << nombre << ' '
<< practica[0]<<' '
<< practica[1]<<' '
<< practica[2]<<' '
<< practica[3]<<endl; }
f01.close(); }
PROGRAMA 2
//POOC12E4
#include <iostream.h>
#include <fstream.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
void main()
{char *nomarch="practicas.txt";
ifstream f02;
203 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
int practica[10][4];
char nombre[10][10];
f02.open(nomarch);
for(int i=0;i<10;i++)
{ f02>>nombre[i];
f02>>practica[i][0];
f02>>practica[i][1];
f02>>practica[i][2];
f02>>practica[i][3]; }
f02.close();
for(int i=0;i<10;i++)
{ 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();
204 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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:
205 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
206 Ing.Ricardo Castañeda
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
PROGRAMACION ORIENTADA A OBJETOS 2013
c) /* POOC12E8
FECHA: 23 DE MARZO DE 2013*/
#include<iostream.h>
#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
207 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
208 Ing.Ricardo Castañeda
Constante Significado
ios:: beg Principio del archivo
ios:: cur Posición actual del archivo
ios:: end Fin del archivo
PROGRAMACION ORIENTADA A OBJETOS 2013
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
/* CODIGO: POOC12PROB1
FECHA: 23 DE MARZO DE 2013
OBJETIVO: Programa crea archivo de almacen */
/* PROGRAMA QUE CREA UN ARCHIVO COMPUESTO DE REGISTROS */
# include<iostream.h>
# 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 *) ®istro, sizeof(registro)); } // se graba registro
flusal.close ( ); } // se cierra archivo
EJECUCION
209 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
2.- Construya un programa que nos permita leer el archivo anteriormente creado.
SOLUCION
PROGRAMA
/* CODIGO: POOC12PROB2
FECHA: 23 DE MARZO DE 2013
OBJETIVO: Programa lee archivo de almacen */
# include<iostream.h>
# include<conio.h>
# include<fstream.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( )
{ 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;
210 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
gotoxy(2,cont);cout<< "================================================================";
cont=cont+2;
while ( ! fluent.eof( ) )
{ fluent.read( ( unsigned char *) ®istro, 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
/* CODIGO: POOC12PROB12
FECHA: 23 DE MARZO DE 2013
OBJETIVO: Lista proveedores de almacen */
# include<iostream.h>
# 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] ; };
211 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
void main( )
{ almacen registro ;
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 *) ®istro, 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
212 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
teluro char[9] ……………..Teléfono del proveedor
Solucion
PROGRAMA
/* CODIGO: POOC12PROB4
FECHA: 22 DE MARZO DE 2013
OBJETIVO: CREA Y MUESTRA ARCHIVO DE PROOVEDORES*/
#include<iostream.h>
#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<<"========================================";
213 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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:
214 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
/* CODIGO: POOC12PROB5
FECHA: 23 DE MARZO DE 2013
OBJETIVO: CONSULTA ITEM DE ALMACEN PARA INDICARME CUAL ES EL PROVEEDOR DEL PRODUCTO*/
#include<iostream.h>
#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
{ 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( )
{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 *) ®istro, sizeof(registro));
215 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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
/* CODIGO: POOC12PROB6
FECHA: 23 DE MARZO DE 2013
OBJETIVO: Consulta item de almacen para indicarme cual es el proveedor del producto, lista de proveedores */
#include<iostream.h>
#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( )
{ almacen registro ;
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 *) ®istro, sizeof(registro));
216 Ing.Ricardo Castañeda
PROGRAMACION ORIENTADA A OBJETOS 2013
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
/* CODIGO: POOC12PROB7
FECHA: 23 DE MARZO DE 2013
OBJETIVO: PROGRAMA ACTUALIZA UNIDADES DE UN REGISTRO */
# include<iostream.h>
# 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 ; } ;
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 *)®istro , sizeof(registro));
} while ( (! ff.eof( )) && strcmp(codx,registro.codalm) !=0 );
if( strcmp(codx,registro.codalm) ==0)
{gotoxy(30,2);cout<<"REGISTRO HALLADO";
217 Ing. Ricardo Castañeda
FACULTAD DE INGENIERIA MECANICA 2013
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 *)
®istro , sizeof(registro)); }
else
cout << "CODIGO NO HALLADO";
getch(); ff.close ( ); }
218 Ing.Ricardo Castañeda