Programación Orientada a Objetos Grupo 744.

Gabriel Montaña - 20221007070

Sergio Cifuentes - 20221007059
Docente. José Guillermo Guarnizo Marin. Ph.D.
Subir el informe el 8 de junio en la plataforma Moodle a lo largo del día.
Fecha de sustentación 9 de junio de 2 pm a 4 pm. 703 Sabio Caldas.
Máximo de a 2. Asistencia obligatoria a la sustentación o se califica sobre 3 el proyecto
final, vale por 2 notas del corte.
Proyecto final: Sistema de gestión de empleados
Descripción del proyecto: El proyecto consiste en desarrollar un sistema de gestión de
empleados utilizando programación orientada a objetos en C++. El sistema debe permitir a
los estudiantes de ingeniería de segundo semestre realizar operaciones básicas
relacionadas con la gestión de empleados en una empresa. El proyecto debe involucrar
conceptos de herencia y polimorfismo para representar diferentes tipos de empleados en
la empresa.
Características del sistema:
1. Clase base "Empleado": Crear una clase base llamada "Empleado" que contenga
los atributos comunes a todos los empleados, como nombre, número de
identificación y salario. Esta clase debe tener métodos para obtener y establecer
estos atributos.
2. Clases derivadas: Crear al menos dos clases derivadas de la clase base "Empleado",
como "EmpleadoAsalariado" y "EmpleadoPorHoras". Estas clases deben heredar
los atributos y métodos de la clase base, y además agregar atributos específicos y
métodos relevantes a cada tipo de empleado. Por ejemplo, la clase
"EmpleadoAsalariado" podría tener un atributo adicional para el salario mensual,
mientras que la clase "EmpleadoPorHoras" podría tener atributos para las horas
trabajadas y la tarifa por hora.
3. Polimorfismo: Utilizar polimorfismo para implementar un método virtual llamado
"calcularSalario()" en la clase base "Empleado". Este método debe ser sobreescrito
en cada clase derivada para calcular el salario específico de cada tipo de empleado.
Por ejemplo, la clase "EmpleadoAsalariado" podría devolver el salario mensual sin
realizar ningún cálculo adicional, mientras que la clase "EmpleadoPorHoras" podría
multiplicar las horas trabajadas por la tarifa por hora para obtener el salario.
 4. Gestión de empleados: Implementar operaciones de gestión de empleados, como
agregar un nuevo empleado, mostrar la información de todos los empleados y
calcular el salario de un empleado específico. Estas operaciones deben interactuar
con las clases derivadas utilizando polimorfismo, es decir, deben funcionar
correctamente independientemente del tipo de empleado que se esté manejando.
Requisitos técnicos:
1. Utilizar programación orientada a objetos en C++ para implementar el sistema.
2. Utilizar herencia para crear las clases derivadas de la clase base "Empleado".
3. Utilizar polimorfismo al implementar el método virtual "calcularSalario()".
4. Utilizar estructuras de datos adecuadas para almacenar la información de los
empleados, como arreglos o contenedores estándar de C++.
5. Utilizar funciones y métodos para realizar las operaciones del sistema.
6. Implementar una interfaz de usuario basada en la consola, donde los usuarios
puedan interactuar con el sistema a través de comandos simples.
Entregables esperados:
1. Código fuente del proyecto en C++.
2. Documentación del proyecto, que incluya una descripción detallada de las clases y
su funcionalidad, así como instrucciones para compilar y ejecutar el sistema. Para
esto realizar diagramas de clases y diagramas de objetos.
3. Un informe que describa las decisiones de diseño tomadas durante el desarrollo
del proyecto y las dificultades encontradas.
Bibliografía sugerida.
1. "Effective C++: 55 Specific Ways to Improve Your Programs and Designs" by Scott
Meyers.
2. "Design Patterns: Elements of Reusable Object-Oriented Software" by Erich
Gamma, Richard Helm, Ralph Johnson, and John Vlissides.
3. "C++ Primer" by Stanley B. Lippman, Josée Lajoie, and Barbara E. Moo.
4. "Clean Code: A Handbook of Agile Software Craftsmanship" by Robert C. Martin.
5. "Object-Oriented Programming in C++" by Robert Lafore.
6. "Modern C++ Design: Generic Programming and Design Patterns Applied" by
Andrei Alexandrescu.
 7. "Thinking in C++, Volumes 1 and 2" by Bruce Eckel.
