Modelo de Informe Practica #07 - 2023

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

Mayo - 2023 LENGUAJES DE
PROGRAMACIÓN II
Práctica N° 07
Elaborado por:
Joel Gerardo Cruces de la Cruz
Luis Mariano Terrones Ortega
© IEEE 2013 The Institute of Electrical and Electronics Engineers, Inc.

SESIÓN N° 07: Clases Bases y Clases Derivadas, Miembros Protected, Constructores y Destructores en Clases
Derivadas, Herencia Public, Protected y Private en C++
GRUPO N° 01
PRÁCTICAS DE LENGUAJES DE PROGRAMACIÓN II
Presentado por:
Joel Gerardo Cruces de la Cruz

Luis Mariano Terrones Ortega
ii
RECONOCIMIENTOS
A mis padres, al Ingeniero y al tutor respectivo, que nos apoyaron en lo largo de nuestra
carrera universitaria.
PALABRAS CLAVES
Herencia, Clases, Métodos, Atributos, Public, Protected, Private,
iii
ÍNDICE
1. RESÚMEN 1
2. INTRODUCCIÓN ...................................................................................................... 1
3. MARCO TEÓRICO .................................................................................................... 1
3.1 Clase Base ....................................................................................................... 1
3.2 Clase Derivada ................................................................................................. 1
3.3 Miembros Protected .......................................................................................... 2
3.4 Constructores de clases derivadas ................................................................... 4
3.5 Destructores de clases derivadas ..................................................................... 6
3.6 Clases de derivación( especificadores de acceso) ............................................ 7
4. MODELAMIENTO ..................................................................................................... 1
4.1 Diagrama de clases .......................................................................................... 1
4.2 Diagrama de secuencia .................................................................................... 2
5. EXPERIENCIAS DE PRÁCTICA ............................................................................... 3
6. EJERCICIOS PROPUESTOS: .................................................................................. 5
7. CONCLUSIONES DE LA PRÁCTICA: ....................................................................... 9
8. CUESTIONARIO ..................................................................................................... 10
9. BIBLIOGRAFÍA ....................................................................................................... 14
iv
ÍNDICE DE TABLAS Y FIGURAS
Figura N° 1: Diagrama de Clases...................................... ¡Error! Marcador no definido.

Figura N° 2: código de función......................................... ¡Error! Marcador no definido.
v
SESIÓN N° 07: Clases Bases y Clases Derivadas, Miembros Protected, Constructores y Destructores en Clases Derivadas,
Herencia Public, Protected y Private en C++
1. RESÚMEN
En este documento se realiza la descripcion de los conceptos Clases Bases y Clases Derivadas,
Miembros Protected, Constructores y Destructores en Clases Derivadas, Herencia Public, Protected
y Private en la Programación Orientada a Objetos (POO), los cuales son fueron presentados en la
guia de practica. Tambien se realizo la aplicación de los conceptos mencionados en clases, asi como
la implementacion de Herencia Public, Protected y Private para el codigo que se desarrollo en el
laboratorio 7 durante las horas de practica, se realizo su diagrama de secuencia representando cada
relacion que contiene cada clase del programa desarrolado, posteriormente se responden las
preguntas del cuestionario de la practica para finalmente realizar las conclusiones y referencias
respectivas del informe.
2. INTRODUCCIÓN
Este informe aborda el tema de las clases bases y clases derivadas, así como los miembros
protegidos, constructores y destructores en clases derivadas, y la herencia pública, protegida y
privada en el lenguaje de programación C++.
En la programación orientada a objetos, las clases son una herramienta fundamental para organizar
y estructurar nuestro código. Una clase base es aquella que proporciona la estructura y
funcionalidades básicas, mientras que las clases derivadas se crean a partir de la clase base y heredan
sus características y comportamientos.
Uno de los aspectos importantes en la herencia es la utilización de los miembros protegidos. Estos
miembros son accesibles tanto en la clase base como en las clases derivadas, permitiendo que los
miembros protegidos puedan ser utilizados y modificados por las clases derivadas.
En cuanto a los constructores y destructores en clases derivadas, estos son métodos especiales que
se utilizan para inicializar y liberar recursos de los objetos. Al heredar de una clase base, es posible
definir constructores y destructores específicos para las clases derivadas, permitiendo así una mayor
personalización y control sobre la creación y destrucción de los objetos.
Además, en C++, se pueden utilizar los conceptos de herencia pública, protegida y privada. La
herencia pública permite que los miembros públicos de la clase base sean accesibles desde las clases
derivadas. La herencia protegida permite que los miembros protegidos de la clase base sean
accesibles desde las clases derivadas, pero no desde otros contextos. Por último, la herencia privada
restringe el acceso a los miembros de la clase base solo dentro de la propia clase derivada,
ocultándolos al resto del programa.
1
SESIÓN N° 07: Clases Bases y Clases Derivadas, Miembros Protected, Constructores y Destructores en Clases Derivadas, Herencia Public, Protected y Private en C++
3. MARCO TEÓRICO
3.1 Clase Base

¿QUÉ ES? ¿CÓMO SE DECLARA? ¿CÓMO LO USO? ¿CUÁNDO LO USO?
La clase base es una clase de la cual otras class ClaseBase { Se utiliza creando clases Se utiliza cuando se desea establecer una
// Atributos y métodos de la clase base
clases derivan. Contiene características y }; derivadas que heredan de la jerarquía de clases, compartir características
comportamientos comunes. clase base mediante la palabra comunes y promover la reutilización de
clave public (en C++). código. Se modela la relación "es-un" entre
objetos y se definen las características básicas
que pueden ser heredadas y extendidas.
3.2 Clase Derivada

