CPP Inheritance

Unveiling the Essence of Inheritance In C++ Programming Language

When embarking on the creation of a new class, rather than laboriously crafting fresh data members and member functions, the programmer can simply dictate that the new class inherits the traits of an existing class. The originating class is christened the base class, while the newly born class inherits the title of the derived class.

Inheritance embodies the notion of an “is a” relationship. To elucidate, consider the hierarchy of a mammal being an animal, a dog being a mammal, thereby concluding that a dog is inherently an animal.

The Dynamics of Base and Derived Classes

A class can derive from multiple base classes, effortlessly inheriting both data and functions from various sources. To establish a derived class, a class derivation list is employed, stipulating the base class(es) in a distinct format. The structure of this declaration follows the pattern:

class derived-class: access-specifier base-class

The access-specifier assumes one of three roles: public, protected, or private, while base-class references an existing class. If no access-specifier is specified, private is assumed.

An illustration can be found in the foundation class Shape and its inheritor, the class Rectangle:

#include <iostream>

using namespace std;

// Base class
class Shape {
   public:
      void setWidth(int w) {
         width = w;
      }
      void setHeight(int h) {
         height = h;
      }

   protected:
      int width;
      int height;
};

// Derived class
class Rectangle: public Shape {
   public:
      int getArea() { 
         return (width * height); 
      }
};

int main(void) {
   Rectangle Rect;

   Rect.setWidth(5);
   Rect.setHeight(7);

   // Printing the area of the object.
   cout << "Total area: " << Rect.getArea() << endl;

   return 0;
}

This example magnificently showcases the implementation of inheritance with the Rectangle class building upon the foundation laid by the Shape class.

Access Control in Inheritance

A derived class enjoys access to all non-private constituents of its base class. Consequently, base-class members intended to remain hidden from derived-class member functions should be designated as private within the base class.

Summarizing the accessibility across various contexts:

Types of Inheritance

Inheritance can be implemented through public, protected, or private inheritance. The access-specifier determines the type:

1. Public Inheritance: Public members of the base class become public members of the derived class, while protected members are retained as protected. Private members remain inaccessible directly, but can be accessed through public and protected functions of the base class.
2. Protected Inheritance: Public and protected base-class members turn into protected derived-class members.
3. Private Inheritance: Both public and protected base-class members are transformed into private derived-class members.

The Realm of Multiple Inheritance

C++ emboldens the concept of multiple inheritance, wherein a class can inherit from more than one class simultaneously. The syntax for this advanced form follows:

class derived-class: access baseA, access baseB...

Where access is public, protected, or private, and multiple base classes are specified separated by commas.

For instance:

// Base class Shape
class Shape {
   public:
      void setWidth(int w) {
         width = w;
      }
      void setHeight(int h) {
         height = h;
      }

   protected:
      int width;
      int height;
};

// Base class PaintCost
class PaintCost {
   public:
      int getCost(int area) {
         return area * 70;
      }
};

// Derived class Rectangle
class Rectangle: public Shape, public PaintCost {
   public:
      int getArea() {
         return (width * height); 
      }
};

In this exemplary scenario, Rectangle joyfully inherits from both Shape and PaintCost.

Inheritance remains a cornerstone of object-oriented programming, transforming classes into hierarchies and encapsulating the essence of relationships. The techniques and strategies disclosed here pave the way to efficient, robust, and highly organized code._