Guia 01 Algoritmos I Con Dev C Parte 01 PDF

UNIVERSIDAD NACIONAL JOSÉ MARÍA ARGUEDAS
Ley de Creación N° 28372 Resolución de Funcionamiento N° 280-2006-CONAFU
CARRERA PROFESIONAL DE INGENIERIA DE SISTEMAS
IMPLEMENTACIÓN DE ALGORITMOS
EN DEV C++ USANDO MÓDULOS
- GUÍAS DE PRÁCTICA -
MATERIAL PREPARADO PARA EL CURSO:
ALGORITMOS Y ESTRUCTURA DE DATOS
ELABORADO POR:
ING. EDWIN OCTAVIO RAMOS VELÁSQUEZ
ANDAHUAYLAS – PERÚ
Implementación de Algoritmos en Dev C++ usando módulos Univ. Nac. José María Arguedas
Carrera Profesional de Ingeniería de Sistemas Docente: Ing. Edwin O. Ramos Velásquez
PRESENTACIÓN
El presente trabajo es un compilado de guías de laboratorio preparado para ser utilizado por los
alumnos de la Carrera profesional de Ingeniería de Sistemas o de Ingeniería Informática en las
sesiones de un curso de Introducción a la programación. Nosotros, habilitamos este material para
los alumnos, de forma tal les sirva de guía en la resolución de ejercicios de programación.
La programación modular y/o estructurada, concibe que un programa está compuesto por un
conjunto de módulos o subprogramas; y, donde cada módulo está a cargo de una función
específica dentro de un software. Siendo que la forma más cómoda de desarrollar software
complejo es a través del uso de módulos o procedimientos, en el presente material, se aborda la
implementación de software desde esa óptica. El alumno notará que cada programa, ha sido
subdividido en por lo menos dos módulos. Esperamos que el alumno se acostumbre al uso de
procedimientos y/o funciones en sus programas, ya que su uso le ha de facilitar la implementación
de programas complejos.
Esperamos que el presente conjunto de guías de laboratorio sean de utilidad para absolver
muchas de las dudas que nuestros estudiantes nos han planteado en clase.
El profesor
Página 2 de 36
GUÍA DE LABORATORIO 01:

IMPLEMENTACIÓN DE ALGORITMOS EN DEV C++ 4.9.9.2
(USANDO PROCEDIMIENTOS)
OBJETIVO
 El alumno podrá crear una aplicación básica utilizando PROCEDIMIENTOS y/o
FUNCIONES en Dev C++ 4.9.9.2, tomando como referencia los diagrama de flujo.
DATOS PREVIOS
Para dar inicio a esta práctica, usted necesita contar con los siguientes elementos:
Paquete de software: devcpp-4.9.9.2_setup.exe (instalado)
METODOLOGIA
 Se presentará al alumno ejemplos de algoritmos en la forma de diagramas de flujo, y se
les solicitará su implementación en Dev C++.
 Se absolverán preguntas en la sesión de esta práctica de laboratorio.
NOTA:
Previamente, usted debería de crear un directorio de trabajo para el almacenamiento del
código fuente de sus programas (Podría ser por ejemplo “D:\Applicaciones C”).
DESARROLLO DE LA PRÁCTICA DE LABORATORIO
1. Implementar un programa que halle el promedio de dos números
Algoritmo_Promedio( ) void Algoritmo_Promedio()

{ //1. Declaración de variables
int A,
intB;A,
float
B; C;
float C;
INICIO
//2. Algoritmo
Leer A
printf("Leer el numero A: ");
scanf(“%d”, &A); &A);
scanf(“%d”,
Leer B
printf("Leer el numero B: ");
C = (A + B) / 2 scanf(“%d”, &B); &B);
scanf(“%d”,
C = (float(A) +float(B))/2;
Print:
C printf(“El Resultado es %f”, C);
FIN
}
//---------------------------------------
int main(int argc, char *argv[])
Programa_Principal( ) {
Algoritmo_Promedio();
INICIO
Algoritmo_Promedio();
Algoritmo_02();
Programa
//3. Congelar pantalla principal
Algoritmo_Promedio( ) printf("\n ");
system("PAUSE");
return EXIT_SUCCESS;
}
FIN
Página 3 de 36
2. Implementar un programa que dados dos números A y B, ambos leídos desde el teclado,
aplique el algoritmo de Euclides para hallar el Máximo Común Divisor, y que muestre su
resultado en pantalla.
#include <cstdlib>
HallarMCD(A,B: Integer): Integer #include <iostream>
Inicio
using namespace std;
SI IF NO int HallarMCD(int A, int B)

A>B { //1. Declaración de Variables
X=A X=B int x, y, R, MCD;
Y=B Y=A
int x, y, R, MCD;
if (A > B)
if {
(Ax >= B)
A;
R = X mod Y
{ =
y x B;
= A;
} y = B;
}
else { x = B;
MCD = Y
else y
{ =x A;
= B;
} y = A;
WHILE }
( R<>0)
R = x % y;
Hacer MCD = y;
X=Y while (R!= 0)
while
{ x(R = !=
y; 0)
Y=R
{yx==R; y;
R = xR;
y = % y;
R = X mod R ==xy; % y;
Y MCD
} MCD = y;
MCD = Y }
return MCD;
return (MCD) }
FIN //------- Programa Principal ----------