8. "C++ Programming: From Problem Analysis to Program Design" by D.S. Malik.
9. "Accelerated C++: Practical Programming by Example" by Andrew Koenig and
Barbara E. Moo.
10. "Head First Design Patterns" by Eric Freeman, Elisabeth Robson, Bert Bates, and
Kathy Sierra.
1. "Programación en C++: Curso práctico del lenguaje" de Luis Joyanes Aguilar y
Matilde Fernández Azuela.
2. "Aprenda programación orientada a objetos en C++" de Rubén Fuentes Fernández.
3. "Programación orientada a objetos en C++: Conceptos, técnicas y aplicaciones" de
Rafael López García.
4. "Programación Orientada a Objetos en C++" de Julián Vargas Núñez.
5. "Introducción a la programación orientada a objetos en C++" de Carlos Rafael
Gómez Zapata.
6. "Aprende a programar con C++" de Ángel Arias.
7. "Patrones de diseño: Elementos de software orientado a objetos reutilizable" de
Erich Gamma, Richard Helm, Ralph Johnson y John Vlissides.
8. "C++: El lenguaje de programación" de Bjarne Stroustrup.
9. "Programación orientada a objetos con C++" de Ernesto Hijar.
10. "Programación orientada a objetos en C++" de Carlos Toro.

Código
#include <iostream>

#include <vector>

using namespace std;