La clase derivada es una clase class ClaseDerivada : public ClaseBase { Se utiliza creando objetos Se utiliza cuando se desea especializar o
// Atributos y métodos adicionales
que hereda atributos y métodos }; de la clase derivada y extender la funcionalidad de una clase base
de una clase base, y puede accediendo a los atributos y existente. Se usa para modelar una relación de
agregar nuevos atributos y métodos heredados de la "es-un" más específica, donde la clase derivada
métodos, o modificar los clase base, así como a los es una forma especializada de la clase base. Se
existentes. nuevos atributos y métodos emplea cuando se necesitan características
definidos en la clase adicionales específicas o comportamiento
derivada. modificado en comparación con la clase base.
1
3.2.1 Control de acceso de la clase base

El control de acceso de la clase class ClaseBase { El uso del control de acceso en la El control de acceso se utiliza para
public:
base se refiere a la forma en que int atributoPublico; clase derivada implica utilizar los mantener la encapsulación y controlar
los atributos y métodos de la protected: miembros heredados según su la visibilidad y modificabilidad de los
int atributoProtegido;
clase base son accesibles desde private: nivel de acceso. Los miembros miembros heredados. Se utiliza cuando
la clase derivada. Determina si int atributoPrivado; públicos de la clase base son se desea limitar el acceso a ciertos
public:
los miembros heredados void metodoPublico() { accesibles directamente en la miembros de la clase base para evitar
pueden ser accedidos // Código del método clase derivada. Los miembros modificaciones no deseadas o para
}
directamente o si se requiere protected: protegidos pueden ser accedidos permitir una interacción controlada con
algún nivel de restricción. void metodoProtegido() { dentro de la clase derivada y en los miembros heredados. También se
// Código del método
} sus subclases. Los miembros utiliza para definir la interfaz pública
private:
void metodoPrivado() {
privados de la clase base no son de la clase derivada y ocultar los
// Código del método accesibles en la clase derivada. detalles internos de la clase base.
}
};
3.3 Miembros Protected

Los miembros protected son class ClaseBase { Para usar un miembro Se utiliza protected cuando se quiere
protected:
miembros de una clase que tienen int atributoProtegido; protected, se puede acceder permitir el acceso a ciertos miembros de
un nivel de acceso intermedio protected:
directamente dentro de la una clase base en sus subclases, pero se
entre public y private. Los void metodoProtegido() { clase en la que se declaran, así desea mantenerlos ocultos o inaccesibles
miembros protected son accesibles // Código del método como en sus clases derivadas. fuera de la jerarquía de herencia. Esto
}
dentro de la clase en la que se }; Esto significa que los permite que las subclases hereden y
declaran, así como en sus clases miembros protected son utilicen los miembros protected, pero que
derivadas (subclases). heredados por las subclases y las clases externas no tengan acceso
pueden ser accedidos y directo a ellos. El uso de protected ayuda
utilizados en las subclases. a mantener la encapsulación y controlar el
acceso a los miembros de una clase base
dentro de su jerarquía de herencia.
2
3.3.1 Atributos Protected

Los atributos protected son class ClaseBase { Para usar un atributo protected, Se utiliza protected cuando se quiere permitir
atributos de una clase que protected: se puede acceder directamente el acceso a ciertos atributos de una clase base
int atributoProtegido;
tienen un nivel de acceso }; dentro de la clase en la que se en sus subclases, pero se desea mantenerlos
intermedio entre public y declara y en sus clases ocultos o inaccesibles fuera de la jerarquía de
private. Los atributos derivadas. Esto significa que los herencia. Esto permite que las subclases
protected son accesibles atributos protected son hereden y utilicen los atributos protected, pero
dentro de la clase en la que heredados por las subclases y que las clases externas no tengan acceso
se declaran y en sus clases pueden ser accedidos y directo a ellos. El uso de protected ayuda a
derivadas (subclases). utilizados en las subclases mantener la encapsulación y controlar el
acceso a los atributos de una clase base dentro
de su jerarquía de herencia.
3.3.2 Métodos Protected

Los métodos protected son class ClaseBase { Para usar un método protected, se Se utiliza protected cuando se quiere
métodos de una clase que protected: puede invocar directamente dentro de permitir el acceso a ciertos métodos de
void metodoProtegido() {
tienen un nivel de acceso // Código del método la clase en la que se declara y en sus una clase base en sus subclases, pero se
intermedio entre public y } clases derivadas. Esto significa que desea mantenerlos ocultos o inaccesibles
private. Los métodos }; los métodos protected son heredados fuera de la jerarquía de herencia. Esto
protected son accesibles por las subclases y pueden ser permite que las subclases hereden y
dentro de la clase en la que accedidos y utilizados en las utilicen los métodos protected, pero que
se declaran y en sus clases subclases. las clases externas no tengan acceso
derivadas (subclases). directo a ellos.
3
3.4 Constructores de clases derivadas