{ // 1. Declaración de variables
Programa Principal() int A, B, MCD;
int A, B, MCD;
INICIO
// 2. Algoritmo
printf("\n Leer A:");
Leer: A scanf("%d", &A);&A)
scanf(“%d”,
printf("\n Leer B:");
Leer: B scanf("%d", &B);
scanf(“%d”, &B)
MCD
MCD =
= HallarMCD(A,
HallarMCD(A, B);
B);
C = HallarMCD (A, B)
printf("\nElElResultado
printf("\n Resultadoes:
es:%d",
%d",MCD);
MCD);
Print: MCD system("PAUSE");

}
FIN
Página 4 de 36
3. Implementar un programa que dados dos números A y B, ambos leídos desde el teclado,
aplique el algoritmo de Euclides para hallar el Mínimo Común Múltiplo (MCM), y que muestre
su resultado en pantalla.
#include <cstdlib>
HallarMCM(A, B: Integer): Integer #include <iostream>
Inicio
SI IF NO int HallarMCM(int A, int B)

A>B { //1. Declaración de Variables
X=A X=B int x, y, R, MCD;
Y=B Y=A
int x, y, R, MCD;
if (A > B)
if {
(Ax >= B)
A;
R = X mod Y
{ =
y x B;
= A;
} y = B;
}
else { x = B;
MCD = Y
else y
{ =x A;
= B;
} y = A;
WHILE }
( R<>0)
R = x % y;
Hacer MCD = y;
X=Y while (R!= 0)
while
{ x =(R!=
y; 0)
Y=R
{
y = R;y;
x =
R = X mod
R y= =
x R;
% y;
Y MCD = x
R = y;% y;
} MCD = y;
MCD = Y }
MCD = MCD * x * y;
MCD = MCD * X * Y
return MCD;
return (MCD)
}
//------- Programa Principal ----------

FIN int main(int argc, char *argv[])
int
intA,A,B,B,
MCM;
MCM;
Programa Principal()
// 2. Algoritmo
INICIO printf("\n Leer A:");
scanf("%d",
scanf(“%d”,&A);
&A)
Leer: A printf("\n Leer B:");
scanf("%d",
scanf(“%d”,&B);
&B)
Leer: B
MCM = HallarMCM(A, B);
MCD = HallarMCD(A, B);
C = HallarMCM (A, B) printf("\n El

printf("\n El Resultado
Resultado es:
es: %d",
%d", MCM);
MCD);
system("PAUSE");
Print: MCD
}
FIN
Página 5 de 36
4. Implemente que lea desde el teclado un número N, y luego imprima en pantalla la siguiente
imagen:
1 1 1
1 2 1 2 1 2
1 1 2 3 1 2 3
1 2 1 2 3 4
Si N = 2 1 Si N = 3 1 2 3
1 2
1 Si N = 4
Solución:
Imprimir_Fila (Fila:Integer) #include <cstdlib>

#include <iostream>
INICIO
Print: Eoln
void Imprimir_Fila(int N)
{ //1. Declarar variables
For k = 1 --> Fila
int
intk;
k;string
strings;
s;
Print: k + ' ' //2. Algoritmo
printf("\n");
for
for(k
(k==1;1;kk<=
<=N;
N;k++)
k++)
printf("%d
printf("%d ",k);
",k);
FIN
}
//-------------------------------------
Imprimir_Triangulo(N:Integer)
void Imprimir_Triangulo(int N)
INICIO
{ //1. Declarar variables
int
int k;
k;
For k = 1 --> N
//2. Algoritmo
Imprimir_Linea(k) for (k
for (k == 1;
1; kk <=
<= N;
N; k++)
k++)
Imprimir_Fila(k);
Imprimir_Fila(k);
for (k = N-1; k >= 1; k--)
for (k = N-1; k >= 1; k--)
For k = N -1 --> 1 Imprimir_Fila(k);
Imprimir_Fila(k);
Bucle Decreciente
}
Imprimir_Linea(k)
// --- Programa principal ---

FIN { //1. Declarar Variables
int N;
int N;
Programa Principal ( ) // 2. Algoritmo
printf("\n Leer N: ");
INICIO
scanf(“%d”,
scanf("%d", &N);
&N);
Leer: N
Imprimir_Triangulo(N);
Imprimir_Triangulo(N);
Imprimir_Triangulo(N)
//3. Congelar la pantalla
printf("\n");
FIN
system("PAUSE");
}
Página 6 de 36
5. Implemente un programa que lea desde el teclado un número N, y obtenga el número romano
equivalente y lo imprima en pantalla.
A continuación solo mostramos los diagramas de flujo. Sugerimos al estudiante implementar

el respectivo código fuente en C++.
Programa Principal( ) IntToRomano(N:Integer ): String
Inicio Inicio
N = LeerDatos( )
R = IntToRomanoDecada(N)
R = IntToRomano( N )
return R
Imprimir(R) FIN
FIN
IntToRomanoDecada(N:Integer ): String
Inicio
Z = Integer( N/10 ) Parte entera de

la división N/10
CASE
(Z)
Z=0 Z=1 Z=2 Z=3 Z=4 Z=9
R = IntToRomanoUnidad(N - 0)
R = " X " + IntToRomanoUnidad(N -10)
R = " XX " + IntToRomanoUnidad(N - 20)
R = " XXX " + IntToRomanoUnidad(N - 30)
R = " XL " + IntToRomanoUnidad(N - 40)
R = " XC " + IntToRomanoUnidad(N - 90)
return R
FIN
Página 7 de 36
IntToRomanoUnidad(N:Integer ): String
Inicio
CASE
(N)
N=0 N=1 N=2 N=3 N=4 N=9
R=" " R="I" R = " II " R = " III " R = " IV " R="I"
return R
FIN
TAREAS:
Diseñe Usted 5 programas con sus respectivos diagramas de flujo, y a continuación realice su
implementación en C++.
Página 8 de 36

IMPLEMENTACIÓN DE ALGORITMOS RECURSIVOS DEV C++ 4.9.9.2
(USANDO FUNCIONES)
OBJETIVO
 El alumno podrá crear una aplicación donde se utilice la recursividad, tomando como
referencia los diagrama de flujo.
DATOS PREVIOS
METODOLOGIA
NOTA:

1. Implementar un programa que calcule el valor factorial de un número N, el cual es leído desde
el teclado, y que, imprima este valor en la pantalla.
Factorial (N:Integer ): Integer int Factorial(int N)
INICIO { //1. Declaración de variables
int
intF;F;
SI IF NO //2. Algoritmo
N=0
if (N == 0)
if (NF == 0)
= 1;
F=1 F = N * Factorial(N - 1) F = 1;
else
else F = N * Factorial(N-1);
Programa
F = N * Factorial( N );
return F; principal
}
return F //------------------------------------
FIN
int N, F;
int N, F;
// 2. Algoritmo
Programa_Principal( )
printf(“\nLeer N:”);
INICIO
scanf(“%d”, &N);
Leer:
N
FF == Factorial(N);
Factorial(N);
F = Factorial(N ) printf(“El Resultado es %f”, F);
Print:
//3. Congelar pantalla
F printf("\n ");
system("PAUSE");
FIN
}
Página 9 de 36
2. Implementar un programa que lea un valor N desde el teclado, y luego halle los N primeros
números Fibonacci.
Solución:
#include <cstdlib>
Fibonacci (N:Integer ): Integer #include <iostream>
INICIO
SI IF NO int Fibonacci(int N)
(N= 0) ò { //1. Declaración de variables
(N=1)
F=N
int F;
int F;
F = Fibonacci(N-1) + Fibonacci(N-2) //2. Algoritmo

if
if (N==0
(N==0 ||
|| N==1)
N==1)
F F= =N;
N;
else
else
return F
F F= =Fibonacci(N-1)+
Fibonacci(N-1)+Fibonacci(N-2);
Fibonacci(N-2);
FIN
return F;
}
Imprimir_Nros(N: Integer )
INICIO
//----------------------------
void Imprimir_Nros(int N)
{ //1. Declaracion de variables
for K =1 ---> N
int
intK,K,
f; f;
F = Fibonacci(k )
for
for (K
(K == 1;
1; K<=N;
K<=N; K++)
K++)
{ {f f
= =Fibonacci(K);
Fibonacci(K);
Print: printf(“%d, ”,”,f);
F
printf(“%d, f);
} }
}
FIN
//----- Programa principal -----
{
//1. Declaración de variables
Programa_Principal( ) int N;
int N;
INICIO // 2. Algoritmo
printf("\n Leer N:");
Leer: scanf("%d",
&N);
N
Imprimir_Nros(N);
Imprimir_Nros(N);
Imprimir_Nros (N )
FIN //3. Congelar pantalla

printf("\n ");
system("PAUSE");
}
3. Compile y ejecute la aplicación
TAREAS:
Implemente 3 programas en donde se utilice recursividad.
Página 10 de 36

IMPLEMENTACIÓN DE LIBRERIAS DE PROCEDIMIENTOS/FUNCIONES
EN DEV C++ 4.9.9.2
OBJETIVO
 El alumno podrá crear una aplicación donde se utilicen librerías de procedimientos en
C++.
DATOS PREVIOS
METODOLOGIA
NOTA:
SECCION 01: CREAR EL PROYECTO PREDETERMINADO

1. Crear un nuevo proyecto Dev C++.
a) Al crear el proyecto Dev C++, escoger la plantilla “Console Application”
Seleccionar la plantilla
“Console Application”
b) Crear el directorio ProyLibreria
Página 11 de 36
1. Usar el ícono “Crear

