CP1300 C++ Inheritance and Overloading

Inheritance

• Introduction
  • 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

• A simple example
  • The base class example
    • cstring.h - defines the C string array type
    • Person.h - defines the Person class
    • Person.cpp - implements the Person class
    • Modular.cpp - main program
  • The derived class example
    • AgedPerson.h - defines the AgedPerson class
    • AgedPerson.cpp - implements the AgedPerson class
    • AgedModular.cpp - main program
  • Inheritance
    • All the public: parts of the base class are accessible in the derived class.
    • The private: parts of the base class are not accessible in the derived class.
    • The protected: parts of the base class are accessible in the derived class.
    • The access specifier public means accessible members of the base class are public members of the derived class.
      • An access specifier private means accessible members of the base class are private members of the derived class.
  • New
    • Data member
    • Constructors - note how they use the base constructors
    • Methods

• 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
  • countqueueclass.h
    • The redeclared function Enqueue will be used in preference to the inherited one.
  • countqueueclass.cpp
    • The Enqueue function calls the base class Enqueue function with queue::Enqueue(Item)
  • A pointer to a queue can also point to a countqueue
    • Invoking Enqueue via such a pointer requires late binding so the correct Enqueue is run.
    • Declare the Enqueue function as virtual in the base class.
    • queueclass.h
  • UserCountQueue.cpp

• Example: A Stack with Smack
  • Adds a funky new Smack operation to a stack, which removes the bottom element if it exists
  • smackstackclass.h
  • smackstackclass.cpp
  • UseSmackstack.cpp
  • Placing the stack_data TheItems; in a protected: part would allow direct access to the array and a more efficient implementation. But that breaks encapsulation.

Overloading

• This enables several functions of the same name to be defined, provided they have different parameters.
• This is called function overloading.
• When an overloaded function is called, the compiler works out which version to use from the parameters.

• Example: Functions to calculate the square of a value, either float or int.

  #include <iostream.h>
  
  int Square(int Value);
  float Square(float Value);
  //-----------------------------------------------------------------------
  int main(void) {
  
  int IntInput,IntSquare;
  float FloatInput,FloatSquare;
  
  cout << "Enter and integer and a float : ";
  cin >> IntInput >> FloatInput;
  
  IntSquare = Square(IntInput);
  FloatSquare = Square(FloatInput);
  
  cout << IntInput << " squared is " << IntSquare << endl;
  cout << FloatInput << " squared is " << FloatSquare << endl;
  
  return(0);
  }
  //-----------------------------------------------------------------------
  int Square(int Value) {
  
  return(Value * Value);
  }
  //-----------------------------------------------------------------------
  float Square(float Value) {
  
  return(Value * Value);
  }
  //-----------------------------------------------------------------------
       

• A class may have overloaded member functions
  • This example overloads member functions in a derived class.
  • smackNstackclass.h
  • smackNstackclass.cpp
  • UseSmackNstack.cpp

• Inheritance
• Overloading

Tutorial Questions

• Very smart integer arrays
• Adding in Many Ways

Exam style questions

1. In a derived class:
   • How do you specify that the public members of the base class are to be public members of the derived class?
   • Which parts of the base class are accessible in the derived class?
   • How can you invoke member functions of the base class, when there is a function of the same name in the derived class?
2. Given the following base class header file, write the header file for a derived class that adds an integer data member, and provides a function that increments that integer.

   //------------------------------------------------------
   #ifndef BASICCLASS_H
   //------------------------------------------------------
   class basic {
   
   public:
   
   basic(void);
   
   int PlayBasicStuff(int Something);
   
   private:
   
   char BasicData;
   
   };
   //------------------------------------------------------
   #define BASICCLASS_H
   #endif
   //------------------------------------------------------
   

3. Write the implementation file for the derived class defined in the last question.
4. What is meant by overloading?
5. How does a C++ compiler differentiate between overloaded functions.
6. Write the header for a class that uses overloading (use your imagination for what the class does).