Los constructores de clases class ClaseDerivada : public ClaseBase { Al utilizar un constructor de una clase Se utiliza un constructor de una
derivadas son métodos public: derivada, se crea un objeto de la clase clase derivada cuando se quiere
especiales que se utilizan para ClaseDerivada(...) : ClaseBase(...) { derivada y se inicializan tanto los atributos crear y configurar objetos de la clase
inicializar los objetos de una // Código adicional de inicialización de la de la clase derivada como los atributos derivada, asegurándose de que
clase derivada
clase derivada/subclase. Un heredados de la clase base. Esto se logra también se inicialicen correctamente
}
constructor es un método que }; llamando al constructor de la clase base en los atributos heredados de la clase
se llama automáticamente al la lista de inicialización del constructor de base. Esto es especialmente útil
crear un objeto y se encarga de la clase derivada cuando la clase derivada agrega
asignar valores iniciales a los atributos adicionales o requiere una
atributos de la clase. inicialización específica antes de su
uso.
3.4.1 Inicialización de clases base en constructores

La inicialización de clases base class ClaseDerivada : public ClaseBase { Al utilizar la inicialización de clases Se utiliza la inicialización de clases base en
en constructores se refiere al public: base en constructores, se asegura constructores cuando se desea establecer
proceso de llamar y pasar ClaseDerivada(...): ClaseBase(...) { que los constructores de las clases los valores iniciales de los miembros
argumentos a los constructores // Código adicional de inicialización de la base sean llamados correctamente y heredados de la clase base al construir un
clase derivada
de las clases base desde los se les pasen los argumentos objeto de la clase derivada. Esto es
}
constructores de las clases }; necesarios. Esto permite inicializar especialmente útil cuando la clase derivada
derivadas. Permite establecer los miembros heredados de la clase agrega atributos adicionales o requiere una
los valores iniciales de los base de manera adecuada antes de inicialización específica antes de su uso,
miembros heredados de la clase ejecutar el código adicional en el pero aún se necesita la inicialización
base al construir un objeto de la constructor de la clase derivada. adecuada de los miembros heredados de la
clase derivada. clase base.
4
3.4.2 Inicialización de objetos miembros de clases

La inicialización de objetos class Clase { Al utilizar la inicialización de objetos Se utiliza la inicialización de objetos
miembros de clases se refiere al private: miembros de clases, se asegura que miembros de clases cuando se quiere
proceso de inicializar los Tipo miembro1; los objetos miembros sean asignar valores iniciales a los objetos
objetos que son miembros de OtroTipo miembro2; inicializados antes de que se ejecute el miembros de una clase antes de utilizarlos
public:
una clase. Permite establecer código en el constructor de la clase. en los métodos de la clase. Es
Clase(...) : miembro1(...), miembro2(...) {
valores iniciales a los objetos // Código adicional de inicialización de Esto permite establecer valores especialmente útil cuando los objetos
miembros antes de utilizarlos la clase iniciales a los objetos miembros y miembros requieren una inicialización
en los métodos de la clase. } utilizarlos en los métodos de la clase específica o cuando se desea evitar la
}; de manera adecuada. inicialización por defecto y asignar valores
personalizados a los objetos miembros
3.4.3 Sobrecarga de constructores de clases derivadas

La sobrecarga de constructores class ClaseDerivada : public ClaseBase { Al utilizar la sobrecarga de Se utiliza la sobrecarga de constructores de
de clases derivadas es la public: constructores de clases derivadas, clases derivadas cuando se desea tener
capacidad de una clase ClaseDerivada(...): ClaseBase(...) { se pueden crear objetos de la clase flexibilidad en la inicialización de objetos de
derivada de tener múltiples // Código adicional de inicialización de la derivada utilizando diferentes la clase derivada. Permite crear objetos con
clase derivada
constructores con diferentes constructores según las diferentes combinaciones de valores
}
parámetros. Permite crear necesidades específicas. Cada iniciales, adaptándose a diferentes casos de
objetos de la clase derivada ClaseDerivada(...): ClaseBase(...) { constructor puede realizar una uso o requisitos de inicialización. La
utilizando diferentes // Código adicional de inicialización de la inicialización personalizada y sobrecarga de constructores es útil cuando se
combinaciones de argumentos clase derivada ajustada a diferentes necesitan diferentes formas de construir
según las necesidades } combinaciones de argumentos. objetos de la clase derivada sin tener que
específicas de inicialización. modificar la lógica interna de la clase base.
// Otros constructores sobrecargados...
};
5
3.5 Destructores de clases derivadas

Un destructor de una clase class ClaseDerivada : public ClaseBase { Al utilizar el destructor de una clase Se utiliza el destructor de una clase
derivada es un método especial public: derivada, se pueden realizar acciones de derivada cuando se requiere realizar
que se utiliza para liberar los // ... limpieza y liberación de recursos acciones de limpieza y liberación de
recursos asignados a un objeto específicos de la clase derivada. Esto recursos específicos de la clase
~ClaseDerivada() {
de la clase derivada y a sus puede incluir liberar memoria asignada derivada y sus miembros. Es
// Código del destructor de la clase
miembros. Se ejecuta derivada dinámicamente, cerrar archivos especialmente útil cuando la clase
automáticamente cuando un } abiertos, desconectar conexiones de derivada ha asignado recursos
objeto de la clase derivada deja }; red, entre otras tareas. adicionales durante su ciclo de vida y es
de existir, ya sea porque sale necesario liberarlos de manera
del ámbito o se elimina adecuada para evitar fugas de memoria
explícitamente. u otros problemas.
3.5.1 Tipos de miembros