nueva carpeta”, para crear el
directorio “ProyLibreria”
2. directorio
“ProyLibreria” creado para
el nuevo proyecto
A continuación seleccionar el directorio recién creado para allí grabar todos los archivos
de este proyecto
3. Seleccionar el directorio
recién creado “ProyLibreria”
4. Presionar “Guardar”
para grabar el proyecto
c) Grabar todo.
Página 12 de 36
1. Presionar el botón
“Guardar todo”
Todos los archivos que se han de grabar, deberán ser grabados en el directorio “ProyLibreria”,
el cual usted creo en el paso anterior.
SECCION 02: AGREGAR UN ARCHIVO DE CABECERA (Librería *.h)
2. Seleccionar el ícono del proyecto “ProyLibreria”, y en el menú contextual que se mostrare,

seleccionar la opción “Nuevo Código Fuente”
1. Seleccionar la opción
“Nuevo Código Fuente”
Luego de esta acción se habrá creado un archivo denominado “Sin Nombre1”.
3. Cambiar el nombre del archivo “SinNombre1”, y asignarle el nuevo nombre “MyLibreria.h”.

Para hacer esto, seleccionar el ícono “Sin Nombre1”, y en el menú contextual seleccionar la
opción “Renombrar Archivo”, y luego escribir el texto “MyLibreria.h”
Página 13 de 36
2. Escribir el nuevo
nombre “MiLibreria.h”
“Renombrar Archivo”
3. Presionar el
botón “OK”
El aspecto de la interfaz será similar a la que se muestra:
4. Modificar el contenido del archivo “MyLibreria.h”, de forma que debería contener lo siguiente:
Archivo “MyLibreria.h”
#ifndef _MYLIBRERIA_H
#define _MYLIBRERIA_H
Sección
// Sección de código fuente
de
código
fuente
#endif
5. Presionar el botón “Guardar todo” (en el menú de la interfaz).
Página 14 de 36
SECCION 03: IMPLEMENTAR EL ALGORITMO EN LOS ARCHIVOS DEL PROYECTO
6. Implementar un programa que calcule el factorial de un número N, el cual es leído desde el

teclado, y que lo imprima en la pantalla (Utilizando librerías).
Factorial (N:Integer ): Integer Programa_Principal( )
INICIO INICIO
SI IF NO Leer:
N=0 N
F=1 F = N * Factorial(N - 1) F = Factorial(N )
Print:
F
return F
FIN
FIN
Nota: Aplicaremos la siguiente lógica, el programa principal será escrito El texto ”MYLIBRERIA”
en el procedimiento principal (“void main()”), mientras que los debe estar sincronizado
procedimientos y/o funciones serán escritos dentro de los archivos de con el nombre del archivo.
cabecera (archivos con extensión *.H)
(Si el nombre del archivo
Referencia al archivo Deberá agregar un archivo de cabecera (archivo “*.h”) al proyecto, cambia, este encabezado
donde se encuentran y modificar el archivo tal cual se muestra a continuación: también debe cambiar)
los procedimientos y/o
funciones a utilizar Archivo: main.cpp Archivo: MyLibreria.H
#include <cstdlib> #ifndef_MYLIBRERIA_H

#ifndef _MYLIBRERIA_H
#include <iostream> #define_MYLIBRERIA_H
#define _MYLIBRERIA_H
#include”MyLibreria.H”
#include “MyLibreria.H” /* -------------------------------
NOTA: El nombre del archivo
using namespace std; debe coincidir con el encabezado
anterior
-------------------------------
int main(int argc, char *argv[]) */
{ // 1. Declaración de variables using namespace std;
int N, F;
int Factorial(int N)
// 2. Algoritmo { //1. Declaración de variables
printf(“\nLeer N:”); int F;
scanf(“%d”, &N); //2. Algoritmo
F = Factorial(N); if (N == 0)
F = 1;
else
Llama a una función
//3. Congelar pantalla F = N * Factorial( N );
definida en una librería
printf("\n ");
system("PAUSE"); (en “MyLibreria.h”) return F;
Esto debe estar en la
última línea de
} }
código del archivo
#endif *.h
Página 15 de 36
Nota: El encabezado:
#include “MyLibreria.h”
Se escribe así por cuanto el archivo “Mylibreria.h” se encuentra en el mismo directorio del
main.cpp. si acaso el archivo “Mylibreria.h” estuviera en el directorio “include” del
paquete Dev C++, entonces debería escribirse así:
#include <MyLibreria.h>
7. Implementar un programa que lea desde el teclado un número N, y que luego imprima en
pantalla: “Es número PRIMO” o “No es número PRIMO” según corresponda.
ProgramaPrincipal( ) Es_Primo(N:Integer):Boolean
INICIO INICIO
Leer: E = true
N
For k = 2 -->N-1
H = EsPrimo( N )
SI IF NO
SI IF NO (N % K) = 0
¿ H = true ?
E = false
Print Print:
"Es Primo" "NO es primo"
return E
FIN FIN
Nota: No olvide, todos los procedimientos y/o funciones deben ser escritos en un archivo de
cabecera (archivo *.h)
TAREAS
Escriba 05 programas donde se utilicen archivos de cabecera (“*.h”) creados por el mismo
usuario.
Página 16 de 36

IMPLEMENTACIÓN DE LIBRERIAS DE CLASES
EN DEV C++ 4.9.9.2
OBJETIVO
 El alumno podrá crear librerías de clases a partir de diagramas de clase
 El alumno podrá utilizar las librerías de clase de manera adecuada.
DATOS PREVIOS
METODOLOGIA
 Se propondrá al alumno una estructura de clases para su implementación en java
(diagrama de clases mostrado al final de esta guía de laboratorio).
 Se plantearán una serie de pasos para implementar la estructura de clases
(diagrama de flujo presentado al final de esta guía de laboratorio).
 Se presentara un nuevo diagrama de clases y se solicitará al alumno que lo
