UCSM Esc. Prof.

de Ingeniería de INFORME DE PRÁCTICAS

Sistemas

ABRIL- 2021 LENGUAJES DE

PROGRAMACIÓN II

Práctica N° 02
Elaborado por:
a) Nombre y Código
b) Carlos Elisban Huaman Quispe 2020243481
c) Maria Fernanda Huarcaya Quispe 2020243642
d) Bryan Carlos Tarqui Gomez 2017826151

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

Práctica N° 2:

ii
 GRUPO N° 2

PRÁCTICAS DE LENGUAJES DE PROGRAMACIÓN II

Presentado por:

- Carlos Elisban Huaman Quispe 2020243481

- Maria Fernanda Huarcaya Quispe 2020243642
- Bryan Carlos Tarqui Gomez 2017826151
RECONOCIMIENTOS

El autor de este trabajo reconoce con gratitud a los creadores de los lenguajes C, C++ y
otras personalidades y autores de libros de programación Bjarne Stroustrup, Dennis
Ritchie, Herb Sutter, Herb Sutter, James Gosling, James Gosling, Brian Kernighan, Brian
Kernighan, Ken Thompson.

PALABRAS CLAVES

Abstracción, Método, Encapsulamiento, Get, Set

ÍNDICE

1. RESUMEN……………………………………………………………………………………………………7
2. INTRODUCCION……………………………………………………………………………………………7
3. MARCO TEORICO……………………………………………………...................................................8
3.1 ………………………………………………………………………………………………8
3.1.1 Arreglo de estructuras……………………………………………………………………….…..9
3.1.2 Ámbitos de acceso a miembros de estructura……………………………………………….10
3.1.3 Punteros…………………………………………………………………………………………..11
3.2 Archivos………………………………………………………………………………………………...12
3.2.1 Archivo de lectura……………………………………………………………………………….13
3.2.2 Archivo de escritura……………………………………………………………………………..14
3.2.3 Archivo de acceso secuencial………………………………………………………………….15
3.2.4 Archivo de acceso aleatorio…………………………………………………………………….16
3.3 Clases…………………………………………………………………………………………………….17
4. MODELAMIENTO…………………………………………………………………………………………...18
5. EXPERIENCIAS PRACTICAS……………………………………………………………………………..18
6. CONCLUSIONES DE LA PRACTICA…………………………………………………………………….25
7. CUESTIONARIO…………………………………………………………………………………………….25
8 BIBLIOGRAFIA………………………………………………………………………………………………27
8.1.Del cuestionario…………………………………………………………………………………………27
8.2 Del Marco teórico………………………………………………………………………………………..27
25
Práctica N° 9: Manejo de Excepciones

1. RESÚMEN

En esta segunda práctica se profundizara temas que están muy vinculados a los elementos que están dentro
de las clases. Primero nos enfrascaremos en los atributos, aquel elemento que da una característica
particular a nuestra clase. Es en base a ello que muchos programadores seleccionan los atributos más
importantes y resaltantes de la clase. Por eso se explicara el tema de la “Abstracción”, un tema vital, que
ayuda a saber que atributos son los más adecuados al momento de realizar una clase.
Luego se hablará de los mensajes, para ello es fundamental conocer y saber generar el “Get” y el “Set”. El
“Set” tiene la función de definir valores a los atributos de la clase, por medio del método principal. En
cambio el “Get” usualmente es utilizado para retornar los valores definidos.
Por último, indagaremos el tema de la “Encapsulación”, un tema crucial que sirve para ocultar nuestros
atributos. Para ello, es necesario definir los atributos otorgándoles un acceso privado. De esta manera, no
será muy fácil acceder por medio del método principal.

2. INTRODUCCIÓN

