多重继承

Question

I've read multiple inheritance from a book known as "C++ Primer" but I've only received a header file for the example written in the book which makes it little difficult for me to understand without source.cpp. So, my question is, what is an Endangered class and how do i define the member functions highlight , cuddle , onExhibit etc?

This header file can also be downloaded from here .

// Multiple Inheritance.h

#include <string>
#include <iostream>

class Endangered {
public:
    virtual ~Endangered();
    virtual std::ostream& print(std::ostream&) const;
    virtual void highlight() const;
    // ...
};

class ZooAnimal;
extern std::ostream&
operator<<(std::ostream&, const ZooAnimal&);

class ZooAnimal {
public:
    ZooAnimal();
    ZooAnimal(std::string animal, bool exhibit,
              std::string family): nm(animal), 
                                   exhibit_stat(exhibit), 
                                   fam_name(family) { } 
    virtual ~ZooAnimal();

    virtual std::ostream& print(std::ostream&) const;
    virtual int population() const;

    // accessors
    std::string name() const { return nm; }
    std::string family_name() const { return fam_name; }
    bool onExhibit() const { return exhibit_stat; }
    // ...
protected:
    std::string nm;
    bool        exhibit_stat;
    std::string fam_name;
    // ...
private:
};

class Bear : public ZooAnimal {
enum DanceType { two_left_feet, macarena, fandango, waltz };
public:
    Bear();
    Bear(std::string name, bool onExhibit=true, 
         std::string family = "Bear"):
                         ZooAnimal(name, onExhibit, family),
                         ival(0), dancetype(two_left_feet) { }

    virtual std::ostream &print(std::ostream&) const;
    virtual int toes() const;
    int mumble(int);
    void dance(DanceType) const;

    virtual ~Bear();
private:
    int         ival;
    DanceType   dancetype;
};

class Panda : public Bear, public Endangered {
public:
    Panda();
    Panda(std::string name, bool onExhibit=true);
    virtual ~Panda();
    virtual std::ostream& print(std::ostream&) const;
    void highlight();
    virtual int toes();
    virtual void cuddle();
// ...
};

Panda::Panda(std::string name, bool onExhibit)
      : Bear(name, onExhibit, "Panda") { }

inline
std::ostream& Panda::print(std::ostream &os) const
{
    Bear::print(os);          // print the Bear part
    Endangered::print(os);    // print the Endangered part
    return os;
}

class PolarBear : public Bear { /* . . . */ };

Answer 1

Just have functions with the same name, return type, argument number, const-ness, and argument types (known collectively as the function signature ) in your class that you're deriving.

For instance,

// Me.h

class Me : public Endangered, public ZooAnimal {
    // notice that these don't have virtual before them
    std::ostream& print(std::ostream&) const;
    void highlight() const;
    std::ostream& print(std::ostream&) const;
    int population() const;

    /* etc */
};

// Me.cpp

std::ostream& Me::print(std::ostream& stream) const { /* stuff */; return stream; }

void Me::highlight() const { /* stuff */ }

/* etc */

Note that the destructors for those classes must be defined for each class, not for derived classes. So you'd need

ZooAnimal::~ZooAnimal() {
    /* stuff */
}

not Me::~Me (although you'd need that too if Me had one).

somewhere.