C++: Inheritance

It is possible define a new class that inherits the structure of an existing class.
This avoids repeating parts that are the same.
The derived class inherits from the base class
Example: A queue with a counter of how many items have ever been enqueued
- Differences from the normal queue class in queueclass.h and queueclass.cpp
  - A new private data member to count the number of enqueues
  - The Enqueue function needs to be replaced by one that increments the counter
  - A new function is needed to return the number of enqueues
- Declaring an inherited class (p.322)
  - countqueueclass.h
  - The access specifier public means public members of the base class queue are also public members of the derived class.
    - An access specifier private means public members of the base class are private members of the derived class.
  - All the public: parts of the base class queue are accessible in the derived class.
  - The private: parts of the base class queue are not accessible in the derived class.
  - The redeclared function Enqueue will be used in preference to the inherited one. It could be declared as virtual in the base class so that the compiler will always know whether to use the base class version or the derived class version (see below).
  - New data member
- Implementing an inherited class (p.323)
  - countqueueclass.cpp
  - The default constructor uses : queue() to initialise the base class data before initialising the counter.
  - The Enqueue function calls the base class Enqueue function with queue::Enqueue(Item)
  - New function implemented simply
- Example use of countqueue
  - UserCountQueue.cpp
Accessing base class private: parts
- The member functions of a derived class cannot access the private: parts of the base class.
- The member functions of a derived class can access the protected: parts of the base class.
- Example
  - threepartclass.h - Base class header with data of all types
  - threepartclass.cpp - Base class implementation
  - fourpartclass.h - Derived class header with data of two types
  - fourpartclass.cpp - Derived class implementation
  - UseParts.cpp - Main program using the base and derived classes
Virtual functions
- A pointer to a derived class object is implicitly converted to a pointer to its base class.
  - If the derived class redefines anything, the base class version is still used, which is not the intent.
  - Example
```
fourpart FourPartObject;
fourpart *FourPartPointer;
threepart *ThreePartPointer;

ThreePartPointer = FourPartPointer = &FourPartObject;
ThreePartPointer->ReportTheValues();  //----Calls the threepart version
FourPartPointer->ReportTheValues();  //----Calls the fourpart version
```
- If the base class version is declared as virtual then the version associated with the object is called, e.g., if ReportTheValues is declared as virtual in threepartclass.h, then the above confusion does not arise.
- Functions are made virtual by putting virtual before the return type in their declaration, e.g.,
  virtual void ReportTheValues(void);
- If a function is to be redfined in a derived class, it's a good idea to declare it as virtual in the base class.
- Pure virtual functions are declared in the base class but implemented only in derived classes.
  - Functions are made pure virtual by putting = 0 after the parameter list in their declaration, e.g.,
    virtual OnlyInBaseClass(void) = 0;
  - Classes that include any pure virtual functions are called abstract classes.
  - It is not possible to create instances of an abstract class; it's possible only to create instances of derived classes.
  - It's possible to declare pointers to abstract classes.