CLASE_4 Introducción a la Programación Orientada a Objetos

A continuación, te presento un tutorial sobre la Programación Orientada a Objetos (POO) en C++, centrándonos en sus principios, herencia, polimorfismo y la implementación de sobrecarga de constructores.

Programación Orientada a Objetos (POO) en C++: Principios Fundamentales y Constructores Sobrecargados

¡Bienvenidos a una inmersión profunda en la Programación Orientada a Objetos (POO) en C++! La POO es un paradigma de programación que organiza el software en torno a "objetos" en lugar de acciones y datos. Comprender sus principios es crucial para escribir código modular, reutilizable y fácil de mantener.

1. Principios Fundamentales de la Programación Orientada a Objetos

La POO se basa en cuatro pilares principales:

Encapsulamiento:
- Concepto: Consiste en agrupar los datos (atributos) y los métodos (funciones) que operan sobre esos datos en una única unidad llamada clase. Además, controla el acceso a esos datos y métodos, ocultando la implementación interna y exponiendo solo lo necesario.
- Beneficio: Protege los datos de accesos indebidos y asegura que los objetos se manipulen de manera controlada, reduciendo efectos secundarios no deseados.
- En C++: Se logra mediante especificadores de acceso (public, private, protected). Los atributos suelen ser private y se accede a ellos a través de métodos public (getters y setters).
Abstracción:
- Concepto: Se enfoca en mostrar solo las características esenciales de un objeto y ocultar los detalles complejos de su implementación. Es como usar un teléfono: sabemos cómo llamar, pero no necesitamos saber cómo funciona internamente la red.
- Beneficio: Simplifica el modelo del sistema, permite a los programadores centrarse en lo "qué hace" un objeto en lugar de "cómo lo hace".
- En C++: Se logra mediante interfaces, clases abstractas (con métodos virtuales puros) y el encapsulamiento.
Herencia:
- Concepto: Permite que una clase (clase derivada o subclase) herede propiedades y comportamientos (atributos y métodos) de otra clase (clase base o superclase). Establece una relación "es un" (ej., "Un Perro es un Animal").
- Beneficio: Promueve la reutilización de código, ya que las características comunes se definen una vez en la clase base y son compartidas por todas las clases derivadas. Facilita la creación de jerarquías de clases.
- En C++: Se especifica usando el operador : después del nombre de la clase derivada, seguido del especificador de acceso y el nombre de la clase base (ej., class Perro : public Animal { ... };).
Polimorfismo:
- Concepto: Significa "muchas formas". Permite que objetos de diferentes clases (pero relacionadas por herencia) respondan a la misma llamada de método de manera diferente, según su tipo específico.
- Beneficio: Permite escribir código más genérico y flexible. Puedes tratar objetos de diferentes tipos de manera uniforme.
- En C++: Se logra principalmente a través de funciones virtuales y punteros o referencias a la clase base. Cuando una función es declarada virtual en la clase base y es sobrescrita en las clases derivadas, la versión del método que se ejecuta en tiempo de ejecución depende del tipo real del objeto al que apunta el puntero/referencia de la clase base.

2. Mecanismos Fundamentales: Herencia y Polimorfismo en C++

Vamos a ilustrar la herencia y el polimorfismo con un ejemplo sencillo.

Ejemplo de Herencia y Polimorfismo: Animales y Sonidos

C++
#include <iostream>
#include <string>

// Clase Base: Animal
class Animal {
protected: // protected permite acceso a clases derivadas
    std::string nombre;
    int edad;

public:
    // Constructor de la clase base
    Animal(std::string nom, int ed) : nombre(nom), edad(ed) {
        std::cout << "Constructor de Animal: " << nombre << std::endl;
    }

    // Método virtual: permite polimorfismo
    virtual void hacerSonido() const {
        std::cout << "El animal " << nombre << " hace un sonido genérico." << std::endl;
    }

    void mostrarInfo() const {
        std::cout << "Nombre: " << nombre << ", Edad: " << edad << std::endl;
    }

    // Destructor virtual: importante para el polimorfismo con liberación de memoria
    virtual ~Animal() {
        std::cout << "Destructor de Animal: " << nombre << std::endl;
    }
};

// Clase Derivada: Perro (hereda de Animal)
class Perro : public Animal {
private:
    std::string raza;

public:
    // Constructor de Perro. Llama explícitamente al constructor de la clase base
    Perro(std::string nom, int ed, std::string rz) : Animal(nom, ed), raza(rz) {
        std::cout << "Constructor de Perro: " << nombre << " (" << raza << ")" << std::endl;
    }

    // Sobreescritura del método virtual hacerSonido()
    void hacerSonido() const override { // 'override' es opcional pero buena práctica
        std::cout << "El perro " << nombre << " ladra: ¡Guau! ¡Guau!" << std::endl;
    }

    void mostrarInfoPerro() const {
        mostrarInfo(); // Llama al método de la clase base
        std::cout << "Raza: " << raza << std::endl;
    }

    ~Perro() override {
        std::cout << "Destructor de Perro: " << nombre << std::endl;
    }
};