Para formar pilares en el aprendizaje de la POO, es necesario saber más a fondo las funcionalidades de los
elementos que se pueden declarar dentro de las clases. Dicho esto, se puede afirmar que muchos
programadores son excelentes al momento de declarar dentro del código, pero solo pocos conocen técnicas
que brindan a su código mayor seguridad, conformidad a sus clientes y menos horas de trabajo al
programador. Es claro, que aquellas técnicas van optimizándose al pasar de los años, es por esa razón que
en este informe se informará las ventajas de aquellos temas que ayudan a los programadores a perfeccionar
una clase.
Partiendo del tema de clases, muchos saben que esto sirve para moldear un objeto. Unos de sus
componentes que ayuda a resaltar una diferencia con las demás clases, son los atributos. En base a esto se
pueden decir existen atributos que a pesar de pertenecer a una misma clases, esto son diferentes tanto en
sus accesos como Privados y como Públicos, con diferentes tipos como enteros, flotantes, etc. Por ende se
puede argumentar que una clase, puede tener una gran cantidad de atributos.
En base al párrafo anterior, dentro del contenido de este informe, se investigara puntos importantes de la
“Abstracción”, ya que esto ayuda a que el programador al momento de declarar una clase y añadir sus
atributos, este selecciona e incluye aspectos importantes para su clase y así cumplir su objetivo. Esto se
puede notar en el artículo titulado “La importancia de la abstracción en la informática”, puesto que Serna
(2011) menciona que “Las habilidades de la abstracción son esenciales en la construcción de modelos,
diseños e implementaciones apropiadas para cumplir el propósito” (p.123).
Otro tema importante, es la “Encapsulación”. Este tema brinda al programador a que sus atributos sean más
resguardados y no puedan ser modificados fácilmente. Además este tema, nos introduce al tema de
“Herencia”, ya que ahí cada clase general, resguarda un atributo privado. Sierra menciona que “Para poder
encapsular es necesario que los miembros a menudo se especifiquen como public, protected o private y asi
determinar si están disponibles para todas las clase, subclases o solo la definición de las clases”(p.22), en
base a esta cita es por donde el tema de la “Encapsulación”, toma importancia al momento de declarar una
clase con sus atributos. Todo esto se profundizara dentro del marco teórico.
Por tal motivo, este informe tiene como objetivo informar acerca de estos temas, brindar ejemplos por
medio de ejemplo como código y modelamientos. A su vez, busca compartir experiencias prácticas donde
se pudo poner a prueba aquellos temas.

7
Práctica N° 1: Estructuras, Archivos y Clases en C++

3. MARCO TEÓRICO
3.1 Clases
¿QUÉ ES? ¿CÓMO SE DECLARA? ¿CÓMO LO ¿CUÁNDO LO USO?
USO?
Es un tipo de datos definido La clase se declara con la Una clase se usa cuando se
por el usuario que tiene sus palabra clave que es Class [1] Sintaxis quiere especificar la forma de un
propios miembros de datos y #include <iostream> objeto y combina la
funciones. Estos se pueden Class (Palabra clave) Cclase representación de datos y los
acceder y usar creando una (nombre definido por el usuario) métodos para poder manipular
instancia de esa clase. [1] { eso datos de manera ordenado.
Acceso especificado: [2]
La clase en C++ es como el Privados, públicos y protegidos
plano de un objeto. Miembros de datos:
Variables Si desea definir un mismo tipo
No define ningún modelo para Miembros de funciones () de variable con muchas
un tipo de datos, define lo que Miembros de acceso de datos de propiedades, puede usar clases.
sígnica el nombre definido por …miembros [2]
el usuario, en que consiste un }
objeto de clases y que // Cuerpo de función
operaciones se realiza en dicho Terminación de clases con punto y
objeto. [1] coma.

Una clase es un mecanismo de

vinculación de miembros de
datos y métodos de asociación
en una sola unidad.[2]