implemente.
NOTA:
SECCION 01: CREAR EL PROYECTO PryClases
1. Crear un nuevo proyecto Dev C++ utilizando la plantilla “Console application”.
a) Al crear el proyecto Dev C++, escoger la plantilla “Console Application”
Seleccionar la plantilla
“Console Application”
Página 17 de 36
b) Crear el directorio PryClases
1. Usar el ícono “Crear

nueva carpeta”, para crear
el directorio “PryClases”
2. directorio “PryClases”
creado para el nuevo
proyecto
A continuación seleccionar el directorio recién creado para allí grabar todos los archivos
de este proyecto
3. Seleccionar el directorio
recién creado “PryClases”
4. Presionar “Guardar”
para grabar el proyecto
c) Grabar todo.
Página 18 de 36
1. Presionar el botón
“Guardar todo”
Todos los archivos que se han de grabar, deberán ser grabados en el directorio “PryClases”,
el cual usted creo en el paso anterior.
SECCION 02: CREAR TODAS LAS CLASES DEL MODELO (Archivos *.h)
a) Crear la clase TArena
2. Seleccionar el ícono del proyecto “PryClases”, y en el menú contextual que se
mostrare, seleccionar la opción “Nuevo Código Fuente”
“Nuevo Código Fuente”
Luego de esta acción se habrá creado un archivo denominado “Sin Nombre1”.
3. Cambiar el nombre del archivo “SinNombre1”, y asignarle el nuevo nombre

“claseTArena.h”. Para hacer esto, seleccionar el ícono “Sin Nombre1”, y en el menú
contextual seleccionar la opción “Renombrar Archivo”, y luego escribir el texto
“claseTArena.h”
Página 19 de 36
2. Escribir el nuevo
nombre “claseTArena.h”
3. Presionar el
3. Presionar
botón “OK” el
El aspecto de la interfaz será similar a la que se muestra: botón “OK”
4. Modificar el contenido del archivo “claseTArena.h”, de forma tal como se muestra:

Archivo “claseTArena.h”
#ifndef _CLASETARENA_H
#define _CLASETARENA_H
Sección
// Sección de código fuente
de
código
fuente
#endif
5. Escribir en la “sección de código fuente” del archivo la declaración del encabezado

de la clase TArena, tal como se muestra a continuación:
//-- SECCION 1. Declaración de referencias include
//-------------------------------------------------
//-- SECCION 2. Declaración del Encabezado de la Clase
class TArena{
Nombre de la
clase “TArena”
}; // El encabezado termina en Punto y Coma

//-------------------------------------------------
//-- SECCION 3. Implementación de las clases
b) Crear la clase TAsfalto

6. Repetir los pasos 2, 3, 4, y 5, pero en esta ocasión trabajar con la clase TAsfalto
c) Crear la clase THormigon

7. Repetir los pasos 2, 3, 4, y 5, pero en esta ocasión trabajar con la clase THormigon
d) Crear la clase TVidrio

8. Repetir los pasos 2, 3, 4, y 5, pero en esta ocasión trabajar con la clase TVidrio
Página 20 de 36
e) Crear la clase TEstación

9. Repetir los pasos 2, 3, 4, y 5, pero en esta ocasión trabajar con la clase TEstacion
f) Crear la clase TPista

10. Repetir los pasos 2, 3, 4, y 5, pero en esta ocasión trabajar con la clase TPista
g) Crear la clase TPared

11. Repetir los pasos 2, 3, 4, y 5, pero en esta ocasión trabajar con la clase TPared
h) Crear la clase TPiso

12. Repetir los pasos 2, 3, 4, y 5, pero en esta ocasión trabajar con la clase TPiso
i) Crear la clase TVentana

13. Repetir los pasos 2, 3, 4, y 5, pero en esta ocasión trabajar con la clase TVentana
j) Crear la clase TParabrisa

14. Repetir los pasos 2, 3, 4, y 5, pero en esta ocasión trabajar con la clase TParabrisa
k) Crear la clase TLente

15. Repetir los pasos 2, 3, 4, y 5, pero en esta ocasión trabajar con la clase TLente
16. Una vez terminado de crear las clases, modificar el archivo main.cpp, de forma tal que usando
la instrucción “include”, se haga referencia a todos los archivos “*.h” creados
Ejemplo:
#include “claseTArena.h”
#include “claseTAsfalto.h”
#include “claseTHormigon.h”
#include “claseTVidrio.h”
… etc.
17. Compile todo el proyecto con la opción del menú “EjecutarReconstruir todo”. Si hubieran
errores de codificación, deberá corregirlo.
El aspecto del proyecto es el que se muestra:
Página 21 de 36
SECCION 03: RELACIONAR TODAS LAS CLASES DE ACUERDO AL MODELO (Archivos *.h)
De acuerdo al modelo:
TArena es la superclase
TVidrio tiene como padre a TArena
TAsfalto tiene como padre a TArena
THormigon tiene como padre a TArena
TEstacion tiene como padre a TAsfalto
TPista tiene como padre a TAsfalto
TPared tiene como padre a THormigon
TPiso tiene como padre a THormigon
TVentana tiene como padre a TVidrio
TParabrisa tiene como padre a TVidrio
TLente tiene como padre a TVidrio
Realizaremos la relación en las clases hijo, modificando el encabezado de cada clase.
18. Abrir el archivo claseTVidrio.h, y modificar el encabezado de la clase, de forma tal que se
haga referencia a la clase de la cual es descendiente
//-- SECCION 1. Declaracion de referencias include

#include "claseTArena.h"
//-------------------------------------------------
class TVidrio: public TArena {

Nombre de la clase
Padre “TArena”
//-------------------------------------------------
19. Abrir el archivo claseTAsfalto.h, y modificar el encabezado de la clase, de forma tal que se
haga referencia a la clase de la cual es descendiente
#include "claseTArena.h"
//-------------------------------------------------
class TAsfalto: public TArena {

Nombre de la clase
Padre “TArena”
//-------------------------------------------------
20. Repetir el paso anterior, pero esta ocasión, para todas las demás clases del modelo
SECCION 04: SECCIONAR EL ENCABEZADO DE TODAS LAS CLASES EN TRES

SECCIONES (Archivos *.h)
a) las secciones de código son: prívate, protected y public
b) personalizaremos la sección public, y las segmentaremos en tres secciones:
 Sección Propiedades
 Sección Constructores y Destructores
 Sección Procedimientos y Funciones
Página 22 de 36
21. Modificar el encabezado de la clase TArena (archivo claseTArena.h) dejándolo tal como se
muestra:
class TArena{
private:
protected:
public:
//--- 1. Sección Propiedades
//--- 2. Sección Constructores y Destructores
//--- 3. Sección Procedimientos y Funciones
};
22. Modificar el encabezado de la clase TVidrio (archivo claseTVidrio.h) para dejarlo tal como se
muestra:
class TVidrio{
private:
protected:
public:
};
23. Repetir el paso anterior para las demás clases del modelo.
SECCION 05: PLANIFICAR LA IMPLEMENTACION DE CLASES SEGÚN EL MODELO DE