// Clase Derivada: Gato (hereda de Animal)
class Gato : public Animal {
public:
    // Constructor de Gato
    Gato(std::string nom, int ed) : Animal(nom, ed) {
        std::cout << "Constructor de Gato: " << nombre << std::endl;
    }

    // Sobreescritura del método virtual hacerSonido()
    void hacerSonido() const override {
        std::cout << "El gato " << nombre << " maulla: ¡Miau! ¡Miau!" << std::endl;
    }

    ~Gato() override {
        std::cout << "Destructor de Gato: " << nombre << std::endl;
    }
};

// Función global que demuestra el polimorfismo
void hacerSonidoGenerico(const Animal* animal) {
    // Aunque 'animal' es un puntero a Animal, la llamada a hacerSonido()
    // ejecutará la versión correcta (Perro, Gato o Animal) en tiempo de ejecución
    animal->hacerSonido();
}

int main() {
    std::cout << "--- Demostración de Herencia y Polimorfismo ---" << std::endl;

    // Creación de objetos de las clases derivadas
    Perro miPerro("Buddy", 5, "Labrador");
    Gato miGato("Whiskers", 3);
    Animal miAnimal("Desconocido", 10);

    std::cout << "\n--- Sonidos Directos ---" << std::endl;
    miPerro.hacerSonido();     // Llama a la versión de Perro
    miGato.hacerSonido();      // Llama a la versión de Gato
    miAnimal.hacerSonido();    // Llama a la versión de Animal

    std::cout << "\n--- Polimorfismo con punteros a clase base ---" << std::endl;
    // Punteros a la clase base Animal
    Animal* ptrAnimal1 = &miPerro;
    Animal* ptrAnimal2 = &miGato;
    Animal* ptrAnimal3 = &miAnimal;

    ptrAnimal1->hacerSonido(); // Llama a Perro::hacerSonido()
    ptrAnimal2->hacerSonido(); // Llama a Gato::hacerSonido()
    ptrAnimal3->hacerSonido(); // Llama a Animal::hacerSonido()

    std::cout << "\n--- Polimorfismo con función genérica ---" << std::endl;
    hacerSonidoGenerico(&miPerro);
    hacerSonidoGenerico(&miGato);
    hacerSonidoGenerico(&miAnimal);

    std::cout << "\n--- Usando new para mostrar la importancia del destructor virtual ---" << std::endl;
    Animal* animalDinamico1 = new Perro("Max", 7, "Pastor Alemán");
    Animal* animalDinamico2 = new Gato("Luna", 2);
    animalDinamico1->hacerSonido();
    animalDinamico2->hacerSonido();

    // Sin destructor virtual en Animal, solo se llamaría a ~Animal() para animalDinamico1 y animalDinamico2.
    // Con destructor virtual, se llama primero al destructor de la clase derivada (~Perro, ~Gato)
    // y luego al destructor de la clase base (~Animal).
    delete animalDinamico1;
    delete animalDinamico2;

    std::cout << "\n--- Fin de la demostración ---" << std::endl;
    return 0;
}

Explicación del Ejemplo:

Herencia: Perro y Gato heredan de Animal. Esto se ve en la sintaxis class Perro : public Animal. Heredan los atributos nombre y edad (accesibles porque son protected) y el método mostrarInfo().
Polimorfismo:
- El método hacerSonido() es declarado virtual en la clase base Animal. Esto le dice al compilador que la decisión de qué hacerSonido() llamar debe hacerse en tiempo de ejecución, basándose en el tipo real del objeto.
- Perro y Gato sobreescriben (override) este método para proporcionar su propia implementación específica.
- Cuando usamos punteros o referencias a Animal (Animal* ptrAnimal1 = &miPerro; o void hacerSonidoGenerico(const Animal* animal)), y llamamos a hacerSonido(), C++ determina dinámicamente qué versión del método debe ejecutar. Esto es el polimorfismo.
Destructores Virtuales: Es una buena práctica declarar el destructor de la clase base como virtual si esperas usar polimorfismo con objetos creados dinámicamente (new). Esto asegura que el destructor de la clase derivada sea llamado primero, evitando fugas de memoria y comportamientos indefinidos.

3. Sobrecarga de Constructores (Constructores Múltiples)

La sobrecarga de constructores permite que una clase tenga múltiples constructores, siempre y cuando cada uno tenga una lista de parámetros diferente (ya sea en el número de parámetros o en el tipo de los parámetros, o en el orden). Esto proporciona flexibilidad al inicializar objetos.

Ejemplo de Sobrecarga de Constructores: Clase `Libro`

C++
#include <iostream>
#include <string>

class Libro {
private:
    std::string titulo;
    std::string autor;
    int anioPublicacion;
    std::string isbn;
    bool disponible;

public:
    // Constructor 1: Constructor por defecto
    // Inicializa el libro con valores predeterminados
    Libro() : titulo("Sin Titulo"), autor("Desconocido"), anioPublicacion(0), isbn("N/A"), disponible(true) {
        std::cout << "Constructor por defecto (Libro vacío) llamado." << std::endl;
    }