1
3.1 Accesos especificados
¿QUÉ ¿CÓMO SE DECLARA? ¿CÓMO LO ¿CUÁNDO LO USO?
ES? USO?
Privados Sintaxis
Si no se especifica ningún El acceso especificado se usa Class (Palabra clave) Cclase Lo usamos en la clase sino no se
especificador para los dentro de la clase con la palabra (nombre definido por el usuario) puede acceder fuera la clase. [2]
miembros de clases estos se clave PRIVATE. {
consideran privados. Acceso especificado:
Privados, públicos y protegidos
Se puede acceder utilizando }
las funciones de miembros // Cuerpo de función
de th.[2] Terminación de clases con punto y
coma.

Públicos
Una función o miembros de El acceso especificado se usa Sintaxis Lo usamos en la clase ya se
datos que se define como dentro o fuera de la clase con la Class (Palabra clave) Cclase dentro o fuera de la clase a
público puede ser accesible palabra clave PUBLIC. (nombre definido por el usuario) través del objeto y el operador
para los que están fuera de { de punto. [3]
la clase. [3] Acceso especificado:
Privados, públicos y protegidos
}
// Cuerpo de función
Terminación de clases con punto y
coma.
Protegidos Sintaxis
Es accesible para la propia El acceso especificado se usa Class (Palabra clave) Cclase Se usa en casos de herencia. [3]
clase y las clases secundaria dentro de la clase con la palabra (nombre definido por el usuario)
de dicha clase. clave PROTECTED. {
Acceso especificado:
Es similar al especificador Privados, públicos y protegidos
privado de la manera que no }
se puede acceder fuera de la // Cuerpo de función
clase. [3] Terminación de clases con punto y
coma.

1
3.2 Abstracción
¿QUÉ ¿CÓMO SE DECLARA? ¿CÓMO LO USO? ¿CUÁNDO LO USO?
ES?

La clase abstracta se deben Se declara una o más La abstracción no se usa explícitamente en el La clase abstracción son
proporcionar una definición funciones virtuales código sino implícita, esenciales para proporcionar
para función.[4] una abstracción al Código que
lo haga reutilizable y
La subclase se convertiría ampliable. [4]
en una clase abstracta en si
misma

La abstracción como
proceso nos permite percibir
los atributos esenciales de
un objeto. [4]

1
3.3 Encapsulamiento
¿QUÉ ¿CÓMO SE DECLARA? ¿CÓMO LO ¿CUÁNDO LO USO?
ES? USO?
La encapsulación se define Esta muestra el salario del empleado y Encapsulamiento se usa cuando
como la agrupación de datos usamos el set y get. diseño interno, utilizado en
e información en una sola #Include <iostream> términos de implementación. [6]
unidad. [5] Using namespace std;
Class CEmpleado {
Se define más como unir Private:
datos y las funciones que //Atributo privado
los manipulan. Int salario;

Este significa ocultar los

detalles internos o la
mecánica de un objeto se
hace. [5]
Setter //esta toma al s y lo asigna al salario
Public:
Son como un tipo de El setter se usa con la palabra //Setter Este lo usamos cuando
contenedor asociado a los clave SET Void setsalario(int s){ queremos almacenar valores,
elementos que tienen que salario = s; pero este no se puede modificar
ser único ya que el valor del } una vez que ya se agrega al
elemento lo identifica. [6] conjunto [6]

Getter Este devuelve el salario en privado. Este lo usamos cuando

//Getter queremos almacenar un carácter
Este lee los caracteres del El getter se usa con la palabra Int getsalario(){ leído en la variable. [7]
stdin y los contiene como clave GET return salario;
una cadena C en str [7] }
};
Int main(){
CEmpleado E1;
E1.sersalario(2500);
1
 Cout << E1.getsalario ();
return 0;
}

3.4.1 Constructores
¿QUÉ ¿CÓMO SE DECLARA? ¿CÓMO LO ¿CUÁNDO LO USO?
ES? USO?

