Modelo de Informe para Prácticas 2020

UCSM Esc. Prof.
de Ingeniería de Sistemas INFORME DE PRÁCTICAS

Marzo - 2020 LENGUAJES DE
PROGRAMACIÓN II
Práctica N° 01
Elaborado por:
”
© IEEE 2013 The Institute of Electrical and Electronics Engineers, Inc.

Práctica N° 1: Estructuras, Archivos y Clases en C++
ii
GRUPO N° 1
PRÁCTICAS DE LENGUAJES DE PROGRAMACIÓN II
Presentado por:
iii
RECONOCIMIENTOS
La autora de este trabajo reconoce con gratitud a su mentor para este trabajo, al Ingeniero
Montesinos.
PALABRAS CLAVES
Clases, control de acceso, encapsulación, programación orientada a objetos, clases

abstractas
ÍNDICE
1. RESÚMEN 1
2. INTRODUCCIÓN.......................................................................................................1
3. MARCO TEÓRICO.....................................................................................................1
3.1 Abstracción de una entidad...............................................................................1
3.2 Encapsulamiento y ocultamiento de datos dentro de una clase.........................1
3.3 Métodos de servicio para las clases diseñadas.................................................1
4. EXPERIENCIAS DE PRÁCTICA................................................................................1
4.1 Primera Experiencia..........................................................................................1
5. CÓDIGO E …………………………………………………………………………………4
6. CONCLUSIONES.....................................................................................................15
7. CUESTIONARIO......................................................................................................15
ÍNDICE DE TABLAS Y FIGURAS
Figura N° 1: diagram de casos de uso................................................................................2

Tabla 1: Caso de uso N°1....................................................................................................2
Figura N° 2: Diagrama de clases........................................................................................3
Figura N° 3: Diagrama de flujo..........................................................................................5
Fig. 1. Example of a figure caption.....................................................................................9
1. RESÚMEN
Este documento trata los temas de abstracción de una entidad para ser representada en un
programa como una clase, encapsulamiento y ocultamiento de datos dentro de una clase. Ver las
relaciones de la herencia con los tipos de acceso que puede tener un miembro de clase. Métodos y
la manipulación de los atributos de la clase, las variables locales, los parámetros formales y
valores de retorno
2. INTRODUCCIÓN
Para poder comprender un problema es necesario el comprender los elementos que intervienen en
este, y también los datos o comportamientos que tienen dichos elementos. Es por eso que para
poder comprender un problema y poder resolverlo con programación orientada a objetos uno tiene
que poder definir clases (clases padres y clases hijas) para poder analizar debidamente un
problema.
3. MARCO TEÓRICO
3.1 Abstracción de una entidad
La abstracción nos sirve para poder discernir entre los detalles de los elementos (características o
comportamientos) que son importantes y los que no, nos permiten usar la herencia y aplicar los
modificadores de acceso.
3.2 Encapsulamiento y ocultamiento de datos dentro de una clase 1

El término de encapsulamiento de datos puede ser un debate, pues algunos los usan para referirse
al control de acceso y otros para referirse a “la capacidad de empaquetar datos con funciones que
te permitan poder crear un nuevo tipo de datos”.
La propiedad de ocultamiento de información significa que los objetos pueden saber cómo
comunicarse entre sí a través de interfaces bien definidas, pero por lo general no se les permite
saber cómo se implementan otros objetos; los detalles de la implementación se ocultan dentro de
los mismos objetos
3.3 Modificadores de acceso2

