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
*
*/

#include <iostream.h>

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
};
Y su implementacion 
/**
* Habitante.cpp
* Programa que implementa la clase habitante
*
* Pello Xabier Altadill Izura
* Compilacion: g++ -c Habitante.cpp
*
*/

#include "Habitante.hpp"

        // Construido
        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 La clase Humano, que hereda de Habitante 
/**
* 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
};
Y su implementacion 

        // Construido
        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 La clase Animal, que hereda de Habitante 
/**
* 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
};
Y su implementacion 
/**
* Animal.cpp
* Programa que implementa la clase Animal
*
* Pello Xabier Altadill Izura
* Compilacion: g++ -c Animal.cpp
*
*/

#include "Animal.hpp"

        // Construido
        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;}
};
Y su implementacion 
/**
* 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;
}
NECESITA DEPURARSE