HERENCIAS
24. Bosquejar a manera de listado la secuencia que se seguirá para implementar todas las clases
del modelo.
Revisando el modelo de clases, empezando por el nodo raíz (clase TArena),
terminaremos en los nodos hojas (Clases que no tienen descendientes). La secuencia que
vamos a seguir es la siguiente:
a) Implementar la clase TArena
b) Implementar la clase TAsfalto
c) Implementar la clase THormigon
d) Implementar la clase TVidrio
e) Implementar la clase TEstacion
f) Implementar la clase TPista
g) Implementar la clase TPared
h) Implementar la clase TPiso
i) Implementar la clase TVentana
j) Implementar la clase TParabrisa
k) Implementar la clase TLente
SECCION 06: IMPLEMENTAR ITERATIVAMENTE TODAS LAS CLASES DEL MODELO

Para iniciar este paso, consideramos la secuencia estipulada en la planificación de clases( paso
anterior).
Página 23 de 36
25. Implementar la clase TArena.

Paso 6.0: Seleccionar la clase a implementar: La clase TArena.
TArena
#Densidad: Integer
-Color: String
+TArena()
+TArena(Densidad: Integer, Color: String)
+getDensidad(): Integer
+setDensidad(Value: Integer)
+getColor(): String
+setColor(Value: String)
+print(String s)
+println(String s)
Paso 6.1 Escribir las propiedades de la clase

Modificar la clase TArena (archivo claseTArena.h) y en la sección propiedades escribir
todas las propiedades de la clase.
class TArena {
//Sección 1. Propiedades
private:
string Color;
protected:
int Densidad;
public:
};
Nota: para utilizar el tipo de datos “string” se debe referenciar al espacio de
trabajo “std”. Esto se hace escribiendo la referencia en la parte superior del
archivo, de la forma siguiente:
Paso 6.2 y 6.3 Implementar el constructor sin parámetros, y el que tiene parámetros
class TArena {
private:
string Color;
protected:
int Densidad;
public:
TArena();
TArena(int Densidad, string Color);
};
//-------------------------------------------------
TArena::TArena()
{ this->Densidad = 0 ;
this->Color = "";
}
TArena::TArena(int Densidad, string Color)
{ this->Densidad = Densidad ;
this->Color = Color;
}
Página 24 de 36
Paso 5.4 Implementar los procedimientos y funciones de la clase
class TArena {
private:
string Color;
protected:
int Densidad;
public:
TArena();
TArena(int Densidad, string Color);

int getDensidad();
void setDensidad(int value);
string getColor();
void setColor(string value);
void print(string s);
void println(string s);
};
//-------------------------------------------------

TArena::TArena()
{ this->Densidad = 0 ;
this->Color = "";
}
TArena::TArena(int Densidad, string Color)
{ this->Densidad = Densidad ;
this->Color = Color;
}
//-- Procedimientos y funciones

int TArena::getDensidad()
{ return this->Densidad;
}
void TArena::setDensidad(int value)
{ this->Densidad = value;
}
string TArena::getColor()
{ return this->Color;
}
void TArena::setColor(string value)
{ this->Color = value;
}
void TArena::print(string s)
{ printf("%s", s.c_str());
}
void TArena::println(string s)
{printf("\n%s", s.c_str());
}
26. Implementar la clase TVidrio.

Paso 6.0: Seleccionar la clase a implementar: La clase TVidrio.
Página 25 de 36
TVidrio
-Opacidad: Integer
-Grosor: Integer
+TVidrio()
+TVidrio(Densidad: Integer, Color: String, Opacidad: Integer, Grosor: Integer)
+getOpacidad(): Integer
+setOpacidad(Value: Integer)
+getGrosor(): Integer
+setGrosor(Value: Integer)
+Traslucir()
+TraspasarImagen()
+getArea(): double
+getVolumen(): double

Modificar la clase TVidrio.h, (archivo claseTVidrio.h) y en la sección propiedades escribir
todas las propiedades de la clase.
private:
int Opacidad;
int Grosor;
protected:
public:
};
Nota: para utilizar el tipo de datos “string” se debe referenciar al espacio de
trabajo “std”. Esto se hace escribiendo la referencia en la parte superior del
archivo, de la forma siguiente:
Paso 6.2 y 6.3 Implementar el constructor sin parámetros, y el que tiene parámetros
private:
int Opacidad;
int Grosor;
protected:
public:
TVidrio();
TVidrio(int Densidad, string Color,
int Opacidad, int Grosor);
};
TVidrio::TVidrio():TArena()
{ this->Opacidad =0 ;
this->Grosor = 0;
}
TVidrio::TVidrio(int Densidad, string Color, int Opacidad,
int Grosor):TArena(Densidad, Color)
{ this->Opacidad = Opacidad ;
this->Grosor = Grosor;
}
Página 26 de 36
Paso 6.4 y 6.5, Implementar los procedimientos y funciones de la clase

private:
int Opacidad;
int Grosor;
protected:
public:
TVidrio();
TVidrio(int Densidad, string Color,
int Opacidad, int Grosor);
int getOpacidad();
void setOpacidad(int value);
int getGrosor();
void setGrosor(int value);
void Traslucir();
void TraspasarImagen();
double getArea();
double getVolumen();
};
//-------------------------------------------------
TVidrio::TVidrio():TArena()
{ this->Opacidad =0 ;
this->Grosor = 0;
}
TVidrio::TVidrio(int Densidad, string Color, int Opacidad,
int Grosor):TArena(Densidad, Color)
{ this->Opacidad = Opacidad ;
this->Grosor = Grosor;
}
//-- Procedimientos y funciones
int TVidrio::getOpacidad()
{ return this->Opacidad;
}
void TVidrio::setOpacidad(int value)
{ this->Opacidad = value;
}
int TVidrio::getGrosor()
{ return this->Grosor;
}
void TVidrio::setGrosor(int value)
{ this->Grosor = value;
}
void TVidrio::Traslucir()
{
}
void TVidrio::TraspasarImagen()
{
}
double TVidrio::getArea()
{ return 0;
}
double TVidrio::getVolumen()
{ return 0;
}
Página 27 de 36

Modificar el archivo TArena.h, y en la sección propiedades escribir todas las propiedades
de la clase.
public class TArena {
private:
string Color;
protected:
int Densidad;
public:

}
27. Repetir el paso anterior (Pasos 6.0, 6.1, 6.1, 6.2, 6.3, 6.4, 6.5) pero esta vez, para todas las
demás clases del modelo. Respetar la secuencia de implementación.
SECCION 07: CREACION DE LOS OBJETOS

28. Agregue los métodos “getClassName” y “getClassName_full” a todas las clases según se
indica:
a) A la superclase “TArena”. Agregar los métodos indicados en el encabezado, y luego
implementarlos (utilizar la palabra reservada virtual). Solamente en esta clase
agregaremos también el método “InstanceOf”, por cuanto es la superclase.
class TArena{
//------
virtual string getClassName();
virtual string getClassName_full();
//----
bool InstanceOf(string class_name);
};