Los tipos de miembros se class MiClase { Los tipos de miembros se utilizan para Se utilizan los tipos de miembros en una
refieren a las diferentes private: definir y organizar el comportamiento y los clase cuando se necesita definir y
categorías de miembros que int atributo; // Atributo datos asociados con una clase. Los organizar los datos y el comportamiento
pueden existir en una clase. Los void metodo(); // Método atributos almacenan información asociados con los objetos de la clase. Los
public:
tipos comunes de miembros específica de cada objeto, los métodos atributos almacenan información
static int miembroEstatico; // Miembro
son los atributos (variables de estático definen el comportamiento y las específica de cada objeto, los métodos
instancia), los métodos }; operaciones que se pueden realizar en los definen cómo se comportan los objetos y
(funciones de la clase) y los objetos, y los miembros estáticos son los miembros estáticos proporcionan
miembros estáticos compartidos por todas las instancias de la datos o funcionalidades compartidas por
(compartidos por todas las clase. Los miembros se utilizan accediendo todas las instancias de la clase. Se utilizan
instancias de la clase). a ellos a través de objetos de la clase o para modelar y representar de manera
utilizando la notación de ámbito para los eficiente la lógica y las características de
miembros estáticos. un objeto o entidad en un programa.
6
3.6 Clases de derivación( especificadores de acceso)

Las clases de derivación con class ClaseDerivada : public ClaseBase { El uso de los especificadores de acceso en una Los especificadores de acceso se
especificadores de acceso son // Código de la clase derivada clase de derivación determina cómo se utilizan cuando se desea controlar la
una forma de herencia en la }; heredan y acceden los miembros de la clase visibilidad y accesibilidad de los
cual se especifica el nivel de base en la clase derivada. miembros heredados en la clase
class ClaseDerivada : protected
acceso que tendrán los Si se utiliza PUBLIC, los miembros derivada. Se utilizan para establecer
ClaseBase {
miembros heredados de la clase // Código de la clase derivada heredados son accesibles directamente en la la relación de acceso entre la clase
base en la clase derivada. Esto }; clase derivada y también se heredan con su base y la clase derivada,
permite controlar la visibilidad nivel de acceso original. determinando qué miembros son
y accesibilidad de los class ClaseDerivada : private ClaseBase { Si se utiliza PROTECTED, los miembros accesibles y cómo se pueden utilizar
miembros heredados en la clase // Código de la clase derivada heredados son accesibles en la clase derivada en la clase derivada y en las clases
derivada. }; y en las clases derivadas posteriores, pero no derivadas posteriores. Los
desde fuera de la jerarquía de clases. especificadores de acceso se utilizan
Si se utiliza PRIVATE, los miembros para aplicar el principio de
heredados son accesibles solo dentro de la ocultamiento de información y
clase derivada y no desde las clases derivadas encapsulación, y para definir la
ni desde fuera de la jerarquía de clases. interfaz y el comportamiento de las
clases derivadas.
3.6.1 DERIVACIÓN PÚBLICA (PUBLIC)

La derivación pública (public) class ClaseDerivada : public ClaseBase En la derivación pública, los miembros La derivación pública se utiliza cuando se
es un tipo de herencia en C++ { públicos de la clase base se heredan con desea heredar los miembros públicos de la
donde los miembros públicos // Código de la clase derivada su nivel de acceso original y son clase base en la clase derivada y se quiere
de la clase base se heredan }; accesibles directamente desde la clase que estos miembros sean accesibles desde
como miembros públicos en la derivada. Esto significa que se pueden la clase derivada y también desde fuera de
clase derivada. Esto significa utilizar los miembros heredados de la la clase derivada. Es útil cuando se desea
que los miembros heredados misma manera que los miembros de la establecer una relación "es un" entre la
son accesibles directamente clase derivada. Además, los miembros clase base y la clase derivada, donde la
desde la clase derivada y heredados también son accesibles desde clase derivada es una extensión
también desde fuera de la clase fuera de la clase derivada utilizando un especializada de la clase base y se espera
derivada. objeto de la clase derivada. que tenga todas las características públicas
de la clase base.
7
3.6.2 DERIVACIÓN PROTEGIDA (PROTECTED)

La derivación protegida class ClaseDerivada : protected ClaseBase En la derivación protegida, los La derivación protegida se utiliza cuando se
(protected) es un tipo de { miembros protegidos de la clase desea heredar los miembros protegidos de la
herencia en C++ donde los // Código de la clase derivada base se heredan como miembros clase base en la clase derivada y se quiere
miembros protegidos de la }; protegidos en la clase derivada. Esto que estos miembros sean accesibles dentro
clase base se heredan como significa que se pueden acceder de la clase derivada y también dentro de las
miembros protegidos en la directamente desde la clase derivada clases derivadas posteriores en la jerarquía
clase derivada. Esto significa y también desde las clases derivadas de clases. Es útil cuando se desea establecer
que los miembros heredados posteriores en la jerarquía de clases. una relación "es un" entre la clase base y la
son accesibles dentro de la Sin embargo, los miembros clase derivada, y se espera que los miembros
clase derivada y también dentro heredados no son accesibles desde heredados sean utilizados y extendidos en
de las clases derivadas fuera de la jerarquía de clases las clases derivadas, pero no se desea que
posteriores, pero no son utilizando un objeto de la clase sean accesibles desde fuera de la jerarquía de
accesibles desde fuera de la derivada. clases.
jerarquía de clases.
3.6.3 DERIVACIÓN PRIVADA (PRIVATE).

