Herencia multiple
La herencia multiple Una de las oportunidades que nos ofrece el lenguaje c++ es la posibilidad de que un objeto tenga la herencia de mas de una clase; esta ventaja fue considerada por los desarrolladores de Java como una pega y la quitaron, e incluso hay desarrolladores de c++ que prefieren evitar este tipo de herencia ya que puede complicar mucho la depuracion de programas Para ilustrar un caso de herencia multiple hemos definido la superclase Habitante; de ella heredan dos clases distintas: Humano (que hablan) y Animal (que matan). Ahora queremos definir un ente que tiene propiedades de esas dos clases: Militar, ya que el militar habla y ademas mata. Como podemos definirlo? con una herencia multiple. Vamos la definicion de la superclase o clase padre Habitante Notas de la logia POO Conviene definir todos los metodos de un clase como const siempre que en el metodo no se modifiquen los atributos. Tu resistencia es inutil. unete a nosotros o muere. Definir metodos como const le facilitara el trabajo al compilador y al programador. Nota el codigo necesita revision y testeo
/**
* Habitante.hpp
* Clase que define el objeto habitante
*
* Pello Xabier Altadill Izura
*
*/
using namespace std;
#include <iostream>
class Habitante {
private:
char *nombre;
int edad;
public:
Habitante();
virtual ~Habitante();
Habitante(const Habitante &);
virtual void dormir();
// setter/getter o accessors
virtual char *getNombre() const { return this->nombre;}
// inline
virtual void setNombre(char *nombre) { this->nombre = nombre; } // inline
virtual int getEdad() const { return this->edad;} // inline
virtual void setEdad(int edad) { this->edad = edad; } // inline
}; |
/**
* Habitante.cpp
* Programa que implementa la clase habitante
*
* Pello Xabier Altadill Izura
* Compilacion: g++ -c Habitante.cpp
*
*/
#include "Habitante.hpp"
// Constructor
Habitante::Habitante() {
cout << "-clase habitante- Habitante construido."<< endl;
}
// Destructor
Habitante::~Habitante() {
cout << "-clase habitante- Habitante "<< this->getNombre() << " destruido."<< endl;
}
// constructor copia
Habitante::Habitante(const Habitante & original) {
nombre = new char;
original.getNombre();
}
// metodo dormir
void Habitante::dormir() {
cout << "-clase habitante- zzzzzZZZZzzzzz zzz" << endl;
}
|
/**
* Humano.hpp
* Clase que define el objeto humano
*
* Pello Xabier Altadill Izura
*
*/
#include "Habitante.hpp"
// hereda atributos y metodos de la superclase Habitante
class Humano : public Habitante {
private:
char *idioma;
public:
Humano();
virtual ~Humano();
Humano(const Humano &);
virtual void hablar(char *bla) const;
// setter/getter o accessors
virtual char *getIdioma() const { return this->idioma;} // inline
virtual void setIdioma(char *idioma) { this->idioma = idioma; } // inline
}; |
/**
* Humano.cpp
* Fichero que implementa el objeto humano
*
* Pello Xabier Altadill Izura
*
*/
#include "Habitante.hpp"
// Constructor
Humano::Humano() {
cout << "-clase Humano- Humano construido."<< endl;
}
// Destructor
Humano::~Humano() {
cout << "-clase Humano- Humano "<< this->getNombre() << " destruido."<< endl;
}
// constructor copia
Humano::Humano(const Humano & original) {
idioma = new char;
idioma = original.getIdioma();
}
// metodo hablar
void Humano::hablar(char *bla) const {
cout << "-clase Humano-" << this->getNombre() << " dice: " << bla << endl;
} |
/**
* Animal.hpp
* Clase que define el objeto Animal
*
* Pello Xabier Altadill Izura
*
*/
#include "Habitante.hpp"
// hereda atributos y metodos de la superclase Habitante
class Animal : public Habitante {
private:
int patas;
public:
Animal();
virtual ~Animal();
Animal(const Animal &);
virtual void matar() const;
// setter/getter o accessors
virtual int getPatas() const { return this->patas;} // inline
virtual void setPatas(int patas) { this->patas = patas; } // inline
}; |
/**
* Animal.cpp
* Programa que implementa la clase Animal
*
* Pello Xabier Altadill Izura
* Compilacion: g++ -c Animal.cpp
*
*/
#include "Animal.hpp"
// Constructor
Animal::Animal() {
cout << "-clase Animal- Animal construido."<< endl;
}
// Destructor
Animal::~Animal() {
cout << "-clase Animal- Animal "<< this->getNombre() << " destruido."<< endl;
}
// constructor copia
Animal::Animal(const Animal & original) {}
// metodo matar
void Animal::matar() const {
cout << "-clase Animal-" << this->getNombre() << " Matar! Matar! Matar! " << endl;
} |
La herencia multiple! Aqui esta la clase Militar, que hereda de Humano y Animal.
/**
* Militar.hpp
* Clase que define el objeto Militar
*
* Pello Xabier Altadill Izura
*
*/
// Herencia multiple de Humano y Animal
class Militar : public Animal { //, public Humano {
private:
char *rango;
public:
Militar();
~Militar();
Militar(const Militar &);
// sobrescribe metodos
void matar() const;
void hablar(char *bla) const;
// un metodo poco probable entre cualquier uniformado...
void razonar() const;
// setter/getter o accessors
char *getRango() const { return this->rango;}
void setRango(char *rango) { this->rango = rango;}
}; |
/**
* Militar.cpp
* Programa que implementa la clase Militar
*
* Pello Xabier Altadill Izura
* Compilacion: g++ -c Habitante.cpp
* g++ -c Humano.cpp
* g++ -c Animal.cpp
* g++ Militar.cpp Habitante.o Humano.o Animal.o -o Militar
*/
#include "Militar.hpp"
// Constructor
Militar::Militar() {
cout << "-clase Militar- Militar construido."<< endl;
}
// Destructor
Militar::~Militar() {
cout << "-clase Militar- Militar "<< this->getNombre() << " destruido."<< endl;
}
// constructor copia
Militar::Militar(const Militar & original) {
cout << "-clase Militar- Militar copia creada."<< endl;
}
// metodo razonar
void Militar::razonar() const {
cout << "-clase Militar-" << this->getNombre() << " Error: OVERFLOW " << endl;
}
// metodo hablar
void Militar::hablar(char *bla) const {
cout << "-clase Militar-" << this->getRango() << " " << this->getNombre() << " dice: ";
cout << bla << endl;
}
// metodo matar
void Militar::matar() const {
cout << "-clase Militar-" << this->getRango() << " Matar! " << endl;
cout << "-clase Militar- Somos... agresores por la paz " << endl;
}
// Aqui haremos multiples pruebas...
int main () {
return 0;
}
|