COP 3330 Object-oriented Programming in C++ Inheritance Spring 2019

Hierarchical Relationships of Classes Many types of classes share similarities in information and behavior Similar private member data Similar member functions Inheritance Factoring out common features into a single base class Build derived classes that will share or inherit all of the data and functionality of the base class Except constructors, destructors, and assignment operators

Examples Base Class Derived Classes Geometric Objects Circles, Squares, Diamonds, …… Sports Football, Baseball, Basketball, …… Bank Accounts Checking, Savings, Mortgage, …… Vehicles Cars, Trains, Buses, …… Cars Sedan, Coupe, SUV, ……

Inheritance vs. Composition Inheritance: The base class/derived class relationship is an “is-a” relationship Derived object is an instance of the base object Usually a subcategory Composition: “has-a” relationship An object of one class is a component of another class (i.e., is embedded in another object)

Declaring Derived Classes Format class derivedClassName : public baseClassName The base class must be declared somewhere in that file or another, included file public in the derivation syntax: The derived class is publicly derived from the base class The protection levels in the derived class are the same as in the base class It is also possible to derive using other protection levels

Examples class Sport {…}; class Football : public Sport {…}; class Baseball : public Sport {…}; class BankAccount {…}; class Checking : public BankAccount {…}; class Vehicle {…}; class Car : public Vehicle {…}; class SUV : public Car {…}; Car inherits everything in the Vehicle class SUV inherits everything in the Car class Thus, SUV inherits everything from the Vehicle class

Revisit: Protection Levels in Classes Public (member data and functions) Can be accessed by name from anywhere Private Can be accessed directly only by the class in which it is declared We would like derived classes to have access to the members inherited from the base class, but we still want protection from outside access Solution: Protected Can be accessed directly by the class in which it is declared and by ANY classes derived from that class – but not from anywhere else

Types of Inheritance When deriving a class from a base class, the base class may be inherited through public, protected, or private inheritance Syntax: class derivedClassName : public baseClassName class derivedClassName : private baseClassName class derivedClassName : protected baseClassName We hardly use protected or private inheritance, but public inheritance is commonly used

Types of Inheritance Public inheritance - protection levels stay the same in derived class (besides private) public members of the base class become public members of the derived class protected members of the base class become protected members of the derived class. A base class's private members are NEVER accessible directly from a derived class, but can be accessed through calls to functions of the base class Protected inheritance  public and protected members of the base class become protected members of the derived class. Private inheritance  public and protected members of the base class become private members of the derived class

derivedFromProtectedDerived Types of Inheritance If we derive a class  derivedFromProtectedDerived from protectedDerived, x and y are also inherited to the derived class If we derive a class  derivedFromPrivateDerived  from privateDerived, x and y are NOT inherited because they are private variables of privateDerived

Constructors in Derived Classes We know that when an object is created, its constructor runs  However, what happens when a derived object is created? A derived object “is an” instance of the base class Thus, when a derived object is created, the constructors from BOTH the base and derived classes will run The base class will run first, then the derived

Example Vehicle obj1; Only the Vehicle() constructor runs Car obj2; //Car inherits from Vehicle Vehicle() constructor runs, followed by the Car() constructor SUV obj3; //SUV inherits from Car Vehicle() Car() SUV()

Destructors Destructors will be invoked in the reverse order, first the children, then the base classes Example: SUV obj3; //SUV inherits from Car //Car inherits from Vehicle Order of destructors: ~SUV() ~Car() ~Vehicle()

Constructors with Parameters Without parameters, the default constructors are called Example: with a derived class, we might want to declare SUV s(2, 3, 4, “green”, “Honda Pilot”); 2 and 3 might be for variables like vehicleCategory and idNumber in the Vehicle Class 4 and “green” might be for variables like numDoors and carColor in the Car Class “Honda Pilot” might be for a variable model in the SUV class

