Class Inheritance Basics

Class Inheritance is a way to extend a class. The new class (child class) builds or overwrites logic from the parent class (super class).

The syntax for class extension is:

class ChildClass : public ParentClass { // code }

Overwriting methods:

Overwritten method is a method that has been inherited from the parent but it's logic is changed in the child.

Syntax for overwriting function:

class ParentClass { public: funcType funcName(args) { // code } }; class ChildClass : public ParentClass { public: funcType funcName(args) { // overwriting } };

Let's have a base class Vehicle and child classes - Car, Scooter, Bicycle. We'll set a simplified formula for the insurance cost.

#include <iostream> using namespace std; class Vehicle { public: double getInsuranceCost(int months) { return 0; } }; // Scooter inherits Vehicle. class Scooter : public Vehicle { public: // overwriting method double getInsuranceCost(int months) { return months * 15; } }; // Car inherits Vehicle. class Car : public Vehicle { public: // overwriting method double getInsuranceCost(int months) { return months * 25; } }; // Bicycle inherits Vehicle. class Bicycle : public Vehicle { // the class uses getInsuranceCost() // inherited from Vehicle. }; void main() { Scooter scooter; cout << "Scooter Year Insurance: " << scooter.getInsuranceCost(12) << " $\n"; Car car; cout << "Car Year Insurance: " << car.getInsuranceCost(12) << " $\n"; Bicycle bike; cout << "Bicycle Year Insurance: " << bike.getInsuranceCost(12) << " $"; }

Output:

Scooter Year Insurance: 180 $ Car Year Insurance: 300 $ Bicycle Year Insurance: 0 $

Explanation:

• At line 15 the class Scooter inherits the Vehicle class. And at lines 19 to 22 the function getInsuranceCost is overwritten.
• At line 26 the class Car extends the Vehicle class. The Car class overwrites getInsuranceCost function at lines 30 - 33.
• At line 37 the Bicycle class extends Vehicle. It doesn't overwrite the getInsuranceCost method. When called (line 55) the code from the base class is executed.

Extending functions and constructors:

Let's have a base class Vehicle and child class Car. The child class will add one more member and also extend a constructor and a function called representation.

#include <string> #include <iostream> using namespace std; class Vehicle { protected: string brand; string model; public: Vehicle(string brandValue, string modelValue) { brand = brandValue; model = modelValue; cout << "Vehicle constructor" << endl; } void representation() { cout << "Brand: " << brand << endl; } }; class Car : public Vehicle { private: int horsePowers; public: Car(string brandValue, string modelValue, int horsePowersValue) : Vehicle(brandValue, modelValue) { cout << "Car constructor" << endl; horsePowers = horsePowersValue; } void representation() { Vehicle::representation(); cout << "Model: " << model << endl; cout << "Horse Powers: " << horsePowers << endl; } }; void main() { Vehicle sampleBicycle("Merida ", "ONE-FORTY 800"); sampleBicycle.representation(); cout << "--------------------" << endl; Car fordCar("Ford", "Fiesta", 80); fordCar.representation(); cout << "--------------------" << endl; Car toyotaCar("Toyota", "Corolla", 100); toyotaCar.representation(); }

Output:

Vehicle constructor Brand: Merida -------------------- Vehicle constructor Car constructor Brand: Ford Model: Fiesta Horse Powers: 80 -------------------- Vehicle constructor Car constructor Brand: Toyota Model: Corolla Horse Powers: 100

Explanation:

• At line 29 instead of private the members are defined as protected. That's because we want to extend the class and inherit it's members. More details about it later in the lesson.
• At line 34 the class Car inherits Vehicle.
• The Car class has 3 members - horsePowers defined at line 30 and also brand and model (lines 9 and 10) due to the class extension.
• The Car class constructor inherits the vehicle constructor at line 32. When car object is created (lines 56 and 60) the code from the parent's class constructor (lines 15 - 18) executes first and afterwards the code from child's constructor (lines 36 - 38).
• At line 43 the representation function of the parent class is called. When representation function is called for a Vehicle object at line 53, only the brand is printed.
• When representation function is called for a Car object, all 3 members (make, model, horsePowers) are printed.

Private vs protected members

Both private and protected members can be accessed or modified only in a class body.

Private Members can be accessed or modified only in one class - the one they are defined in.

Protected members can be accessed or modified in the class they are defined in and the classes that extend it.

Let's look at the example:

#include <string> #include <iostream> using namespace std; class Vehicle { protected: string brand; string model; }; class Car : public Vehicle { private: int horsePowers; public: Car(string brandValue, string modelValue, int horsePowersValue) { brand = brandValue; model = modelValue; horsePowers = horsePowersValue; } }; void main() { Car mercedesCar("Volkswagen", "Polo", 90); }

• Due to the extension class Car has 3 members - brand, model and horsePowers.
• If at line 8 we replace protected with private, the class Car will have only one member - horsePowers and the code won't compile due to lines 21 and 22.