Es una función miembros de Cuando se defina el cuerpo del Este es la clase podemos ver como se Se usa para inicializar los
una clase que inicializa constructor usamos el parámetro usa la constructora. miembros de datos y construir el
objetos de una clase. [8] para inicializar el objeto. [8] Class Cubo { objeto de la clase. El compilador
Int side; lo llama automáticamente
El constructor cuando se Public: cuando se crea el objeto. [8]
crea un objeto. Es una Cubo () // Constructor
función miembro especial {
de la clase. Cout <<” Llamado al constructor”;
}
Los constructores tienen el };
mismo nombre de la clase.
[8]

No tienen tipo de retorno y

es una función pública de
clase.

1
3.4.2 Destructores
¿QUÉ ¿CÓMO SE DECLARA? ¿CÓMO LO ¿CUÁNDO LO USO?
ES? USO?

1
La función miembro Este debe declararse en la sección Class Cubo { El compilador crea un destructor
destructor elimina un objeto publica de la clase. Int side; cuando asignamos memoria o
y este se llama Public: puntero en la clase. [9]
automáticamente cuando se
destruye.[9] ~cubo () // Destructor
{
El destructor no tiene Cout <<” Llamado al destructor”;
argumentos y ningún tipo de }
devolución ni siquiera nulo. };

El programador no puede
acceder a la dirección del
destructor.[9]

1
 Práctica N° 2: Manejo de Excepciones

4. MODELAMIENTO

5.EXPERIENCIAS DE PRÁCTICA 
#pragma once
#include <iostream>
#include <string>

using namespace std;

// Clase Base
class estudiante
{
private:
string nombre;
int edad;
int dni;
string sexo;
int codigo;

public:
Persona();
~Persona();

string getNombre;
void setNombre(string nom);
int getEdad;

1
5
 Práctica N° 2: Manejo de Excepciones
void setEdad(int e);
int getDni;
void setDni(int d);
string getSexo;
void setSexo(string s);
int getCodigo;
void setCodigo(string c);

void ingresar();
void mostrar();
};

#include <iostream>

using namespace std;

struct entero
{
private:
int valor;
public:
void ingresar();
void mostrar();
entero sumar(entero);
entero* restar(entero*);
};

#include "entero.h"
#include <iostream>

using namespace std;

int main()
{
entero uno, segundoEntero, tercerEntero, * cuaertoEntero;
uno.ingresar();
segundoEntero.ingresar();
tercerEntero = uno.sumar(segundoEntero);
tercerEntero.mostrar();
segundoEntero.mostrar();
cuaertoEntero = uno.restar(&segundoEntero);
cuaertoEntero->mostrar();
segundoEntero.mostrar();
system("pause");
return 0;
}

#include <iostream>
#include<cstring>

using namespace std;

class Cpersona
{
private:
string nombre;
int edad;
public:
1
6
 Práctica N° 2: Manejo de Excepciones
Cpersona(int _edad, string nombre1);
void leer();
void Correr();

};

#include <cstring>

using namespace std;