string TArena::getClassName(){
return "TArena";
}
string TArena::getClassName_full(){
return "TArena";
}
bool TArena::InstanceOf(string class_name)

{ size_t found;
found = this->getClassName_full().find(class_name);
if (found!=string::npos)
return true;
else
return false;
}
b) A la clase “TVidrio”, agregarle los métodos indicados en el encabezado, y luego

implementarlos.
class TVidrio: public TArena{
//------
string getClassName();
string getClassName_full();
};
Página 28 de 36

string TVidrio::getClassName(){
return "TVidrio";
}
string TArena::getClassName_full(){
return TArena::getClassName_full() +" " +TVidrio::getClassName();
}
c) A la clase “TAsfalto”, agregarle los métodos indicados en el encabezado, y luego

implementarlos.
class TAsfalto: public TArena{
//------
};

string TAsfalto::getClassName(){
return "TAsfalto";
}
string TAsfalto::getClassName_full(){
return TArena::getClassName_full() + " " + TAsfalto::getClassName();
}
Clase Padre “TArena”
Clase Actual
d) A la clase “THormigon”, agregarle los métodos indicados en el encabezado, y luego

implementarlos.
class THormigon: public TArena{
//------
};

string THormigon::getClassName(){
return "THormigon";
}
string THormigon::getClassName_full(){
return TArena::getClassName_full() + " " + THormigon::getClassName();
}
Clase Padre “TArena”

Clase Actual
e) A la clase “TLente”, agregarle los métodos indicados en el encabezado, y luego
implementarlos.
class TLente: public TVidrio{
//------
};

string TLente::getClassName(){
return "TLente";
}
string TLente::getClassName_full(){
return TVidrio::getClassName_full() + " " + TLente::getClassName();
Página 29 de 36
}
f) A la clase “TParabrisa”, agregarle los métodos indicados en el encabezado, y luego
implementarlos.
class TParabrisa: public TVidrio{
//------
};

string TParabrisa::getClassName(){
return "TParabrisa";
}
string TParabrisa::getClassName_full(){
return TVidrio::getClassName_full() +" "+ TParabrisa::getClassName();
}
Clase Padre “TVidrio”

Clase Actual
g) A las demás clases del modelo, agregarle los métodos indicados en el encabezado, y
luego implementarlos(los métodos “getClassName” y “getClassName_full”). Proceder
de acuerdo al patrón propuesto.
29. Abrir el archivo main.cpp, y escribir en el programa principal una aplicación que sirva para
crear objetos de las clases del diagrama.

//------------------------------------------------
void print(string s)
{ printf("%s", s.c_str());
}
void println(string s)
{ printf("%s \n", s.c_str());
}
void println(int n)
{ printf(" %d \n", n);
}
void println(double d)
{ printf(" %f \n", d );
}
//------------------------------------------------
void Imprimir(TArena *O){
println("-------------------------------------- ");
print("la clase: "); println(O->getClassName());
print("la clase: "); println(O->getClassName_full());
if (O->InstanceOf("TArena")==true)
{ TArena *A = (TArena *) O;
print("El objeto es de color"); println(A->getColor());
print("Su densidad es: "); println(A->getDensidad());
}
if (O->InstanceOf("TVidrio"))
{
TVidrio *Vi = (TVidrio *) O;
print("Su opacidad es: " ); println(Vi->getOpacidad());
print("Su grosor es: " ); println(Vi->getGrosor());
print("El area es: " ); println(Vi->getArea());
print("El volumen es: "); println(Vi->getVolumen());
Vi->Traslucir();
Vi->TraspasarImagen();
}
Página 30 de 36
if (O->InstanceOf("TLente"))
{ TLente *L = (TLente *) O;
print("Su número es: "); println(L->getNumero());
print("Su diametro es: "); println(L->getDiametro());
L->AumentarImagen();
L->CentrarImagen();
}
if (O->InstanceOf("TParabrisa"))
{TParabrisa *P = (TParabrisa *) O;
print("Su Marca es: "); println(P->getMarca());
print("Su Largo es: "); println(P->getLargo());
print("Su Ancho es: "); println(P->getAncho());
P->CerrarVentana();
P->AbrirVentana();
}
if (O->InstanceOf("TVentana"))
{ TVentana *V = (TVentana *) O;
print("Su Largo es: "); println(V->getLargo());
print("Su Ancho es: "); println(V->getAncho());
print("La posicion es: "); println(V->getPosicion());
V->BloquearElViento();
}
if (O->InstanceOf("TPiso"))
{ TPiso *X = (TPiso *) O;
print("Se usa en: "); println(X->getUso());
print("Su Antiguedad es:"); println(X->getAntiguedad());
X->Resbalar();
X->Quebrarse();
}
if (O->InstanceOf("TAsfalto"))
{ TAsfalto *Y = (TAsfalto *) O;
print("El petroleo es: "); println(Y->getTipoPetroleo());
}
if (O->InstanceOf("THormigon"))
{ THormigon *H = (THormigon *) O;
H->Chorrearse();
H->Mezclar();
}
if (O->InstanceOf("TEstacion"))
{ TEstacion *E = (TEstacion *) O;
print("El area es: "); println(E->getArea());
}
if (O->InstanceOf("TPared"))
{ TPared *Pa = (TPared *) O;
print("La ubicacion es: "); println(Pa->getUbicacion());
print("La altura es: "); println(Pa->getAltura());
Pa->DarSoporte();
Pa->Proteger();
}
if (O->InstanceOf("TPista"))
{ TPista *Z = (TPista *) O;
print("La longitud es: "); println(Z->getLongitud());
print("El ancho es: "); println(Z->getAncho());
print("El area es: "); println(Z->getArea());
Z->AvanzarVehiculo();
Z->EmitirSenyales();
}
Página 31 de 36
}
{ //1. Declarar las variables
TArena *A, *B, *C, *D, *E, *F, *G;
// 2. Crear los objetos

A = new TPista(18,"Verde","Negro", 3, 10);
B = new TPiso(20, "Plomo", "Patio de casa", 5);
C = new TParabrisa(30, "Transparente",0,2,"Michelin", 3,1);
D = new TPared(12,"Azul","Perimetro", 2);
E = new TEstacion(15, "Amarillo", "Negro", 2.5);
F = new TVentana(12,"Transparente",1,3,5,2);
G = new TLente(11,"Transparente", 0,1,45,2);
// 3. Usar los objetos

Imprimir(A);
Imprimir(B);
Imprimir(C);
Imprimir(D);
Imprimir(E);
Imprimir(F);
Imprimir(G);
// 4. Destruir los objetos

delete A;
delete B;
delete C;
delete D;
delete E;
delete F;
delete G;
system("PAUSE");
}
30. Grabar todo y ejecutarlo.
TAREAS:
Implementar la siguiente estructura de clases.
Página 32 de 36
TMetal
TAparato THerramienta
-Material: String
-Marca: String -Solidez: double -Uso: String
-Peso: double -Antiguedad: Integer
+TMetal()
+TAparato() +TMetal(Material: String, Solidez: double) +getUso(): String
+TAparato(Material: String, ... Completar...) +getMaterial(): String +setUso(Value: String)
+getMarca(): String +setMaterial(Value: String) +getAntiguedad(): Integer
+setMarca(Value: String) +getSolidez(): double +setAntiguedad(Value: Integer)
+getPeso(): double +setSolidez(Value: double) +Levantar()
+setPeso(Value: double) +Tensar() +Utilizar()
+Apartar() +Endurecer()
TTanque TCanyon
-Calibre: double TLampa
-Modelo: String
-Ruedas: Integer -Largo: double
#Largo: Integer
+TCanyon() -Ancho: Integer
+TTanque()
+TTanque(Material: String, ...Completar ...) +TCanyon(Material: String, ...Completar...)
+TLampa()
+getModelo(): String +getCalibre(): double
+TLampa(Material: String, ...Completar...)
+setModelo(Value: String) +setCalibre(Value: double)
+getLargo(): Integer
+getRuedas(): Integer +getLargo(): double
+setLargo(Value: Integer)
+setRuedas(Value: Integer) +setLargo(Value: double)
+getAncho(): Integer
+Circular() +setAncho(Value: Integer)
+Atacar() +Lampear()
+Cargar()
TVajilla
TPicota
-Color: String
TCuchillo
-Pico: String
+TVajilla()
-Filo: String
+TPicota() +TVajilla(Material: String, ...Completar...)
+TPicota(Material: String, ...Completar...) +getColor(): String +TCuchillo()
+getPico(): String +setColor(Value: String) +TCuchillo(Materia: String, ...Completar...)
+setPico(Value: String) +Lavarse() +getFilo(): String
+Picotear() +Secarse() +setFilo(Value: String)
+Clavar() +Cortar()
+Enfilar()
TCuchara TPlato
+Peso: double -Diametro: double

