C++ Primer Plus

This method of having the derived method call the base method works well enough for single inheritance. For example, suppose that the HeadWaiter class derives from the Waiter class. You could use a sequence of definitions like this, with each derived class adding to the information displayed by its base class:

void Worker::Show() const

{

    cout << "Name: " << fullname << "\n";

    cout << "Employee ID: " << id << "\n";

}

void Waiter::Show() const

{

    Worker::Show();

    cout << "Panache rating: " << panache << "\n";

}

void HeadWaiter::Show() const

{

    Waiter::Show();

    cout << "Presence rating: " << presence << "\n";

}

This incremental approach fails for the SingingWaiter case, however. The following method fails because it ignores the Waiter component:

void SingingWaiter::Show()

{

    Singer::Show();

}

You can remedy that by calling the Waiter version also:

void SingingWaiter::Show()

{

      Singer::Show();

      Waiter::Show();

}

However, this displays a person’s name and ID twice because Singer::Show() and with Waiter::Show() both call Worker::Show().

How can you fix this? One way is to use a modular approach instead of an incremental approach. That is, you can provide a method that displays only Worker components, another method that displays only Waiter components (instead of Waiter plus Worker components), and another that displays only Singer components. Then the SingingWaiter::Show() method can put those components together. For example, you could use this:

void Worker::Data() const

{

    cout << "Name: " << fullname << "\n";

    cout << "Employee ID: " << id << "\n";

}

void Waiter::Data() const

{

    cout << "Panache rating: " << panache << "\n";

}

void Singer::Data() const

{

    cout << "Vocal range: " << pv[voice] << "\n";

}

void SingingWaiter::Data() const

{

    Singer::Data();

    Waiter::Data();

}

void SingingWaiter::Show() const

{

    cout << "Category: singing waiter\n";

    Worker::Data();

    Data();

}

Similarly, the other Show() methods would be built from the appropriate Data() components.

With this approach, objects would still use the Show() method publicly. The Data() methods, on the other hand, should be internal to the classes; they should be helper methods used to facilitate the public interface. However, making the Data() methods private would prevent, say, Waiter code from using Worker::Data(). Here is just the kind of situation for which the protected access class is useful. If the Data() methods are protected, they can by used internally by all the classes in the hierarchy while being kept hidden from the outside world.

Another approach would be to make all the data components protected instead of private, but using protected methods instead of protected data puts tighter control on the allowable access to the data.

The Set() methods, which solicit data for setting object values, present a similar problem. For example, SingingWaiter::Set()should ask for Worker information once, not twice. The same solution used for Show() works. You can provide protected Get() methods that solicit information for just a single class, and then you can put together Set() methods that use the Get() methods as building blocks.

In short, introducing MI with a shared ancestor requires introducing virtual base classes, altering the rules for constructor initialization lists, and possibly recoding the classes if they were written with MI in mind. Listing 14.10 shows the modified class declarations with these changes institutes, and Listing 14.11 shows the implementation.

Listing 14.10. workermi.h

// workermi.h  -- working classes with MI

#ifndef WORKERMI_H_

#define WORKERMI_H_

#include

class Worker   // an abstract base class

{

private:

    std::string fullname;

    long id;

protected:

    virtual void Data() const;

    virtual void Get();

public:

    Worker() : fullname("no one"), id(0L) {}

    Worker(const std::string & s, long n)

            : fullname(s), id(n) {}

    virtual ~Worker() = 0; // pure virtual function

    virtual void Set() = 0;

    virtual void Show() const = 0;

};

class Waiter : virtual public Worker

{

private:

    int panache;

protected:

    void Data() const;

    void Get();

public:

    Waiter() : Worker(), panache(0) {}

    Waiter(const std::string & s, long n, int p = 0)

            : Worker(s, n), panache(p) {}

    Waiter(const Worker & wk, int p = 0)

            : Worker(wk), panache(p) {}

    void Set();

    void Show() const;

};

class Singer : virtual public Worker

{

protected:

enum {other, alto, contralto, soprano,

                    bass, baritone, tenor};

    enum {Vtypes = 7};

    void Data() const;

    void Get();

private:

    static char *pv[Vtypes];    // string equivs of voice types

    int voice;

public:

    Singer() : Worker(), voice(other) {}

    Singer(const std::string & s, long n, int v = other)

            : Worker(s, n), voice(v) {}

    Singer(const Worker & wk, int v = other)

            : Worker(wk), voice(v) {}

    void Set();

    void Show() const;

};

// multiple inheritance

class SingingWaiter : public Singer, public Waiter

{

protected:

    void Data() const;

    void Get();

public:

    SingingWaiter()  {}

    SingingWaiter(const std::string & s, long n, int p = 0,

                            int v = other)

            : Worker(s,n), Waiter(s, n, p), Singer(s, n, v) {}

    SingingWaiter(const Worker & wk, int p = 0, int v = other)