    // Constructor 2: Con título y autor
    // Útil para inicializaciones rápidas
    Libro(std::string t, std::string a) : titulo(t), autor(a), anioPublicacion(0), isbn("N/A"), disponible(true) {
        std::cout << "Constructor (Titulo, Autor) llamado." << std::endl;
    }

    // Constructor 3: Con todos los parámetros principales
    // Inicialización completa del libro
    Libro(std::string t, std::string a, int ap, std::string i)
        : titulo(t), autor(a), anioPublicacion(ap), isbn(i), disponible(true) {
        std::cout << "Constructor (Completo) llamado." << std::endl;
    }

    // Constructor 4: Constructor de copia (aunque no se pide explícitamente, es un constructor común)
    // Permite crear un nuevo objeto como copia de uno existente
    Libro(const Libro& otroLibro)
        : titulo(otroLibro.titulo), autor(otroLibro.autor), anioPublicacion(otroLibro.anioPublicacion),
          isbn(otroLibro.isbn), disponible(otroLibro.disponible) {
        std::cout << "Constructor de copia llamado para: " << titulo << std::endl;
    }

    // Método para mostrar la información del libro
    void mostrarInfo() const {
        std::cout << "Título: " << titulo
                  << ", Autor: " << autor
                  << ", Año: " << anioPublicacion
                  << ", ISBN: " << isbn
                  << ", Disponible: " << (disponible ? "Sí" : "No")
                  << std::endl;
    }
};

int main() {
    std::cout << "--- Demostración de Sobrecarga de Constructores ---" << std::endl;

    // Utilizando el Constructor 1 (por defecto)
    Libro libro1;
    libro1.mostrarInfo();

    std::cout << std::endl;

    // Utilizando el Constructor 2 (Título, Autor)
    Libro libro2("El Principito", "Antoine de Saint-Exupéry");
    libro2.mostrarInfo();

    std::cout << std::endl;

    // Utilizando el Constructor 3 (Completo)
    Libro libro3("Cien Años de Soledad", "Gabriel García Márquez", 1967, "978-0-307-45529-6");
    libro3.mostrarInfo();

    std::cout << std::endl;

    // Utilizando el Constructor 4 (de copia)
    Libro libro4 = libro3; // Esto invoca el constructor de copia
    libro4.mostrarInfo();

    std::cout << "\n--- Fin de la demostración ---" << std::endl;
    return 0;
}

Explicación del Ejemplo de Sobrecarga de Constructores:

Múltiples Constructores: La clase Libro tiene cuatro constructores diferentes. Cada uno se distingue por la cantidad o el tipo de sus parámetros:
- Libro(): No toma ningún parámetro. Es el constructor por defecto.
- Libro(std::string t, std::string a): Toma dos parámetros de tipo std::string (título y autor).
- Libro(std::string t, std::string a, int ap, std::string i): Toma cuatro parámetros de diferentes tipos.
- Libro(const Libro& otroLibro): Es el constructor de copia, toma una referencia constante a otro objeto Libro.
Lista de Inicialización de Miembros (: atributo(param)):
- En los constructores, se utiliza una lista de inicialización (: titulo(t), autor(a), ...) antes del cuerpo del constructor ({ ... }).
- Ventaja: Esta es la forma preferida y más eficiente de inicializar los atributos de una clase en C++, especialmente para atributos de tipo objeto (como std::string). Los atributos se inicializan directamente, en lugar de ser primero construidos con su constructor por defecto y luego asignados. Para tipos fundamentales (como int), no hay una diferencia significativa en rendimiento, pero es buena práctica mantener la consistencia.
Flexibilidad en la Creación de Objetos:
- Libro libro1;: Crea un Libro vacío con valores predeterminados.
- Libro libro2("El Principito", "Antoine de Saint-Exupéry");: Crea un Libro especificando solo el título y el autor.
- Libro libro3("Cien Años de Soledad", ..., 1967, ...);: Crea un Libro con todos los detalles.
- Libro libro4 = libro3;: Crea un nuevo Libro copiando los datos de libro3.

4. Compilación y Ejecución

Para compilar y ejecutar cualquiera de los ejemplos (guárdalos en archivos .cpp separados, por ejemplo, animales.cpp y libros.cpp):

Guarda el código: Por ejemplo, guarda el código de Animales en animales.cpp.
Compila: Abre una terminal y usa g++:
Bash
g++ animales.cpp -o animales_ejemplo
(Haz lo mismo para libros.cpp si lo guardaste por separado: g++ libros.cpp -o libros_ejemplo)
Ejecuta:
Bash
./animales_ejemplo
(o ./libros_ejemplo)

La Programación Orientada a Objetos es un paradigma potente que te permitirá modelar problemas complejos de manera más intuitiva y desarrollar aplicaciones robustas y mantenibles. La herencia y el polimorfismo son herramientas clave para la reutilización de código y la flexibilidad, mientras que la sobrecarga de constructores te da un control fino sobre cómo se inicializan tus objetos.

3DSON

Buscar este blog