-Volumen: double
+TCuchara()
+TCuchara(Material: String, ...Completar...) +TPlato()
+getPeso(): double +TPlato(Material: String, ...Completar...)
+setPeso(Value: double) +getDiametro(): double
+Cargar() +setDiametro(Value: double)
+getVolumen(): double
+setVolumen(Value: double)
+Servir()
+TomarElPlato()
Página 33 de 36
INICIO DESCRIPCION DE LOS PASOS A APLICAR

PARA LA IMPLEMENTACION DE CLASES
1
Crear el proyecto
2 En C++ debe crear un archivo de librería (archivo

Crear todas las clases del *.h) por cada clase (Le asignará al archivo el
Modelo (Escribir los mismo nombre de la clase pública, y le agregará la
encabezados de cada clase) extension "h", con el prefijo"class_")
La clase X tiene como padre a la clase Y. En
3 C++ se trata de usar las instrucciones:
Relacionar las clases - refencia: es decir include "class_Padre.h"
de acuerdo al Modelo - relacion de 2 clases
Ej: class TClaseHijo: public TClasePadre {
};
4
Seccionar todas los encabezados de todas las
clases en 3 secciones:
"Sección 1. Propiedades"
"Sección 2. Constructores/Destructores"
"Sección 3. Procedimientos y Funciones"
Planificar la implementación de clases Iniciar en el Nodo Raiz (Superclase

de acuerdo a las jerarquías definidas superior) y terminar en los nodos
5 del modelo hoja (Clases sin descendendientes)
6
Para k = 1 ----> N N = Número total de clases del modelo
-Las clases están ordenadas por la jerarquía

TMyClase = Clase(k)
definida por la ascendencia de clases
6.1
Escribir las propiedades -En la sección propiedades, definir todas las
de la clase variables de la clase
6.2 -Inicializar cada variable (Propiedad)

Declarar e Implementar el declarada en la clase
Constructor sin parámetros -Utilizar la instrucción "super()" para el
Ej: TMyClase() llamado al constructor del padre de la clase
-Declarar un parámetro por cada Propiedad

6.3 de la clase
-Inicializar cada variable (Propiedad) declarada
Declarar e Implementar el en la clase con el parámetro de contraparte
Constructor con parámetros -Utilizar la instrucción
Ej: TMyClase(par1, par2, ...) "TClasePadre(param1,para2, ...)" para el llamado
al constructor del padre de la clase. Transferirle
los parámetros que deben inicializar propiedades
de la clase padre y ascendientes
6.4
Declarar e Implementar los -Todos los procedimientos empiezan con
procedimientos de la clase
la palabra reservada "void"
"TMyClase"
6.5
Declarar e Implementar las -Todos las funciones empiezan con la palabra
funciones de la clase reservada "int" , "float", "string", ... etc. Toda
"TMyClase" función debe contener la palabra reservada
"return"
FIN
Página 34 de 36
TVi dr io TA r e n a
-Op a c i da d: Int ege r #D e ns i da d: Int ege r
-Gr os or : Int ege r -Co l or : St ring
Página 35 de 36
+T Vi dr io( ) +T A r ena ( )
+T Vi dr io( De ns i da d: Int ege r , Co l or : St ring, Op a c i da d: Int ege r , Gr os or : Int ege r ) +T A r ena ( De ns i da d: Int ege r , Co l or : St ring)
+g e t Op a c i da d( ): Int ege r +g e t De ns i da d( ): Int ege r
+s et Op a c i da d( Va l ue : Int ege r ) +s et De ns i da d( Va l ue : Int ege r )
+g e t Gr os or (): Int ege r +g e t Co l or (): St ring
+s et Gr os or (Va l ue : Int ege r ) +s et Co l or (Va l ue : St ring)
+T r as l uc i r() +p r int (St ring s)
+T r as pa s ar Ima ge n( ) +p r int ln( St ring s)
+g e t Ar ea ( ): do ubl e
+g e t Vo l ume n( ): do ubl e
TA s f al to
-Ti po Pe t rol eo : St ring

