Demystified Object-Oriented Programming with C++ by Dorothy R. Kirk

Author:Dorothy R. Kirk
Language: eng
Format: mobi, epub, pdf
Publisher: PACKT Publishing Pvt. Ltd.
Published: 2021-03-24T16:00:00+00:00

Creating a diamond-shaped hierarchy

When using multiple inheritance, sometimes it is tempting to utilize sibling (or cousin) classes as base classes for a new derived class. When this happens, the hierarchy is no longer a tree in shape, but rather, a graph containing a diamond.

Whenever an object of the derived class type is instantiated in such a situation, two copies of the common base class will be present in the instance of the derived class. Duplication of this sort obviously wastes space. Additional time is also wasted by calling duplicate constructors and destructors for this repeated sub-object and by maintaining two parallel copies of a sub-object (most likely unnecessarily). Ambiguities also result when trying to access members from this common base class.

Let's see an example detailing this issue, starting with abbreviated class definitions of LifeForm, Horse, and Person. Though only portions of the full program example are shown, the program in its entirety can be found in our GitHub as follows:

https://github.com/PacktPublishing/Demystified-Object-Oriented-Programming-with-CPP/blob/master/Chapter09/Chp9-Ex2.cpp

class Lifeform

{ // abbreviated class definition

private:

int lifeExpectancy;

public:

LifeForm(int life) {lifeExpectancy = life; }

int GetLifeExpectancy() const { return lifeExpectancy; }

// additional constructors, destructor, etc …

virtual void Print() const = 0; // pure virtual functions

virtual const char *IsA() = 0;

virtual const char *Speak() = 0;

};

class Horse: public LifeForm

{ // abbreviated class definition

private:

char *name;

public:

Horse(): LifeForm(35) { name = 0; }

// additional constructors, destructor, etc …

virtual void Print() const override

{ cout << name << endl; }

virtual const char *IsA() override { return "Horse"; }

virtual const char *Speak() override { return "Neigh!"; }

};

class Person: public LifeForm

{ // abbreviated class definition

private:

char *firstName;

char *lastName;

// additional data members …

public:

Person(): LifeForm(80) { firstName = lastName = 0; }

// additional constructors, destructor, etc …

const char *GetFirstName() const { return firstName; }

virtual void Print() const override

{ cout << firstName << " " << lastName << endl; }

virtual const char *IsA() override { return "Person"; }

virtual const char *Speak() override { return "Hello!"; }

};

The previous fragment of code shows skeleton class definitions for LifeForm, Person, and Horse. Each class shows a default constructor, which merely serves as an example to show how lifeExpectancy is set for each class. In the default constructors for Person and Horse, the member initialization list is used to pass a value of 35 or 80 to the LifeForm constructor to set this value.

Though the previous class definitions are abbreviated (that is, purposely incomplete) to save space, let's assume that each class has appropriate additional constructors defined, an appropriate destructor, and other necessary member functions.

We notice that LifeForm is an abstract class, in that it offers pure virtual functions Print(), IsA(), and Speak(). Both Horse and Person are concrete classes and will be instantiable because they override these pure virtual functions with virtual functions. These virtual functions are shown inline, only to make the code compact for viewing.

Next, let's look at a new derived class that will introduce the graph, or diamond shape, in our hierarchy:

class

Download

Copyright Disclaimer:
This site does not store any files on its server. We only index and link to content provided by other sites. Please contact the content providers to delete copyright contents if any and email us, we'll remove relevant links or contents immediately.