La derivación privada (private) class ClaseDerivada : private ClaseBase { En la derivación privada, los La derivación privada se utiliza cuando se desea
es un tipo de herencia en C++ // Código de la clase derivada miembros privados de la clase heredar los miembros privados de la clase base en
donde los miembros privados }; base se heredan como la clase derivada, pero se quiere ocultar y
de la clase base se heredan miembros privados en la clase restringir el acceso a estos miembros. En general,
como miembros privados en la derivada. Esto significa que se utiliza para implementar una relación
clase derivada. Esto significa los miembros heredados no "implementa la funcionalidad de" entre la clase
que los miembros heredados no pueden ser accedidos base y la clase derivada, donde la clase derivada
son accesibles ni dentro de la directamente ni desde la clase necesita acceder a los miembros privados de la
clase derivada ni desde fuera de derivada ni desde fuera de clase base para implementar su funcionalidad,
la misma. ella. pero no se desea que estos miembros sean
accesibles desde fuera de la clase derivada.
8
4. MODELAMIENTO
4.1 Diagrama de clases
Fig nro. 1: Diagrama de clases de Cliente
Fig nro. 2: Diagrama de clases de Vehiculo
1
4.2 Diagrama de secuencia
Fig nro. 3: Diagrama de secuencia de Cliente
Fig nro. 4: Diagrama de secuencia de Vehiculo
2
5. EXPERIENCIAS DE PRÁCTICA
La empresa XYZ necesita desarrollar un sistema de seguridad para proteger la información personal
y financiera de sus clientes durante el proceso de compra en línea. El sistema debe ser capaz de
encriptar la información ingresada por el cliente y almacenarla de manera segura en la base de datos
de la empresa. Además, el sistema debe ser capaz de verificar la autenticidad del cliente antes de
procesar el pago.
#include<iostream>
#include<vector>
#include<string>
using namespace std;
class Cliente
{
protected:
string name;
int dni;
string direccion;
int telefono;
int nrodetarjeta;
Cliente(string name,int dni,string direccion,int telefono, int
nrodetarjeta) :
name(name),dni(dni),direccion(direccion),telefono(telefono),nrodetarjeta
(nrodetarjeta){}
void encriptarInformacion()
{
// Encriptar la información
string infoEncriptada;
for (char& c : name) {
if (c != 'z') {
c = c + 1;
} else {
c = 'a';
}
}
dni = sustitucionNumerica(dni);
for (char& c : direccion) {

if (c != 'z') {
c = c + 1;
} else {
c = 'a';
}
}
telefono = sustitucionNumerica(telefono);
nrodetarjeta = sustitucionNumerica(nrodetarjeta);
}
private:
int sustitucionNumerica(int numero) {
// Tabla de sustitución numérica
string tabla = "9876543210";
string numeroEncriptado;
// Convertir el número en una cadena de dígitos

string numeroStr = to_string(numero);
3
for (char c : numeroStr) {

if (isdigit(c)) {
int indice = c - '0';
numeroEncriptado += tabla[indice];
} else {
numeroEncriptado += c;
}
}
// Convertir la cadena encriptada de nuevo a un número

int numeroEncriptadoInt = stoi(numeroEncriptado);
return numeroEncriptadoInt;
}
};
class ClienteSeguro : protected Cliente
{
public:
ClienteSeguro(string name,int dni,string direccion,int telefono,
int nrodetarjeta):Cliente(name,dni,direccion,telefono, nrodetarjeta){}
void encriptardatoscliente()
{
Cliente :: encriptarInformacion();
}
void mostrarinformacionEncriptada()
{
cout << "Nombre: " << name << endl;
cout << "DNI: " << dni << endl;
cout << "Direccion: " << direccion << endl;
cout << "Telefono: " << telefono << endl;
cout << "Numero de tarjeta: " << nrodetarjeta << endl;
}
};
int main()
{
ClienteSeguro objcliente("Juan", 897346675,"Calle 13",987456123,
123456789);
objcliente.encriptardatoscliente();
objcliente.mostrarinformacionEncriptada();
return 0;
}
4
6. EJERCICIOS PROPUESTOS:
1.- Crea una clase base "Vehículo" con atributos como la marca, modelo, año de fabricación y
precio. Luego, crea dos clases derivadas, "Automóvil" y "Motocicleta" que hereden de la clase
"Vehículo" y añadan atributos específicos como número de puertas y tipo de combustible en el caso
del automóvil y cilindrada en el caso de la motocicleta.
#include<iostream>
#include <string>
class Vehiculo
{
private:
string marca;
string modelo;
int aniofab;
float precio;
public:
Vehiculo(string marca ="", string modelo= "", int aniofab = 0,
float precio = 0):marca(marca),
modelo(modelo),aniofab(aniofab),precio(precio){}
void mostrarAtributos()
{
cout<< "Marca: "<< marca << endl;
cout<< "Modelo: "<< modelo<< endl;
cout<< "Año: "<< aniofab << endl;
cout<< "Precio: "<< precio << endl;
}
};
class Automovil : public Vehiculo

