Clases·Objetos
Herencia·Polimorfismo

// ===== Definición de la clase =====
class Animal {
private:
    std::string nombre;
    int edad;

public:
    // Constructor
    Animal(std::string n, int e)
        : nombre(n), edad(e) {}

    void comer() {
        std::cout << nombre << " está comiendo";
    }

    std::string getNombre() const {
        return nombre;
    }
};

// ===== Creación de objetos (instancias) =====
int main() {
    Animal rex("Rex", 3);   // objeto en stack
    rex.comer();

    Animal* p = new Animal("Miau", 1); // en heap
    p->comer();
    delete p;
}

class CuentaBancaria {
private:
    double saldo;  // nadie accede directo

public:
    CuentaBancaria(double inicial) : saldo(inicial) {}

    // setter con validación
    void depositar(double monto) {
        if (monto > 0) saldo += monto;
    }

    bool retirar(double monto) {
        if (monto <= 0 || monto > saldo)
            return false;  // invariante protegido
        saldo -= monto;
        return true;
    }

    // getter de solo lectura
    double getSaldo() const { return saldo; }
};

class Mascota {
private:
    std::string nombre;
    int* edad;  // recurso dinámico

public:
    // Constructor por defecto
    Mascota() : nombre("Sin nombre"), edad(new int(0)) {
        std::cout << "Constructor por defecto\n";
    }

    // Constructor parametrizado
    Mascota(std::string n, int e)
        : nombre(n), edad(new int(e)) {
        std::cout << "Constructor parametrizado\n";
    }

    // Destructor — libera el recurso
    ~Mascota() {
        delete edad;
        std::cout << nombre << " destruida\n";
    }
};

class Animal {
protected:
    std::string nombre;
public:
    Animal(std::string n) : nombre(n) {}
    void dormir() { std::cout << nombre << " duerme\n"; }
    virtual void sonido() { std::cout << "..."; }
};

// Perro HEREDA de Animal — es-un Animal
class Perro : public Animal {
public:
    Perro(std::string n) : Animal(n) {}  // llama al ctor base

    // Sobrescribe (override) el comportamiento
    void sonido() override {
        std::cout << nombre << " dice: Guau!\n";
    }

    // Método nuevo, exclusivo de Perro
    void buscarPelota() {
        std::cout << nombre << " busca la pelota\n";
    }
};

int main() {
    Perro rex("Rex");
    rex.dormir();       // heredado de Animal
    rex.sonido();       // sobrescrito por Perro
    rex.buscarPelota(); // propio de Perro
}

class Animal {
public:
    virtual void sonido() { std::cout << "..."; }
    virtual ~Animal() {}  // destructor virtual ★
};

class Perro : public Animal {
public:
    void sonido() override { std::cout << "Guau!"; }
};

class Gato : public Animal {
public:
    void sonido() override { std::cout << "Miau!"; }
};

// ===== El mismo código, distinto resultado =====
void hacerSonar(Animal* a) {
    a->sonido();  // decide en tiempo de EJECUCIÓN
}

int main() {
    Animal* lista[] = {
        new Perro(), new Gato()
    };
    for (auto a : lista) hacerSonar(a); // Guau! Miau!
}

// Clase abstracta — define el contrato
class Forma {
public:
    virtual double area() const = 0;  // virtual puro
    virtual ~Forma() {}
};

// Forma NO se puede instanciar:
// Forma f; ← error de compilación

class Circulo : public Forma {
    double radio;
public:
    Circulo(double r) : radio(r) {}
    double area() const override {
        return 3.14159 * radio * radio;
    }
};