Cpersona::Cpersona(int _edad, string nombre1)
{
this->edad = _edad;
this->nombre = nombre1;
}
void Cpersona::leer()
{
cout << " soy " << this->nombre
<< " y estoy corriendo la maraton y tengo "
<< this->edad << endl;

}
void Cpersona::leer()
{
cout << " soy " << this->nombre
<< " y estoy leyendo un libro "

#include<iostream>
#include "persona.h"

int main()
{
Cpersona p1 = Cpersona(20, "Fulano");
Cpersona p2(19, "pedro");
Cpersona p3(21, "Antonio");

p1.leer();
p2.Correr();
p3.leer();
p3.Correr();

return 0;

#pragma once
class Rectangulo
{
private:
float largo, ancho;
public:
Rectangulo(float, float);
void perimetro();
void area();

};

#include "Rectangulo.h"

1
7
 Práctica N° 2: Manejo de Excepciones
#include <iostream>

using namespace std;

Rectangulo::Rectangulo(float _largo, float _ancho)

{
largo = _largo;
ancho = _ancho;
}
void Rectangulo::perimetro()
{
float _perimetro;
_perimetro = (2 * largo) + (2 * ancho);
cout << "El perimetro es: " << _perimetro << endl;
}
void Rectangulo::area()
{
float _area;
_area = largo * ancho;
cout << "El area es: " << _area << endl;

#include <iostream>
//#include <stdlib.h>
#include "Rectangulo.h"
using namespace std;
int main() {
Rectangulo r1(11, 7);
r1.perimetro();
r1.area();
system("pause");
return 0;
}

#pragma once
class Cuadrado
{
private:
float lado;
public:
Cuadrado(float);
void perimetro();
void area();
};

#include "Cuadrado.h"
#include <iostream>
using namespace std;

Cuadrado::Cuadrado(float _lado)
{
lado = _lado;
}

void Cuadrado::area()
{
float _area;
_area = lado * 2;
cout << "El area es: " << _area << endl;
}

1
8
 Práctica N° 2: Manejo de Excepciones

void Cuadrado::perimetro()
{
float _perimetro;
_perimetro = lado*4;
cout << "El perimetro es: " << _perimetro << endl;

#include <iostream>
//#include <stdlib.h>
#include "Cuadrado.h"
using namespace std;
int main() {
Cuadrado c1(11,11);
c1.perimetro();
c1.area();
system("pause");
return 0;

#include <iostream>

using namespace std;

#define true 1
#define false 0

class OtraClase
{
bool privateVar; //acceso privado por defecto
public:
void setPrivateVar(bool newval); //metodo set
void getPrivateVar(void); //metodo get
};

#include "COtherClass.h"
#include <iostream>

void OtraClase::setPrivateVar(bool newval)

{
privateVar = newval;
}
bool OtraClase::getPrivateVar(void)
{
return privateVar;

#include "COtherClass.h"
#include <iostream>

using namespace std;

#define true 1
#define false 0

int main()
{
OtraClase obj;
1
9
 Práctica N° 2: Manejo de Excepciones

obj.setPrivateVar(true);
cout << obj.getPrivateVar() << endl;
obj.setPrivateVar(false);
cout << obj.getPrivateVar() << endl;

return 0;

#pragma once
//CVehicle.h
// Definir una clase base para vehiculos
class CVehicle {

int ruedas;
int pasajeros;

public:
void set_ruedas(int num);
int get_ruedas();
void set_pasajeros(int num);
int get_pasajeros();

};
class truck :public CVehicle {
int charge;
public:
void set_charge(int size);
int get_charge();
void mostrar();
};
enum kind
{
car, van, pickup_truck
};
class automobile :public CVehicle {
enum kind kind_of_car;
public:
void set_kind(kind k);
enum kind get_kind();
void mostrar();

};

//CVehicle.cpp
#include "CVehicle.h"
#include <iostream>
using namespace std;
void CVehicle::set_ruedas(int num) { ruedas = num; }
int CVehicle::get_ruedas() { return ruedas; }
void CVehicle::set_pasajeros(int num) { pasajeros = num; }
int CVehicle::get_pasajeros() { return pasajeros; }
void truck::set_charge(int size) {
this->charge = size;
}
int truck::get_charge() {
return this->charge;

2
0
 Práctica N° 2: Manejo de Excepciones
void automobile::set_kind(kind k) {
this->kind_of_car = k;
}
kind automobile::get_kind() {
return this->kind_of_car;
}
void truck::mostrar()
{
cout << "ruedas: " << get_ruedas() << "\n";
cout << "pasajeros: " << get_pasajeros() << "\n";
cout << "Capacidad de carga en pies cúbicos: " << charge << "\n";
}

void automobile::mostrar()
{
cout << "ruedas: " << get_ruedas() << "\n";
cout << "pasajeros: " << get_pasajeros() << "\n";
cout << "tipo: ";
switch (get_kind()) {

case van:
cout << "van\n";
break;

case car:
cout << "carro\n";
break;
case pickup_truck:
cout << "camioneta\n";

//Source.cpp
#include "CVehicle.h"
#include <iostream>
using namespace std;
int main()
{
truck t1, t2;
automobile c;
t1.set_ruedas(18);
t1.set_pasajeros(2);
t1.set_charge(3200);
t2.set_ruedas(6);
t2.set_pasajeros(3);
t2.set_charge(1200);
t1.mostrar();
cout << "\n";
t2.mostrar();
cout << "\n";
c.set_ruedas(4);
c.set_pasajeros(6);
c.set_kind(van);
c.mostrar();
return 0;

2
1
 Práctica N° 2: Manejo de Excepciones
6. CONCLUSIONES DE LA PRÁCTICA:
En conclusión, considero que esta práctica cumplió con el objetivo ya que al haber buscado información que
defina bien cada tema, ayudo a encontrar nuevos subtemas que ayuden a que el programador realmente
interactúe de forma correcta las variables de la clase y cuando debe hacerlas. También es importan resaltar que
se encontró que cada tema realmente ayuda a gestionar mejor el objetivo que debe realizar el objeto y varios
objetos, por ende, considero que esta práctica perfectamente nos orienta a nuevos temas relacionados al POO.

Este lenguaje tiene las mismas ventajas que nos brinda el C pero este contienen mas funciones. Pero los temas
como las clases, encapsulamiento tienen casi parecido la misma definición. Pudimos aprender que las clases
tiene una gran variedad de temas como los accesos de especificación que existen tres que son los publico,
privados y protegido.

También puedo decir que esta practica solvento muchas cuestiones como la manera de hacer que los
atributos no puedan alterarse mediante clases externas, saber escoger que atributos son los que realmente se debe
utilizar para representar la clase declarada, identificar el uso del modelo get y set para ingresar y mostrar
atributos privados. Esperamos próximamente aprender mas temas relacionados a clases

7. CUESTIONARIO
1. ¿En qué consiste la abstracción?
La abstracción consiste en extraer las propiedades esenciales de un concepto, ignorando selectivamente partes de un
todo para facilitar su comprensión, esto sirve en la resolución de problemas buscando generalidades que ofrezcan una
perspectiva distinta, más favorable a su resolución.
2. ¿Qué papel juega la abstracción en el diseño de clases?
Se puede crear objetos del tipo, sin necesitar objetos del mismo tipo, también se pueden crear objetos del tipo a partir de
otros objetos del tipo.
3. ¿Cómo se usa la clasificación?
La clasificación se utiliza para organizar los atributos de una clase, por medio de las relaciones que estos tienen. Por
ejemplo, si nuestra clase es de animal y queremos concretarnos a describir al animal, los atributos deben ser adjetivos de
esa clase.
4. ¿Cómo determinamos los atributos de clase a partir de la abstracción?
Para poder sacar los atributos para una clase se tiene que analizar el concepto del cual se quiere hacer la clase y tomar
las propiedades esenciales de este.
5. ¿Cómo la abstracción nos ayuda a determinar los métodos de clase?
Para determinar los métodos de una clase se tiene que buscar generalidades del concepto del cual se quiere sacar una
clase, también con un método abstracto nos da la posibilidad de introducir la declaración de un método en una clase e
implementarlo en alguna subclase de la clase.
6. ¿Qué es la generalización?
Es crear una abstracción que se pueda usar para más de un tipo de dato, generalización de un tipo de dato consiste en
introducir un parámetro en la definición del tipo para poder usarlo con distintos tipos.
7. ¿Qué es la especificación?
En el ámbito de un lenguaje de programación, se puede decir que la especificación es una manera de orientar a nuestra
clase a una sola definición o a un solo objetivo por completar.
8. ¿En qué consiste la jerarquía de conceptos?
consiste en ordenar que conceptos engloban a otros. por ejemplo si se habla la definición de las personas, esto puede
englobar pequeñas definiciones como el amor, amistad, experiencias,etc.
9. ¿Qué es un método?
Los métodos de una clase son funciones por las cuales se puede manipular los atributos de la clase.
10. ¿Qué es un mensaje?
Un mensaje es una función en la cual el programa crea un cuadro en el que se muestra un mensaje asimismo diferentes
funciones de botones e iconos ya definidos
11. ¿Qué es un método de servicio?

2
2
 Práctica N° 2: Manejo de Excepciones
Es un método que ejecuta los servicios y los métodos son funciones que pertenecen a una clase.
12. ¿Qué es un método set?
Es un método que asigna un valor o elemento del indexador.
13. ¿Qué es un método get?
Es un método que devuelve un valor o elemento del indizador.
14. ¿Cómo actúa un método público?
Funciona de tal manera que un miembro de alguna otra clase tenga acceso desde fuera o dentro de la dicha clase
15. ¿Cómo actúa un método privado?
Funciona de tal manera que se logra mantener su valor para luego poder modificarlo respectivamente. Usualmente de
definen los métodos Get y Set.
16. ¿Cómo se logra cambiar el estado de un objeto?
Se logra cambiar el estado de un objeto mediante las funciones mensaje la cual es capaz de realizar el cambio del objeto
17. ¿Qué es una función inline?
Es un indicador el cual informa al compilador acerca de cada requerimiento a la función esta deberá ser reemplazada por
el cuerpo se dicha función
18. ¿Qué diferencia existe entre los métodos externos y los métodos o funciones insertadas?
Los métodos externos, sirven para acceder a una clase. Uno de los métodos más conocidos es el método principal, este
método permite poder acceder a la clase, si y solo si los métodos o funciones insertadas son públicas.
19. ¿Qué es el encapsulamiento?
Es un procedimiento informático, que sirve para que los atributos de una clase no sean modificas o eliminadas por algún
objeto declarado en la función principal. Suele ser utilizado frecuentemente para ocultar atributos que difícilmente
suelen cambiar su valor dentro de la clase.
20. ¿Qué es la interface de clase?
Las interfaces se relacionan mucho con el tema de la abstracción, ya que una interfaces de clase, permite que un método,
no esté ligado concretamente a una sola clase. Sino esta funcion, comparte con una variedad de clases. Por ejemplo el
método void fly(), no necesariamente pertenece a una sola ave. Si no puede estar en varias al mismo tiempo
21. ¿Qué ventajas de diseño de código proporciona el encapsulamiento?
Primero para poder encapsular atributos, es fundamental que el diseño al momento de declarar una clase y codificar los
atributos, estos tengan un modificador de acceso “Private”. Esto trae como ventaja que aquellos atributos solo puedan
ser modificados dentro de la clase y difícilmente fuera de ella.
22. ¿Cuál es el objetivo declarar private los atributos de clase?
El objetivo principal por el que se coloca Private a los atributos, es para el valor de los atributos no sean modificados
directamente por la función principal o por otra clase.
23. ¿Cómo se accede a atributos privados de un objeto?
Solo se pueden acceder si es que los atributos de la clase donde resguarda esos atributos privados, son públicos. Esto se
puede realizar, llamando a este método en el método principal. Y dentro del método público, llamar por un This al
atributo que deseamos acceder.
24. ¿Cómo se cambia el valor de un atributo privado de un objeto?
Primero para poder cambiar el valor de este atributo, es importante haber accedido a este. Así por medio del método
principal puede llamar a otro método dentro de esa clase que tenga con función modificar los atributos.
25. ¿Qué ventajas trae la aplicación de ocultamiento de información a través de interfaces?
Al empaquetar diferentes atributos y métodos dentro de una clase a través de un interfaces. Trae como ventaja esconder
detalles propios de la clase u objeto declarado, de esta manera no presentara modificaciones por fuentes externas
26. ¿Qué pasos se siguen para construir la interface?
Declarar una función de interface implica saber que método es utilizado por varias clases, asi se procesara una función
que encapsule a ese método
27. ¿Cómo se hace uso de la interface una vez construida?
Una interface, suele ser construida para implementar un método que más adelante servirá para que otras clases puedan
utilizarla. No obstante, están clases no necesariamente deben tener un estrecha relación, sino que compartan la misma
utilidad
28. ¿Qué diferencias existen entre el encapsulamiento y el encapsulamiento por interfaces?
La principal diferencia entre el encapsulamiento normal y por interfaces , es que uno tiene como objetivo individualizar
el objeto, mientras que el otro mantiene que varias clases compartan el mismo métodos mas no los atributos.

2
3
Práctica N° 2: Manejo de Excepciones

8. BIBLIOGRAFÍA

8.1 Introducción
Antonio J.”Introduccion”.[En línea]. Disponible https://bit.ly/3nlwAwC [Accedido: 20 Abril 2021]
Edgar Serna M, “La importancia de la abstracción en la informatica” [En línea]. Disponible
https://bit.ly/3nmmwmQ [Accedido: 19 Abril 2021]

8.2 Cuestionario

“Ocultación de la Información y Mensajes-Métodos” [En línea]. Disponible https://bit.ly/2PlpxaC [Accedido 21

Abril 2021]
Jose Manuel Alarcon. “Lenguaje C#: interfaces y qué diferencia existe entre implementarlas explícita o
implícitamente” [En línea]. Disponible https://bit.ly/3tTbVSX [Accedido 21 Abril 2021]

8.3 Marco teórico

1. J. Valiño J. Zarazaga S. Comella J. Nogueras P. R. Muro-Medrano.,” Utilización de técnicas de programación

basadas en frames para incrementar la potencia de representación en clases de C++ para aplicaciones de
sistemas de información” [En línea]. Disponible: https://bit.ly/3trqxJa [Accedido:21 abril 2021]
2. Fco.Javier Ceballos Sierra:” Programación orientada a objetos c++ cuarta edición” [En línea].
Disponible: https://bit.ly/3al02NQ [Accedido:21 abril 2021]
3. Telkomnika, vol.10,No.2.,” Review of Sequential Access Method for Fingerprint Identification”.,
School of Electrical Engineering and Informatics., Bandung Institute of Technology., [En
línea].Disponible: https://bit.ly/32nkBF2 [Accedido:21 Abril 2021]

2
4
Práctica N° 2: Manejo de Excepciones
4. Ulrich W. Eisenecker, Frank Blinn., Krzysztof Czarnecki.,” A Solution to the Constructor-Problem of
Mixin-Based Programming in C++”.,Presented at the GCSE’2000 Workshop on C++ Template
Programming) [En línea].Disponible: https://bit.ly/3niQ2Kv [Accedido:25 abril 2021]
5. Rumen Kostadinov.,Amruth N. Kumar.,” A Tutor for Learning Encapsulation in C++ Classes”.,
Ramapo College of New Jersey., [En línea].Disponible: https://bit.ly/3tWBH8Y [Accedido:25 abril
2021]
6. Rochester Institute of Technology.,” Dynamic encapsulation of C++ objects” [En línea]. Disponible:
https://bit.ly/2QtXh68 [Accedido:25 abril 2021]
7. AG Carrillo, JF Valdivia., “Abstracción y estructurada de datos en c++” , [En línea] Disponible:
https://bit.ly/3tuKQ8G [Accedido:25 abril 2021]
8. Arzate Reyes Jonathan Jair., “Desarrollo e implatacion de un objeto de aprendizaje sobre los
constructores en el lenguaje C++ para la asignatura de programación orientados a objetos”., [En línea].
Disponible: [En línea].Disponible: https://bit.ly/3vjWJyw [Accedido:24 abril 2021]
9. Henry Augusto Villamizar Rueda.,” Diseño e implementación de una biblioteca de clases en c++ para
la simulación de ambientes virtuales en tiempo real” [En línea]. Disponible: https://bit.ly/3vgoMis
[Accedido:23 abril 2021]

2
5