{
private:
int numpuertas ;
string combustible ;
public:
Automovil() : Vehiculo()
{
numpuertas = 0;
combustible ="";
}
Automovil(string marca ="", string modelo= "", int aniofab = 0,
float precio = 0, int numpuertas = 0, string combustible ="") :
Vehiculo(marca,modelo,aniofab,precio)
{
this->numpuertas = numpuertas;
this->combustible = combustible;
void mostrarAtributosAutomovil()
5
{
Vehiculo:: mostrarAtributos();
cout<< "Numero de puertas: "<< numpuertas << endl;
cout<< "Tipo de Combustible: "<< combustible<< endl;
}
};
class Motocicleta : public Vehiculo

{
private:
string cilindrada;
public:
Motocicleta() : Vehiculo()
{
cilindrada;
}
Motocicleta(string marca ="", string modelo= "", int aniofab = 0,

float precio = 0, string cilindrada ="") :
Vehiculo(marca,modelo,aniofab,precio)
{
this-> cilindrada = cilindrada;
}
void mostrarAtributosMotocicleta()
{
Vehiculo:: mostrarAtributos();
cout<< "Cilindradas: "<< cilindrada << endl;
}
};
int main()
{
cout<<"CLASE BASE VEHICULO"<<endl;
Vehiculo obj1("Toyota","corolla",2019,8000);
obj1.mostrarAtributos();
cout<<endl;
cout<<"CLASE DERIVADA AUTOMOVIL"<<endl;

Automovil objAutomovil("Toyota","Raize",2019, 9000, 4, "Gasolina");
objAutomovil.mostrarAtributosAutomovil();
cout<<endl;
cout<<"CLASE DERIVADA MOTOCICLETA"<<endl;

Motocicleta objMotocileta("Honda","Hornet ",2019, 20000 , "750");
objMotocileta.mostrarAtributosMotocicleta();
};
6
2.- Crea una clase "Persona" con atributos como el nombre, la edad y el salario. Añade un miembro
"protected" para la dirección de correo electrónico. Luego, crea dos clases derivadas, "Empleado"
y "Cliente" que hereden de la clase "Persona" y que tengan acceso a la dirección de correo
electrónico.
#include<iostream>
#include <string>
class Persona
{
protected:
string correoElc;
public:
string name;
int edad;
float salario;
Persona (string name, int edad, float salario, string correo) :
name(name), edad(edad), salario(salario),correoElc(correo){ }
};
class Empleado : public Persona

{
public:
Empleado (string name, int edad, float salario, string correo) :
Persona(name,edad,salario,correo){ }
string getCorreoElcEMPLEADO() {return correoElc;}

void setCorreoElcEMPLEADO(string a) {correoElc = a;}
void usarCorreoElectronicoEMPLEADO() {cout <<"Correo Electronico
Empleado: "<<correoElc;}
};
class Cliente : public Empleado
{
public:
Cliente (string name, int edad, float salario, string correo) :
Empleado(name,edad,salario,correo){ }
string getCorreoElcCLIENTE() {return correoElc;}

void setCorreoElcCLIENTE(string a) {correoElc = a;}
void usarCorreoElectronicoCLIENTE() {cout <<"Correo Electronico

Cliente: "<<correoElc;}
};
int main()
{
Persona objPersona("Julio",25,2500,"julio25@gmail.com");
Empleado objEmpleado("Marco",30,3500,"Marco2005@gmail.com");
cout<<"Datos Empleado:"<<endl;
cout<<"Nombre: "<<objEmpleado.name <<endl;
cout<<"Edad: "<<objEmpleado.edad <<endl;
7
cout<<"Salario: "<<objEmpleado.salario <<endl;

objEmpleado.usarCorreoElectronicoEMPLEADO();
cout<<endl;
cout<<endl;
Cliente objCliente("Pedro",30,3500,"Perdro2569@gmail.com");
cout<<"Datos Cliente:"<<endl;
cout<<"Nombre: "<<objCliente.name <<endl;
cout<<"Edad: "<<objCliente.edad <<endl;
cout<<"Salario: "<<objCliente.salario <<endl;
objCliente.usarCorreoElectronicoCLIENTE();
};
3. Crea una clase base "Móvil" con atributos como la marca, el modelo y el sistema operativo. Añade
un constructor y un destructor a la clase. Luego, crea dos clases derivadas, "Teléfono" y "Tablet"
que hereden de la clase "Móvil" y que tengan constructores y destructores específicos para cada
clase.
#include<iostream>
#include <string>
class Movil
{
private:
string marca;
string modelo;
string sistemaOperativo;
public:
Movil(string marca, string modelo, string sistemaOperativo) :
marca(marca), modelo(modelo), sistemaOperativo(sistemaOperativo){}
void mostrarAtributos()
{
cout<< "Marca: "<< marca << endl;
cout<< "Modelo: "<< modelo<< endl;
cout<< "Sistema Operativo: "<< sistemaOperativo << endl;
}
~Movil(){};
};
class Telefono : public Movil
{
public:
Telefono(string marca, string modelo, string sistemaOperativo)
: Movil(marca,modelo,sistemaOperativo){}
void mostraAtributosTelefono()
{
Movil::mostrarAtributos();
};
~Telefono(){};
};
8
class Tablet : public Movil

{
public:
Tablet(string marca, string modelo, string sistemaOperativo) :
Movil(marca,modelo,sistemaOperativo){}
void mostraAtributosTablet()
{
Movil::mostrarAtributos();
};
~Tablet(){};
};
int main()
{
// Ejercicio 3
cout<<"CLASE BASE MOVIL"<<endl;
Movil mimovil("Samsung","A20","One UI 5.1");
mimovil.mostrarAtributos();
mimovil.~Movil();
cout<<endl;
cout<<"CLASE BASE TELEFONO"<<endl;

Telefono mitelefono("Samsung","A20","One UI 5.1");
mitelefono.mostraAtributosTelefono();
cout<<endl;
cout<<"CLASE BASE TABLET"<<endl;

Tablet mitablet("Xiaomi","12 Pro","MIUI");
mitablet.mostraAtributosTablet();
mimovil.~Movil();
mitelefono.~Telefono();
mitablet.~Tablet();
};
7. CONCLUSIONES DE LA PRÁCTICA:
a) Las clases bases y clases derivadas son esenciales en la programación orientada a objetos,
permitiendo la reutilización y jerarquización del código.
b) Los miembros protegidos brindan acceso controlado a las clases derivadas, manteniendo la
encapsulación.
c) Los constructores y destructores en clases derivadas permiten personalizar la creación y
liberación de recursos.
d) La herencia pública, protegida y privada en C++ determina el nivel de acceso a los miembros
de la clase base desde las clases derivadas.
e) La correcta utilización de estos conceptos mejora la modularidad y estructura del código
orientado a objetos.
9
8. CUESTIONARIO
a) ¿Cuál es la diferencia entre una clase base y una clase derivada en programación orientada
a objetos?
• En programación orientada a objetos, una clase base es una clase existente que se utiliza como punto de partida
para crear una nueva clase, conocida como clase derivada. La clase derivada hereda los atributos y métodos de
la clase base y puede agregar nuevos atributos y métodos o modificar los existentes.
b) ¿Cómo se establece la relación entre una clase base y una clase derivada en C++?
• En C++, la relación entre una clase base y una clase derivada se establece mediante la palabra clave
"public" o "protected" seguida del nombre de la clase base después de la declaración de la clase
derivada. Por ejemplo, para declarar una clase derivada llamada "DerivedClass" que hereda de una
clase base llamada "BaseClass" de manera pública,
c) ¿Qué es la herencia de clases y cuál es su importancia en la programación orientada a
objetos?
• La herencia de clases es un concepto fundamental en la programación orientada a objetos que
permite la creación de jerarquías de clases. Permite que una clase derivada herede los atributos y
métodos de una clase base, lo que promueve la reutilización de código y facilita la organización y
estructuración del programa. La herencia de clases es importante porque mejora la modularidad, el
mantenimiento y la extensibilidad del código.
d) ¿Cuál es la sintaxis de declaración de una clase derivada en C++?
class ClaseDerivada : public ClaseBase {
// Definición de la clase derivada
};
e) ¿Qué es un miembro protected en una clase y qué permite hacer?
• En una clase, un miembro protected es un tipo de acceso intermedio entre los miembros públicos y
privados. Los miembros protected son accesibles desde la clase misma, sus clases derivadas y las
clases amigas, pero no desde el exterior de la clase.
f) ¿Cómo se accede a un miembro protected en una clase base y una clase derivada?
• Para acceder a un miembro protected en una clase base, se puede hacer directamente dentro de la
clase base o a través de una clase derivada utilizando la herencia. Desde una clase derivada, se puede
acceder a los miembros protected heredados de la clase base de manera similar a como se accede a
los miembros propios de la clase derivada.
g) Proporciona un ejemplo de uso de un miembro protected en una clase base y una clase
derivada.
class ClaseBase {
protected:
int protectedMember;
};
public:
void setProtectedMember(int value) {
protectedMember = value; // Acceso al miembro protected en la clase derivada
}
10
};
int main() {
ClaseDerivada obj;
obj.setProtectedMember(10); // Uso de la función para acceder al miembro protected en la
clase derivada
return 0;
}
h) ¿Qué son los constructores y destructores en C++?
• Los constructores y destructores son funciones especiales en C++ que se utilizan para inicializar y
destruir objetos de una clase, respectivamente. El constructor se invoca automáticamente al crear
un objeto y se utiliza para inicializar sus miembros, mientras que el destructor se invoca
automáticamente cuando el objeto deja de existir y se utiliza para liberar recursos o realizar otras
tareas de limpieza
i) ¿Cómo se utiliza un constructor en una clase derivada?
• Para utilizar un constructor en una clase derivada, se puede llamar al constructor de la clase base
utilizando la lista de inicialización en la definición del constructor de la clase derivada. Esto asegura
que los miembros heredados de la clase base se inicialicen correctamente.
class ClaseBase {
public:
ClaseBase (int value) {
// Constructor de la clase base
}
};
public:
ClaseDerivada (int value) : ClaseBase (value) {
// Constructor de la clase derivada
}
};
int main() {
ClaseDerivada obj(10); // Creación de un objeto de la clase derivada con llamada al constructor
return 0;
}
j) ¿Qué es la herencia múltiple y cómo se manejan los constructores y destructores en este
caso?
• La herencia múltiple es un concepto en programación orientada a objetos que permite que una clase
derive de múltiples clases base. En C++, los constructores y destructores en la herencia múltiple se
manejan de manera secuencial, en el orden en que se mencionan las clases base en la lista de
herencia. Cada constructor de clase base correspondiente se invoca en la lista de inicialización del
constructor de la clase derivada.
11
k) ¿Cuáles son las diferencias entre la herencia pública, protegida y privada en C++?
• Herencia pública (public): Los miembros públicos de la clase base son accesibles como miembros
públicos de la clase derivada. Los miembros protegidos de la clase base son accesibles como
miembros protegidos de la clase derivada. Los miembros privados de la clase base no son
accesibles directamente en la clase derivada.
• Herencia protegida (protected): Los miembros públicos y protegidos de la clase base se
convierten en miembros protegidos de la clase derivada. Los miembros privados de la clase base
no son accesibles directamente en la clase derivada.
• Herencia privada (private): Los miembros públicos y protegidos de la clase base se convierten en
miembros privados de la clase derivada. Los miembros privados de la clase base no son accesibles
directamente en la clase derivada.
l) Proporciona un ejemplo de uso de la herencia pública en C++.
class BaseClass {
public:
void publicMember() {
// Miembro público
}
};
class DerivedClass : public BaseClass {

// Herencia pública
};
int main() {
DerivedClass obj;
obj.publicMember(); // Acceso al miembro público heredado de la clase base
return 0;
}
m) Proporciona un ejemplo de uso de la herencia protegida en C++.
class BaseClass {
protected:
void protectedMember() {
// Miembro protegido
}
};
class DerivedClass : protected BaseClass {
// Herencia protegida
};
int main() {
DerivedClass obj;
obj.protectedMember(); // Acceso al miembro protegido
return 0;
}
12
n) Proporciona un ejemplo de uso de la herencia privada en C++.