3.3.1 Public
Los miembros public de una clase base son accesibles dentro del cuerpo de esa clase base, y en
cualquier parte que el programa tenga un manejador (es decir, un nombre, referencia o apuntador)
para un objeto de esa clase base, o una de sus clases derivadas
3.3.2 Private
1
Eckel, Bruce, "Thinking in C++", 2da Edición, Prentice Hall, 2000.
2
Deitel, Paul J., Deitel, Harvey M., "Cómo Programar en C++", 6ta Edición, Ed. Pearson Educación, México 2009.
1
Los miembros private de una clase base son accesibles sólo dentro del cuerpo de esa clase base y
de las funciones friend de esa clase base.
3.3.3 Protected
El uso del acceso protected ofrece un nivel intermedio de protección entre el acceso public y
private. Se puede acceder a los miembros protected de una clase base dentro del cuerpo de esa
clase base, mediante los miembros y funciones friend de esa clase base y mediante los miembros y
funciones friend de cualquier base que se derive de esa clase base. Las funciones miembro de la
clase derivada pueden hacer referencia a los miembros public y protected de la clase base, con
sólo utilizar los nombres de los miembros.
4. EXPERIENCIAS DE PRÁCTICA
4.1 Primera Experiencia
Aprender sobre la abstracción en clases, el uso de la generalización para definir los atributos y
métodos de la clase padre. El uso de la especificación para poder definir los métodos y atributos
propios de las clases hijas.
El programa trata sobre herencia, tenemos la clase padre “persona”, y la clase hija “trabajador”,
esta clase “trabajador” es a su vez clase padre de las clases “albanil”, “gasfitero”, “pintor”.
4.1.1 Modelamiento de la solución clases
2
Figura N° 1: Diagramas de clase(UML)
5. CÓDIGO E
1.
2. /***************************************************************
3. * CODIGO : persona.h
4. * AUTOR :
5. * FECHA : 26/03/2019
6. * DESCRIPCION : clase persona, modela a la persona
7. ****************************************************************/
8. #ifndef PERSONA_H
9. #define PERSONA_H
3
/***************************************************************
* CODIGO : trabajador.h
* AUTOR :
* FECHA : 26/03/2019
* DESCRIPCION : clase persona, modela a la persona
****************************************************************/
#ifndef TRABAJADOR_H
#define TRABAJADOR_H
#include "persona.h"
#include <string>
using namespace std;
class Trabajador : public Persona

{
public:
Trabajador();
void ingresar();
void mostrar();
private:
int codigo;
float sueldo;
string area;
};
/***************************************************************
* CODIGO : albanil.h
* AUTOR :
* FECHA : 26/03/2019
****************************************************************/
#ifndef ALBANIL_H
#define ALBANIL_H
#include <string>
class Albanil : public Trabajador

{
public:
Albanil::Albanil();
void ingresar();
void mostrar();
private:
string categoria;
float jornal;
};
#endif
4
/***************************************************************
* CODIGO : gasfitero.h
* AUTOR :
* FECHA : 26/03/2019
* DESCRIPCION : clase persona, modela a la Gasfitero
****************************************************************/
#ifndef GASFITERO_H
#define GASFITERO_H
#include <string>
class Gasfitero : public Trabajador