How to Distribute Paramters? Use an initialization list function prototype : initialization list { function body; } Use the initialization list to call the next higher constructor explicitly, in order to send the parameters to the parent constructor An initialization list is run before the function body actually runs

Example Vehicle::Vehicle(int c, int id) { vehicleCategory = c; idNumber = id; } Car::Car(int c, int id, int nd, char *cc) : Vehicle(c, id) numDoors = nd; strcpy(carColor, cc); SUV::SUV(int c, int id, int nd, char *cc, char *mod) : Car(c, id, nd, cc) strcpy(model, mod);

Function Overriding Suppose we have the following base class class Student { public: void gradeReport(); …… }; We also have the following derived classes, which inherit everything from Student class Grad : public Student class Undergrad : public Student Suppose gradeReport look different for undergrads and grads These classes need to have their own implementations But using the exact same prototype!

Function Overidding class Grad : public Student { public: void gradeReport(); … }; class Undergrad : public Student void Student::gradeReport() { // processing done by parent function } void Grade::gradeReport() { // explicit call to parent function Student::gradeReport(); // other processing specific to Grad’s version ……

Code Review Geometric-Object Class

Multiple Inheritance C++ supports multiple inheritance A class can inherit properties from more than one base class (a class can inherit from multiple parent classes) Not all object-oriented languages support multiple inheritance (e.g., Java) It is not a necessary feature of object-oriented programming Can introduce issues that make maintenance of programs hard

Constructors/Destructors for Multi-Inheritance The constructors of base classes are always called in the same order in which they are inherited B’s constructor is called before A’s constructor Destructors are called in reverse order: A’s destructor will be called before B’s destructor

Ambiguity in Multiple Inheritance While multiple inheritance seems like a simple extension of single inheritance, it can introduce issues and make maintenance hard Ambiguity Arises when multiple base classes contain a function with the same name Compiler does not know which version to call unless we explicitly specify it by using derivedObject.BaseClass::function() While this workaround is simple, things can get complex when your class inherits from many base classes, which inherit from other classes themselves

The Diamond Problem Occurs when a class inherits from two classes each of which inherits from a single base class. This leads to a diamond shaped inheritance pattern

The Diamond Problem There are many issues that arise in this context Whether Copier should have one or two copies of PoweredDevice? How to resolve certain types of ambiguous references? While most of these issues can be addressed through explicit scoping, the maintenance overhead added to your classes in order to deal with the added complexity can cause development time to skyrocket!

The Diamond Problem C++ by default follows each inheritance path separately, so a Copier object would actually contain two sub-objects (two copies) of PoweredDevice’s member variables and functions: one from Scanner one from Printer Uses of PoweredDevice's members would have to be properly qualified and references specified

The Diamond Problem To disambiguate: Copier b; PoweredDevice &a = b; /* error: which PoweredDevice subobject should a Copier be cast to? a Scanner::PoweredDevice or a Printer::PoweredDevice? */ To disambiguate: PoweredDevice &scanner = static_cast<Scanner&> (b); PoweredDevice &printer = static_cast<Printer&> (b);

The Diamond Problem If PoweredDevice would have a function void do() and a member data int var To disambiguate: The same disambiguation, or explicit qualification is needed:  Copier c; c.Scanner::do(); c.Printer::do(); c.Scanner::var = 0; c.Printer::var = 0;

Virtual Inheritance Virtual inheritance is a C++ technique that ensures only one copy of a base class's member variables are inherited by grandchild derived classes class B: virtual public A class PoweredDevice {}; class Scanner: virtual public PoweredDevice{}; class Printer: virtual public PoweredDevice{}; class Copier: public Scanner, public Printer;

Is multiple inheritance more trouble than it’s worth? Most of the problems that can be solved by multiple inheritance can be solved by single inheritance as well Many object-oriented languages do not even support multiple inheritance Many experienced programmers believe multiple inheritance in C++ should be avoided at all costs due to the many potential problems it brings  If there are times and situations when multiple inheritance is the best way to proceed, use it extremely cautiously

Questions