class BaseClass {
private:
void privateMember() {
}
};
class DerivedClass : private BaseClass {
// Herencia privada
};
int main() {
DerivedClass obj;
// obj.privateMember(); // No se puede acceder al miembro privado
return 0;
}
o) ¿Qué es la herencia virtual en C++ y cuándo se utiliza?
• La herencia virtual en C++ se utiliza cuando se necesita resolver el problema de la herencia múltiple
de manera adecuada. Permite que una clase base sea heredada virtualmente por múltiples clases
derivadas. Esto evita la creación de instancias redundantes de la clase base y resuelve los problemas
de ambigüedad que pueden surgir con la herencia múltiple.
p) ¿Cómo se declara una herencia virtual en C++?
La declaración de una herencia virtual en C++ se realiza mediante la palabra clave virtual en la lista de
herencia.
class BaseClass {
};
class DerivedClass1 : virtual public BaseClass {
// Herencia virtual de BaseClass
};
q) ¿Cuál es la ventaja de utilizar la herencia virtual en C++?
• La ventaja de utilizar la herencia virtual en C++ es que resuelve el problema de la herencia múltiple
al evitar la creación de instancias redundantes de la clase base. Esto ayuda a evitar problemas de
ambigüedad y reduce el tamaño de la jerarquía de clases.
r) Proporciona un ejemplo de uso de la herencia virtual en C++.
Ejemplo de uso de la herencia virtual en C++:
#include <iostream>
class Shape {
public:
virtual void draw() {
std::cout << "Drawing shape" << std::endl;
}
};
class Circle : virtual public Shape {

public:
void draw() override {
13
std::cout << "Drawing circle" << std::endl;

}
};
class Square : virtual public Shape {

public:
void draw() override {
std::cout << "Drawing square" << std::endl;
}
};
class SquareCircle : public Square, public Circle {

// Herencia virtual de Square y Circle
};
int main() {
SquareCircle obj;
obj.draw(); // Salida: "Drawing square"
return 0;
}
9. BIBLIOGRAFÍA
1. Deitel, Paul J., Deitel, Harvey M., "Cómo Programar en C++", 6ta Edición, Ed. Pearson Educación, México
2009.
2. Stroustrup, Bjarne, "El Lenguaje de Programación C++", 3ra Edición, Adisson Pearson Educación S.A.,
Madrid 2002.
3. Eckel, Bruce, "Thinking in C++", 2da Edición, Prentice Hall, 2000.
14