{
public:
Gasfitero();
void ingresar();
void mostrar();
private:
string especialidad;
float bono;
};
#endif
/***************************************************************
* CODIGO : persona,h
* AUTOR :
#include <iostream>
* FECHA : 26/03/2019
#include <string>
****************************************************************/
usingPINTOR_H
#ifndef namespace std;
#define PINTOR_H
extern void manejaPersona(Persona juan)
{
#include <string>
cout << "DATOS DE LA PERSONA " << endl;
cout << "=================== " << endl;
juan.mostrar();
class Pintor : public
cout Trabajador
<< "INGRESAR DATOS DE LA PERSONA " << endl;
{ cout << "============================ " << endl;
public: juan.ingresar();
Pintor::Pintor();
cout << "DATOS DE LA PERSONA " << endl;
voidcout
ingresar();
<< "=================== " << endl;
voidjuan.mostrar();
mostrar();
} void pintar();
extern
voidvoid manejaPersona1(Trabajador juan)
lijar();
{ void aplicarBase();
private: cout << "DATOS DEL TRABAJADOR " << endl;
coutturno;
string << "==================== " << endl;
juan.mostrar();
float bonificacion;
}; cout << "INGRESAR DATOS DEL TRABAJADOR " << endl;
cout << "============================= " << endl;
juan.ingresar();
#endif
cout << "DATOS DEL TRABAJADOR " << endl;
cout << "==================== " << endl;
juan.mostrar();
}
extern void manejaPersona2(Pintor juan)
{ 5
cout << "DATOS DEL PINTOR " << endl;
cout << "================ " << endl;
juan.mostrar();
#include "trabajador.h"
#include "albanil.h"
#include "gasfitero.h"
#include "pintor.h"
#include "menu.h"
#include "manejarlo.h"
#include <iostream>
#include <string>
#define _CRT_SECURE_NO_WARNINGS

extern void manejaPersona(Persona);
int main()
{
const int nro = 6;
Menu uno("\t\t\tMENU\n\t\t\t====\n", nro);
Menu dos("\t\t\tMENU PINTOR\n\t\t\t===========\n", 4);
uno.cargarArchivoOpciones("menu.txt");
dos.cargarArchivoOpciones("menupintor.txt");
Trabajador luis;
Persona juan;
Albanil pedro;
Gasfitero jose;
Pintor mario;
//uno.ingresar();
int n = 0;
do{
uno.mostrar();
n = uno.elijeOpcion();
system("cls");
cout << n << endl;
switch (n)
{
case 1:
manejaPersona(juan);
break;
case 2:
manejaPersona1(luis);
break;
case 3:
dos.mostrar();
dos.elijeOpcion();
manejaPersona2(mario);
break;
case 4:
manejaPersona3(jose);
break;
case 5:
manejaPersona4(pedro);
break;
}
system("pause");
} while (n != nro);
system("pause");
return 0;
}
6
/***************************************************************
* CODIGO : trabajador.cpp
* AUTOR :
/***************************************************************
* CODIGO : pintor.cpp
* AUTOR :
* FECHA : 26/03/2019
* DESCRIPCION : Define los metodos de la clase Pintor
****************************************************************/
#include "pintor.h"
#include <iostream>
#include <string>
Pintor::Pintor()
{
turno = "";
bonificacion = 0;
}
void Pintor::ingresar()
{
Trabajador::ingresar();
fflush(stdin);
cout << "TURNO : ";
getline(cin, turno);
cout << "BONIFICACION : ";
cin >> bonificacion;
}
void Pintor::mostrar()
{
Trabajador::mostrar();
cout << "TURNO : " << turno << endl;
cout << "BONIFICACION : " << bonificacion << endl;
}
void Pintor::pintar()
{
float area = 0;
float tiempo = 0;
float precio = 0;
cout << "pintar casa : " << endl;
cout << "area : ";
cin >> area;
cout << "tiempo : ";
cin >> tiempo;
precio = area * tiempo;
}
void Pintor::lijar()
{
cout << "lijar pared : " << endl;
}
void Pintor::aplicarBase()
{
cout << "Taplicar base " << endl;
}
7
/***************************************************************
* CODIGO : persona.cpp
* AUTOR :
* FECHA : 26/03/2019
/***************************************************************
* CODIGO : menu.cpp
* AUTOR :
* FECHA : 26/03/2019
* DESCRIPCION : Define los metodos de la clase Menu
****************************************************************/
#include "menu.h"
#include "pintor.h"
#include <iostream>
#include <string>
Menu::Menu(string tit, int nroOpciones)

{
titulo = tit;
opciones = new string[nroOpciones + 1];
opcionElegida = 0;
this->nroOpciones = nroOpciones;
}
void Menu::ingresar()
{
for(int i = 0; i < nroOpciones; i++)
{
fflush(stdin);
cout << "ingresar opcion " << i+1 << ": ";
getline(cin, opciones[i]);
opciones[i] += '\n';
}
opciones[nroOpciones] += "\n\n\t\t\tElija una opcion:(1-";
opciones[nroOpciones] += std::to_string(nroOpciones);
opciones[nroOpciones] += "): ";
system("cls");
}
void Menu::mostrar()
{
system("cls");
cout << titulo << endl;
for (int i = 0; i <= nroOpciones; i++)
cout << "\t\t" << opciones[i];
}
int Menu::elijeOpcion()
{
do{
cin >> opcionElegida;
if (opcionElegida < 1 || opcionElegida > nroOpciones)
{
cout << "ERROR: ELIJA UNA OPCION ENTRE (1-";
cout << nroOpciones;
cout << ") ..." << endl;
}
} while (opcionElegida < 1 || opcionElegida > nroOpciones);

return opcionElegida;
}
8
void Menu::cargarArchivoOpciones(char* nombreArchivo)

{
FILE * archivo;
char cadena[80];
archivo = fopen(nombreArchivo, "rt");
for (int i = 0; i < nroOpciones; i++)

{
fgets(cadena, 80, archivo);

//copiar cadena al arreglo tipo string, opciones[i]
opciones[i].append(cadena);
opciones[i].append("\n\0");
cout << opciones[i];
//opciones[i] += '\n';
}
opciones[nroOpciones] += "\n\n\t\t\tElija una opcion:(1-";

opciones[nroOpciones] += "): ";
//system("cls");
/***************************************************************
* CODIGO : gasfitero.cpp
* AUTOR :
* FECHA : 26/03/2019
* DESCRIPCION : Define los metodos de la clase Gasfitero
****************************************************************/
#include "gasfitero.h"
#include <iostream>
#include <string>
Gasfitero::Gasfitero()
{
especialidad = "";
bono = 0;
}
void Gasfitero::ingresar()
{
fflush(stdin);
cout << "ESPECIALIDAD : ";
getline(cin, especialidad);
cout << "BONO : ";
cin >> bono;
}
9
void Gasfitero::mostrar()
{
void Menu::cargarArchivoOpciones(char* nombreArchivo)
{ Trabajador::mostrar();
cout <<
FILE * archivo;
"ESPECIALIDAD : " << especialidad << endl;
cout <<
char cadena[80];
"BONO : " << bono << endl;
} archivo = fopen(nombreArchivo, "rt");
/***************************************************************
for (int i = 0; i < nroOpciones; i++)
* CODIGO
{ : albanil.cpp
* AUTOR :
* FECHA : 26/03/2019
* DESCRIPCION fgets(cadena, 80, archivo);
: Define los metodos de la clase Albanil
//copiar cadena al arreglo tipo string, opciones[i]
****************************************************************/
opciones[i].append(cadena);
opciones[i].append("\n\0");
cout << opciones[i];
//opciones[i] += '\n';
#include "albanil.h"
}
#include <iostream>
opciones[nroOpciones]
#include <string> += "\n\n\t\t\tElija una opcion:(1-";
opciones[nroOpciones]
using namespace std; += "): ";
//system("cls");
Albanil::Albanil()
{ }
categoria = "";
/***************************************************************
jornal = 0;
*
} CODIGO : gasfitero.cpp
* AUTOR
void Albanil::ingresar() :
*
{ FECHA : 26/03/2019
* DESCRIPCION : Define los metodos de la clase Gasfitero
****************************************************************/
fflush(stdin);
cout << "CATEGORIA : ";
#include "persona.h"categoria);
getline(cin,
cout << "JORNAL : ";
#include
cin"gasfitero.h"
>> jornal;
}
#include <iostream>
void Albanil::mostrar()
#include
{ <string>
cout << "CATEGORIA : " << categoria << endl;
cout << "JORNAL : " << jornal << endl;
Gasfitero::Gasfitero()
}
{
especialidad = "";
bono = 0;
}
void Gasfitero::ingresar()
{
fflush(stdin);
cout << "ESPECIALIDAD : ";
getline(cin, especialidad);
cout << "BONO : ";
cin >> bono;
}
void Gasfitero::mostrar()
{
cout << "ESPECIALIDAD : " << especialidad << endl;
cout << "BONO : " << bono << endl;
10
27. **********************************************************
28. * CODIGO : menu.h
29. * AUTOR :
30. * FECHA : 26/03/2019
31. * DESCRIPCION : clase persona, modela al menu
32. ****************************************************************/
33. #ifndef MENU_H
34. #define MENU_H
35.
6. CONCLUSIONES
Conclusiones de la práctica:
 La encapsulación de datos se refiere al control de acceso, y al uso de private, protected y public
 Los diagramas UML nos ayudan a saber qué tipo de acceso tiene un miembro de clase y saber qué tipo
de variable guarda, atributo, o retorna (o recibe) método.
7. CUESTIONARIO
1. ¿En qué consiste la abstracción?
En deshacerse de los detalles de un problema para poder resolverlo.
2. ¿Qué papel juega la abstracción en el diseño de clases?
Nos ayuda a poder simplificar un problema complejo y poder tratarlo con objetos.
Además también nos ayuda a poder usar la herencia diferenciando los atributos y métodos
que se repiten y poder definir una clase padre y clases hijas.
3. ¿Cómo se usa la clasificación?
La clasificación se usa para poder definir de forma adecuada las clases hijas y la clase
padre.
4. ¿Cómo determinamos los atributos de clase a partir de la abstracción?
Para poder determinar los atributos de una clase, nos fijamos en características que sean
importantes para la comprensión y resolución del problema.
5. ¿Cómo la abstracción nos ayuda a determinar los métodos de clase?

11
La abstracción nos permite discernir entre los comportamientos de los objetos, que forman
parte del problema, y nos ayudaran a resolverlo.
6. ¿Qué es la generalización?
La generalización es tomar y/o definir un modelo que nos permita comprender y definir el
problema.
En herencia la generalización nos ayuda a poder saber que atributos y comportamientos se
repiten, y a partir de eso definir una clase padre con dichos métodos y atributos.
7. ¿Qué es la especificación?
Es hacer usos de los detalles para poder definir mejor el problema y para tratarlo.
En herencia la especificación nos ayuda a poder definir los métodos y atributos de las
clases hijas.
8. ¿En qué consiste la jerarquía de conceptos?
Consiste en que el concepto de la clase padre, lo tiene la clase hijo, aunque la clase hijo
tiene, aparte del heredado, un concepto propio.
9. ¿Qué es un método?
Es una función que se define dentro de una clase y puede trabajar con los atributos de
dicha clase.
10. ¿Qué es un mensaje?
Cada operación llamada por un objeto se interpreta como un mensaje al objeto, que utiliza
un método específico para procesar la operación.
11. ¿Qué es un método de servicio?
Es un método que permite que otros objetos consulten o modifiquen los atributos de los
objetos, las clases suelen presentar estos métodos.
12. ¿Qué es un método set?
Los métodos set se utilizan para establecer datos asociados a la clase.
13. ¿Qué es un método get?
Los métodos get se usan para recuperar datos contenidos en el objeto.
14. ¿Cómo actúa un método público?
Un método público es aquel que permite a otras clases externas acceder a sus datos.
15. ¿Cómo actúa un método privado?
Un método privado es aquel que permite el acceso a sus métodos, a través de datos
internos de la misma clase y no a través de clases externas.
16. ¿Cómo se logra cambiar el estado de un objeto?

El estado de un objeto se indica mediante los valores de todos los atributos del objeto, en
un momento dado.
17. ¿Qué es una función inline?3

Una función inline es igual que una función normal (excepto que su declaración viene
precedida por la palabra inline), que no genera código de llamada a función, sino que
sustituye las llamadas a la misma por el código de su definición. La principal ventaja frente
a las macros es que estas funciones si que comprueban el tipo de los parámetros. No se
12
pueden definir funciones inline recursivas (evidentemente, no podemos sustituir infinitas

veces su código).
18. ¿Qué diferencia existe entre los métodos externos y los métodos o funciones
insertadas?
Los métodos externos son los métodos que no están dentro de la clase y los insertados son
aquellos que están dentro de una clase.
19. ¿Qué es el encapsulamiento?
La encapsulación es un mecanismo que oculta información para facilitar el mantenimiento
y la comprensión del código.
20. ¿Qué es la interface de clase?3
De manera similar, la interfaz de una clase describe qué servicios pueden usar los clientes
de la clase y cómo solicitar esos servicios, pero no cómo lleva a cabo la clase esos
servicios. La interfaz de una clase consiste en las funciones miembro public de la clase
(también conocidas como servicios públicos).
21. ¿Qué ventajas de diseño de código proporciona el encapsulamiento?
La encapsulación nos permite restringir el acceso a los atributos y, a su vez, garantiza la
integridad de los datos que contiene un objeto.
22. ¿Cuál es el objetivo declarar private los atributos de clase?
Que dicho atributo solo pueda ser modificado dentro de la clase.
23. ¿Cómo se accede a atributos privados de un objeto?
A través de un método que esté definido dentro de la clase de dicho objeto.
24. ¿Cómo se cambia el valor de un atributo privado de un objeto?
Con un método que esté definido dentro de la clase.
25. ¿Qué ventajas trae la aplicación de ocultamiento de información a través de
interfaces?
Una de las principales ventajas de utilizar interfaces es el polimorfismo ya que separamos
la definición de los métodos de su implementación. Además cabe notar que nuestro objeto
ira cobrando forma a partir de la herencia de distintas interfaces que el mismo deberá ir
implementando a su debido Tiempo.
26. ¿Qué pasos se siguen para construir la interface?3
Una interface puede ser definida utilizando las palabras reservadas class, struct o interface.
El beneficio de utilizar struct o interface es que la visibilidad por defecto de la interface
será public mientras que si usamos una clase deberemos especificarlo explícitamente.
En c++ debe usarse una clase abstracta. En estas clases es típico definir métodos virtuales
sin implementar, es decir, métodos que dicen como debe ser el mensaje pero no qué se
debe hacer cuando se emplean con objetos del tipo base. Este mecanismo nos obliga a
implementar estos métodos en todas las clases derivadas, haciendo más fácil la
consistencia de las clases.
Pues bien, el C++ define un mecanismo para hacer esto (ya que si no lo hiciera deberíamos
definir esos métodos virtuales con un código vacío, lo que no impediría que declaráramos
subclases que no definieran el método y además permitiría que definiéramos objetos del
tipo base abstracto).
3
S. L. Talens. (1995, Jul.). Curso de Programación en C++ [Online]. Available: https://www.uv.es/sto/cursos/c++/curso95.pdf
13
27. ¿Cómo se hace uso de la interface una vez construida?

Solo se aclara que es un metodo virtual y se usa
28. ¿Qué diferencias existen entre el encapsulamiento y el encapsulamiento por

interfaces?
El encapsulamiento tiene que ver con la definición del control de acceso (private, public,
protected). Y el encapsulamiento por interfaces se refiere al hecho de definir interfaces y el
uso de clases abstractas.
14

Modelo de Informe para Prácticas 2020

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Modelo de Informe para Prácticas 2020

Cargado por

Copyright:

Formatos disponibles

UCSM Esc. Prof.

de Ingeniería de Sistemas INFORME DE PRÁCTICAS

© IEEE 2013 The Institute of Electrical and Electronics Engineers, Inc.

PRÁCTICAS DE LENGUAJES DE PROGRAMACIÓN II

Clases, control de acceso, encapsulación, programación orientada a objetos, clases

ÍNDICE DE TABLAS Y FIGURAS

Figura N° 1: diagram de casos de uso................................................................................2

3.2 Encapsulamiento y ocultamiento de datos dentro de una clase 1

3.3 Modificadores de acceso2

Figura N° 1: Diagramas de clase(UML)

6. * DESCRIPCION : clase persona, modela a la persona

class Trabajador : public Persona

class Albanil : public Trabajador

class Gasfitero : public Trabajador

using namespace std;

using namespace std;

using namespace std;

Menu::Menu(string tit, int nroOpciones)

} while (opcionElegida < 1 || opcionElegida > nroOpciones);

void Menu::cargarArchivoOpciones(char* nombreArchivo)

for (int i = 0; i < nroOpciones; i++)

fgets(cadena, 80, archivo);

opciones[nroOpciones] += "\n\n\t\t\tElija una opcion:(1-";

using namespace std;

28. * CODIGO : menu.h

30. * FECHA : 26/03/2019

31. * DESCRIPCION : clase persona, modela al menu

33. #ifndef MENU_H

34. #define MENU_H

5. ¿Cómo la abstracción nos ayuda a determinar los métodos de clase?

16. ¿Cómo se logra cambiar el estado de un objeto?

17. ¿Qué es una función inline?3

pueden definir funciones inline recursivas (evidentemente, no podemos sustituir infinitas

27. ¿Cómo se hace uso de la interface una vez construida?

28. ¿Qué diferencias existen entre el encapsulamiento y el encapsulamiento por

También podría gustarte