class Empleado {

protected:

string nombre;

int identificacion;

double salario;
public:

Empleado(const string& nombre, int identificacion, double salario)

: nombre(nombre), identificacion(identificacion), salario(salario) {}

virtual ~Empleado() {}

string getNombre() const {

return nombre;

void setNombre(const string& nombre) {

this->nombre = nombre;

int getIdentificacion() const {

return identificacion;

void setIdentificacion(int identificacion) {

this->identificacion = identificacion;

double getSalario() const {

return salario;

void setSalario(double salario) {

this->salario = salario;

virtual double calcularSalario() const = 0;

};

class EmpleadoAsalariado : public Empleado {

public:

EmpleadoAsalariado(const string& nombre, int identificacion, double salario)

: Empleado(nombre, identificacion, salario) {}

double calcularSalario() const override {

return salario;

};

class EmpleadoPorHoras : public Empleado {

private:

double horasTrabajadas;

double tarifaPorHora;

public:

EmpleadoPorHoras(const string& nombre, int identificacion, double tarifaPorHora)

: Empleado(nombre, identificacion, 0), horasTrabajadas(0), tarifaPorHora(tarifaPorHora) {}

double getHorasTrabajadas() const {

return horasTrabajadas;

void setHorasTrabajadas(double horasTrabajadas) {

this->horasTrabajadas = horasTrabajadas;

double getTarifaPorHora() const {

return tarifaPorHora;

void setTarifaPorHora(double tarifaPorHora) {

this->tarifaPorHora = tarifaPorHora;

}
 double calcularSalario() const override {

return horasTrabajadas * tarifaPorHora;

};

class SistemaEmpleados {

private:

vector<Empleado*> empleados;

public:

void agregarEmpleado(Empleado* empleado) {

empleados.push_back(empleado);

void mostrarInformacionEmpleados() const {

for (const auto& empleado : empleados) {

cout << "Nombre: " << empleado->getNombre() << endl;

cout << "Identificacion: " << empleado->getIdentificacion() << endl;

cout << "Salario: " << empleado->getSalario() << endl;

cout << "------------------------------" << endl;

double calcularSalarioEmpleado(int identificacion) const {

for (const auto& empleado : empleados) {

if (empleado->getIdentificacion() == identificacion) {

return empleado->calcularSalario();

return 0.0; // Retorna 0 si no se encuentra el empleado con la identificacion especificada

};

int main() {

SistemaEmpleados sistema;
 while (true) {

cout << "==== MENU ====" << endl;

cout << "1. Agregar empleado" << endl;

cout << "2. Mostrar informacion de empleados" << endl;

cout << "3. Calcular salario de empleado" << endl;

cout << "4. Salir" << endl;

cout << "Ingrese el numero de opcion: ";

int opcion;

cin >> opcion;

switch (opcion) {

case 1: {

cout << "Ingrese el nombre del empleado: ";

string nombre;

cin.ignore();

getline(cin, nombre);

int identificacion;

cout << "Ingrese la identificacion del empleado: ";

cin >> identificacion;

int tipoEmpleado;

cout << "Ingrese el tipo de empleado (1 - Asalariado, 2 - Por Horas): ";

cin >> tipoEmpleado;

if (tipoEmpleado == 1) {

double salarioMensual;

cout << "Ingrese el salario mensual del empleado: ";

cin >> salarioMensual;

sistema.agregarEmpleado(new EmpleadoAsalariado(nombre, identificacion,

salarioMensual));

} else if (tipoEmpleado == 2) {
 double tarifaPorHora;

cout << "Ingrese la tarifa por hora del empleado: ";

cin >> tarifaPorHora;

double horasTrabajadas;

cout << "Ingrese las horas trabajadas del empleado: ";

cin >> horasTrabajadas;

EmpleadoPorHoras* empleadoPorHoras = new EmpleadoPorHoras(nombre, identificacion,

tarifaPorHora);

empleadoPorHoras->setHorasTrabajadas(horasTrabajadas);

sistema.agregarEmpleado(empleadoPorHoras);

cout << "Empleado agregado correctamente." << endl;

break;

case 2:

cout << "Informacion de empleados:" << endl;

sistema.mostrarInformacionEmpleados();

break;

case 3: {

int identificacion;

cout << "Ingrese la identificacion del empleado para calcular su salario: ";

cin >> identificacion;

double salario = sistema.calcularSalarioEmpleado(identificacion);

cout << "Salario del empleado con identificacion " << identificacion << ": " << salario << endl;

break;

case 4:

cout << "Saliendo del programa..." << endl;

return 0;

default:
 cout << "Opcion invalida. Por favor, ingrese una opcion valida." << endl;

break;

cout << "------------------------------" << endl;

Descripción
 Se definen tres clases principales: Empleado, EmpleadoAsalariado y
EmpleadoPorHoras. La clase Empleado es la clase base, y las clases
EmpleadoAsalariado y EmpleadoPorHoras son clases derivadas de la clase base.
 La clase Empleado tiene atributos comunes a todos los empleados, como nombre,
identificación y salario. También tiene métodos para obtener y establecer estos
atributos, así como un método virtual puro llamado calcularSalario(), que se
implementará en las clases derivadas.
 La clase EmpleadoAsalariado representa a un empleado asalariado y hereda de la
clase Empleado. No tiene atributos adicionales ni modifica los métodos heredados.
 La clase EmpleadoPorHoras representa a un empleado que se paga por horas
trabajadas y también hereda de la clase Empleado. Tiene atributos adicionales
para almacenar las horas trabajadas y la tarifa por hora, y también implementa el
método calcularSalario() de manera diferente para calcular el salario en función de
las horas trabajadas y la tarifa por hora.
 La clase SistemaEmpleados se encarga de gestionar la colección de empleados.
Tiene un vector de punteros a objetos Empleado para almacenar los empleados
agregados.
 El método agregarEmpleado() permite agregar un objeto Empleado al vector de
empleados.
 El método mostrarInformacionEmpleados() muestra en la consola la información
de todos los empleados almacenados en el vector.
 El método calcularSalarioEmpleado() recibe una identificación de empleado y
busca en el vector el empleado correspondiente. Si lo encuentra, llama al método
calcularSalario() del empleado y devuelve el salario calculado. Si no encuentra al
empleado, devuelve 0.
 El programa principal (main()) implementa una interfaz de usuario basada en la
consola. Muestra un menú con diferentes opciones: agregar empleado, mostrar
información de empleados, calcular salario de empleado y salir del programa.
 Dependiendo de la opción seleccionada por el usuario, se ejecuta el código
correspondiente en el switch para llevar a cabo la operación deseada. Por ejemplo,
al seleccionar la opción "Agregar empleado", se solicita al usuario que ingrese los
 datos del empleado y se llama al método agregarEmpleado() del objeto
SistemaEmpleados para agregarlo al sistema.
 El programa se ejecuta en un bucle while (true) para que el menú se muestre
continuamente hasta que el usuario elija la opción de salir.
 Se utilizan las funciones cout y cin para mostrar mensajes en la consola y recibir la
entrada del usuario, respectivamente.

Diagrama de clases
+----------------+

| Empleado |

+----------------+

| - nombre |

| - identificacion|

| - salario |

+----------------+

| + getNombre() |

| + setNombre() |

| + getIdentifi- |

| cacion() |

| + setIdentifi- |

| cacion() |

| + getSalario() |

| + setSalario() |

| + calcularSala-|

| rio() |

+-------+--------+

+---------+--------+
|EmpladoAsalariado|

+-----------------+

| |

+-----------------+

| + calcularSala- |

| rio() |

+-----------------+

+---------+--------+

| EmpleadoPorHoras|

+-----------------+

| - horasTrabajadas|

| - tarifaPorHora |

+-----------------+

| + getHorasTraba-|

| jadas() |

| + setHorasTraba-|

| jadas() |

| + getTarifaPor- |

| Hora() |

| + setTarifaPor- |

| Hora() |

| + calcularSala- |

| rio() |

+-------+--------+

^
 |

+-------+--------+

| SistemaEmpleados|

+-----------------+

| - empleados |

+-----------------+

| + agregarEmplea-|

| do() |

| + mostrarInfor- |

| macionEmplea- |

| dos() |

| + calcularSala- |

| rioEmpleado() |

+-----------------+

En este diagrama de clases, se muestra la estructura de las clases y sus relaciones. La clase
Empleado es la clase base que tiene los atributos comunes a todos los empleados, como nombre,
identificación y salario. También define el método virtual puro calcularSalario().

Las clases EmpleadoAsalariado y EmpleadoPorHoras son clases derivadas de Empleado y heredan

sus atributos y métodos. EmpleadoPorHoras tiene atributos adicionales para almacenar las horas
trabajadas y la tarifa por hora.

La clase SistemaEmpleados se encarga de gestionar los empleados y tiene una asociación con la
clase Empleado. Contiene un vector de punteros a objetos Empleado para almacenar los
empleados agregados. Los métodos agregarEmpleado(), mostrarInformacionEmpleados() y
calcularSalarioEmpleado() permiten agregar empleados, mostrar su información y calcular el
salario de un empleado específico.

Diagrama de objetos
+------------------------------------+

| SistemaEmpleados |

+------------------------------------+

| - empleados: vector<Empleado*> |
+------------------------------------+

| + agregarEmpleado(empleado: Empleado*) |

| + mostrarInformacionEmpleados() |

| + calcularSalarioEmpleado(identificacion: int) |

+------------------------------------+

+-----------+------------+

| |

+--------------------+ +---------------------+

| Empleado | | EmpleadoAsalariado |

+--------------------+ +---------------------+

| - nombre || |

| - identificacion | +---------------------+

| - salario || |

+--------------------+ +---------------------+

| + getNombre() || |

| + setNombre() | | + calcularSalario() |

| + getIdentificacion() | |

| + setIdentificacion() | |

| + getSalario() || |

| + setSalario() || |

| + calcularSalario() | | |

+--------------------+ +---------------------+

+-----------+------------+

| |

+------------------------------------+

| EmpleadoPorHoras |

+------------------------------------+
| - horasTrabajadas |

| - tarifaPorHora |

+------------------------------------+

| + getHorasTrabajadas() |

| + setHorasTrabajadas() |

| + getTarifaPorHora() |

| + setTarifaPorHora() |

| + calcularSalario() |

+------------------------------------+

En este diagrama de objetos, se representan las instancias de las clases que se crean
durante la ejecución del programa.
El objeto SistemaEmpleados es el encargado de gestionar los empleados y tiene
asociaciones con las clases Empleado, EmpleadoAsalariado y EmpleadoPorHoras.
Contiene un vector de punteros a objetos Empleado llamado empleados, donde se
almacenan los empleados agregados.
Las instancias de las clases Empleado, EmpleadoAsalariado y EmpleadoPorHoras
representan empleados individuales con sus respectivos atributos. Las clases derivadas
EmpleadoAsalariado y EmpleadoPorHoras heredan los atributos y métodos de la clase
base Empleado y agregan funcionalidades específicas. Por ejemplo, EmpleadoPorHoras
tiene atributos adicionales horasTrabajadas y tarifaPorHora, y también tiene su propia
implementación del método calcularSalario().
Las flechas indican las relaciones entre los objetos. Por ejemplo, el objeto
SistemaEmpleados se relaciona con los objetos Empleado a través del vector empleados.
Además, los métodos de SistemaEmpleados interactúan con los objetos de las clases
Empleado para realizar operaciones como agregar empleados, mostrar información y
calcular salarios.

Informe de Diseño y Dificultades en el Desarrollo del Proyecto

Durante el desarrollo del proyecto de implementación del sistema de gestión de
empleados, se tomaron varias decisiones de diseño con el objetivo de lograr una solución
eficiente, fácil de mantener y que cumpla con los requisitos establecidos. Sin embargo,
también se encontraron algunas dificultades que requerían soluciones creativas. A
continuación, se describen las decisiones de diseño tomadas y las dificultades
encontradas:
Decisiones de Diseño:
 1. Uso de Programación Orientada a Objetos (POO): Se decidió utilizar el paradigma
de POO para organizar el código en clases y objetos, lo cual permite una estructura
modular y promueve la reutilización de código.
2. Uso de Herencia: Se aplicó la herencia para crear las clases derivadas
EmpleadoAsalariado y EmpleadoPorHoras, aprovechando la relación "es-un"
entre las clases derivadas y la clase base Empleado. Esto permitió definir atributos
y métodos específicos para cada tipo de empleado y reutilizar el código común de
la clase base.
3. Implementación de Polimorfismo: Se utilizó el polimorfismo al definir el método
virtual calcularSalario() en la clase base Empleado y sobrescribirlo en las clases
derivadas. Esto permitió que el método se comporte de manera diferente según el
tipo de empleado, facilitando el cálculo del salario específico de cada tipo.
4. Uso de contenedores de C++: Se eligió utilizar un vector de punteros a objetos
Empleado para almacenar los empleados en la clase SistemaEmpleados. Esto
proporcionó flexibilidad al permitir agregar y acceder a los empleados de manera
dinámica.
Dificultades Encontradas:
1. Gestión de memoria: Una dificultad principal fue la correcta gestión de la memoria
al trabajar con punteros y objetos dinámicos. Se tuvo que garantizar la liberación
adecuada de la memoria asignada a los objetos para evitar fugas de memoria y
problemas de acceso inválido.
2. Validación de entradas de usuario: Otra dificultad fue garantizar la validación
adecuada de las entradas de usuario al solicitar datos como el nombre, la
identificación y el salario. Se implementaron verificaciones para asegurar que los
valores ingresados sean válidos y cumplan con los requisitos esperados.
3. Interfaz de usuario: La implementación de una interfaz de usuario basada en la
consola también presentó desafíos. Se tuvo que diseñar un flujo de interacción
intuitivo para que los usuarios pudieran agregar empleados, ver la información y
calcular salarios de manera fácil y comprensible.
4. Cálculo del salario: El cálculo del salario para cada tipo de empleado requería
lógicas diferentes. Se necesitó un diseño cuidadoso para garantizar que el método
calcularSalario() se implementara correctamente en las clases derivadas y
devolviera el resultado esperado.
En general, el proyecto de implementación del sistema de gestión de empleados requirió
la toma de decisiones de diseño cuidadosas y la superación de dificultades técnicas. El
enfoque de la POO, la herencia y el polimorfismo resultaron útiles para organizar el código
y lograr un sistema flexible y extensible. A través de soluciones creativas y pruebas
rigurosas, se logró desarrollar un sistema funcional que cumple con los requisitos
establecidos.

Resultados del código

DIAGRAMA DE FLUJO

Paso a Paso
PASO A PASO PROYECTO.mp4