Modelo de Informe Practica #07 - 2023

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 Practica #07 - 2023

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

Joel Gerardo Cruces de la Cruz

Herencia, Clases, Métodos, Atributos, Public, Protected, Private,

ÍNDICE DE TABLAS Y FIGURAS

Figura N° 1: Diagrama de Clases...................................... ¡Error! Marcador no definido.

3.1 Clase Base

3.2 Clase Derivada

3.2.1 Control de acceso de la clase base

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

3.3 Miembros Protected

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

3.3.1 Atributos Protected

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

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

3.4 Constructores de clases derivadas

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

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

3.4.2 Inicialización de objetos miembros de clases

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

3.4.3 Sobrecarga de constructores de clases derivadas

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

3.5 Destructores de clases derivadas

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

3.5.1 Tipos de miembros

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

3.6 Clases de derivación( especificadores de acceso)

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

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

3.6.2 DERIVACIÓN PROTEGIDA (PROTECTED)

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

3.6.3 DERIVACIÓN PRIVADA (PRIVATE).

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

Fig nro. 1: Diagrama de clases de Cliente

Fig nro. 2: Diagrama de clases de Vehiculo

4.2 Diagrama de secuencia

Fig nro. 3: Diagrama de secuencia de Cliente

Fig nro. 4: Diagrama de secuencia de Vehiculo

for (char& c : direccion) {

// Convertir el número en una cadena de dígitos

for (char c : numeroStr) {

// Convertir la cadena encriptada de nuevo a un número

class Automovil : public Vehiculo

class Motocicleta : public Vehiculo

Motocicleta(string marca ="", string modelo= "", int aniofab = 0,

cout<<"CLASE DERIVADA AUTOMOVIL"<<endl;

cout<<"CLASE DERIVADA MOTOCICLETA"<<endl;

class Empleado : public Persona

string getCorreoElcEMPLEADO() {return correoElc;}

string getCorreoElcCLIENTE() {return correoElc;}

void usarCorreoElectronicoCLIENTE() {cout <<"Correo Electronico

cout<<"Salario: "<<objEmpleado.salario <<endl;

class Tablet : public Movil

cout<<"CLASE BASE TELEFONO"<<endl;

cout<<"CLASE BASE TABLET"<<endl;

class DerivedClass : public BaseClass {

n) Proporciona un ejemplo de uso de la herencia privada en C++.

class Circle : virtual public Shape {

std::cout << "Drawing circle" << std::endl;

class Square : virtual public Shape {

class SquareCircle : public Square, public Circle {