TL e n t e
Carrera Profesional de Ingeniería de Sistemas
+T A s f al to( )
-Nu me r o: do ubl e +T A s f al to( De ns i da d: Int ege r , Co l or : St ring, Ti po Pe t rol eo : St ring)
#D i ame t ro: do ubl e +g e t Ti po Pe t rol eo ( ): St ring
+T Lent e( )
+T Lent e( De ns i da d: Int ege r , Co l or : St ring, Op a c i da d: Int ege r , Gr os or : Int ege r ,THo
. . . )r mi go n
+g e t Nu me r o( ): do ubl e
+s et Nu me r o( Va l ue : do ubl e) TEs t a c i on
Implementación de Algoritmos en Dev C++ usando módulos
+C h o r rea r se( )
+g e t Di ame t ro( ): do ubl e -Ar ea : do ubl e
+Me z cl ar ()
+s et Di ame t ro( Va l ue : do ubl e)
+A u me nt ar Ima ge n( ) +g e t Ar ea ( ): do ubl e
+C e nt rar Ima ge n( )
+g e t Ar ea ( ): do ubl e
TPi st a
TPa r e d
-Longi tud: Int ege r
-Ub i cac i on: St ring -An c ho : Int ege r
TPa r a b r isa TVe n t a n a TPi so
-Al tur a: Int ege r
+g e t Longi tud( ): Int ege r
-Ma r ca: St ring -Lar go : Int ege r -Us o: St ring +s et Longi tud( Va l ue : Int ege r )
+D a r So po r te( )
-Lar go : Int ege r -An c ho : Int ege r -An t igue da d: Int ege r +g e t An c ho ( ): Int ege r
+P r ot ege r ()
-An c ho : Int ege r
+g e t Us o( ): St ring +g e t Ub i cac i on( ): St ring+s et An c ho ( Va l ue : Int ege r )
+B l oque a r El Vi ent o( )
+C e r rar Ve nt ana ( ) +g e t Al tur a( ): Int ege r +A v a nz ar Ve hi cul o( )
+g e t Po s i ci on( ): Int ege r +g e t An t igue da d( ): Int ege r +E mi tirSe ny a l es ()
+A b r irVe nt ana ( ) +g e t Ar ea ( ): do ubl e +R e s ba l ar ()
+g e t Ar ea ( ): do ubl e +g e t Lar go ( ): Int ege r +Q u e br ar se( ) +g e t Ar ea ( ): do ubl e
+g e t Ma r ca( ): St ring +g e t An c ho ( ): Int ege r
+g e t Lar go ( ): Int ege r
Estructura de clases a implementar utilizada en esta guía de prácticas
+g e t An c ho ( ): Int ege r
declaración de los constructores de manera incompleta. Usted debe completarlos.
NOTA: A excepción de las clases TArena, TVidrio, TAsfalto, todas las clases tienen la
Univ. Nac. José María Arguedas
Docente: Ing. Edwin O. Ramos Velásquez
BIBLIOGRAFÍA
CEVALLOS SIERRA, Francisco Javier. Enciclopedia del lenguaje C++. México,

Alfaomega Grupo Editor, S.A. de C.V., 2004.
FARRELL, Joyce. Introducción a la programación: Lógica y diseño. México,

International Thomson Editores, S.A. de C.V., 2000.
JOYANES AGUILAR, Luis. Fundamentos de Programación. México, McGraw –

Hill. 1999.
Página 36 de 36

Guia 01 Algoritmos I Con Dev C Parte 01 PDF

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Guia 01 Algoritmos I Con Dev C Parte 01 PDF

Hochgeladen von

Copyright:

Verfügbare Formate

UNIVERSIDAD NACIONAL JOSÉ MARÍA ARGUEDAS

Ley de Creación N° 28372 Resolución de Funcionamiento N° 280-2006-CONAFU

CARRERA PROFESIONAL DE INGENIERIA DE SISTEMAS

ING. EDWIN OCTAVIO RAMOS VELÁSQUEZ

GUÍA DE LABORATORIO 01:

Paquete de software: devcpp-4.9.9.2_setup.exe (instalado)

DESARROLLO DE LA PRÁCTICA DE LABORATORIO

1. Implementar un programa que halle el promedio de dos números

Algoritmo_Promedio( ) void Algoritmo_Promedio()

SI IF NO int HallarMCD(int A, int B)

FIN //------- Programa Principal ----------

Print: MCD system("PAUSE");

SI IF NO int HallarMCM(int A, int B)

//------- Programa Principal ----------

C = HallarMCM (A, B) printf("\n El

Imprimir_Fila (Fila:Integer) #include <cstdlib>

// --- Programa principal ---

A continuación solo mostramos los diagramas de flujo. Sugerimos al estudiante implementar

Programa Principal( ) IntToRomano(N:Integer ): String

Z = Integer( N/10 ) Parte entera de

Z=0 Z=1 Z=2 Z=3 Z=4 Z=9

R = " X " + IntToRomanoUnidad(N -10)

R = " XX " + IntToRomanoUnidad(N - 20)

R = " XXX " + IntToRomanoUnidad(N - 30)

R = " XL " + IntToRomanoUnidad(N - 40)

R = " XC " + IntToRomanoUnidad(N - 90)

N=0 N=1 N=2 N=3 N=4 N=9

GUÍA DE LABORATORIO 02:

DESARROLLO DE LA PRÁCTICA DE LABORATORIO

F = Factorial(N ) printf(“El Resultado es %f”, F);

F = Fibonacci(N-1) + Fibonacci(N-2) //2. Algoritmo

FIN //3. Congelar pantalla

3. Compile y ejecute la aplicación

GUÍA DE LABORATORIO 03:

DESARROLLO DE LA PRÁCTICA DE LABORATORIO

SECCION 01: CREAR EL PROYECTO PREDETERMINADO

a) Al crear el proyecto Dev C++, escoger la plantilla “Console Application”

b) Crear el directorio ProyLibreria

1. Usar el ícono “Crear

SECCION 02: AGREGAR UN ARCHIVO DE CABECERA (Librería *.h)

2. Seleccionar el ícono del proyecto “ProyLibreria”, y en el menú contextual que se mostrare,

Luego de esta acción se habrá creado un archivo denominado “Sin Nombre1”.

3. Cambiar el nombre del archivo “SinNombre1”, y asignarle el nuevo nombre “MyLibreria.h”.

El aspecto de la interfaz será similar a la que se muestra:

5. Presionar el botón “Guardar todo” (en el menú de la interfaz).

SECCION 03: IMPLEMENTAR EL ALGORITMO EN LOS ARCHIVOS DEL PROYECTO

6. Implementar un programa que calcule el factorial de un número N, el cual es leído desde el

Factorial (N:Integer ): Integer Programa_Principal( )

F=1 F = N * Factorial(N - 1) F = Factorial(N )

#include <cstdlib> #ifndef_MYLIBRERIA_H

scanf(“%d”, &N); //2. Algoritmo

GUÍA DE LABORATORIO 04:

DESARROLLO DE LA PRÁCTICA DE LABORATORIO

SECCION 01: CREAR EL PROYECTO PryClases

1. Crear un nuevo proyecto Dev C++ utilizando la plantilla “Console application”.

a) Al crear el proyecto Dev C++, escoger la plantilla “Console Application”

b) Crear el directorio PryClases

1. Usar el ícono “Crear

Luego de esta acción se habrá creado un archivo denominado “Sin Nombre1”.

3. Cambiar el nombre del archivo “SinNombre1”, y asignarle el nuevo nombre

4. Modificar el contenido del archivo “claseTArena.h”, de forma tal como se muestra:

5. Escribir en la “sección de código fuente” del archivo la declaración del encabezado

}; // El encabezado termina en Punto y Coma