1. C++ Inheritance and a
QuickTime™
decompressor
are needed to see this picture.
Gordon College
CPS212
2. Basics
OO-programming can be defined as a
combination of Abstract Data Types (ADTs)
with Inheritance and Dynamic Binding.
Encapsulation, inheritance and polymorphism
Each practice handles a different aspect of
system composition:
Encapsulation can be seen as a 2D component - public and
private interface
Inheritance adds an additional dimension - the ADT picks up
the characteristics of another component.
Polymorphism adds to inheritance - postponing
implementation decisions until later (perhaps even run-time).
4. Basics
Recall that inheritance is a means of
specifying hierarchical relationships between
types
C++ classes can inherit both data and
function members from other (parent) classes
Terminology: "the child (derived or subclass)
type inherits (or is derived from) the parent
(base or superclass) type."
5. The derived type is just the base type
plus:
Added specializations
Change implementation
without changing the
base class interface
Added Generalizations
/Extensions
new operations and/or
data
6. What a derived class inherits
Every data member defined in the parent
class (although such members may not
always be accessible in the derived class!)
Every ordinary member function of the parent
class (although such members may not
always be accessible in the derived class!)
7. What a derived class doesn't inherit
The base class's constructors and
destructor
The base class's assignment operator
The base class's friends
8. What a derived class can add
New data members
New member functions (also overwrite existing
ones)
New constructors and destructor
New friends
9. When a derived-class object is created & destroyed
Space is allocated (on the stack or the heap) for the full object
(that is, enough space to store the data members inherited from
the base class plus the data members defined in the derived
class itself)
The base class's constructor is called to initialize the data
members inherited from the base class
The derived class's constructor is then called to initialize the
data members added in the derived class
The derived-class object is then usable
When the object is destroyed (goes out of scope or is deleted)
the derived class's destructor is called on the object first
Then the base class's destructor is called on the object
Finally the allocated space for the full object is reclaimed
10. Inheritance in C++
The class header is modified to allow a
derivation list consisting of base classes
(C++ allows multiple inheritance)
class Foo { };
class Bar : public Foo { };
class More : public Foo, public Bar { };
11. Key Properties of C++ Inheritance
The “is-a” relationship is maintained
A pointer to the base type may point to a derived
type object
The above relationship combined with
dynamic binding - promotes a type-secure,
polymorphic style of programming
The programmer need not know the actual type of
an object at compile-time (dynamic-binding)
13. Derived from Window (Menu
class)
Inheritance Hierarchy
Multiple Levels of Derivation
A pointer to a derived class can
be assigned to a pointer of any of
its public base classes without
requiring an explicit cast: Menu m;
Window &w = m;
Screen *ps1 = &w;
Screen *ps2 = &m;
14. Public vs private inheritance
The public keyword in the inheritance syntax
means that publicly accessible members
inherited from the base class stay publicly
accessible in the derived class
But sometimes its preferable to inherit the
public members of a parent in such a way
that they become private in the child
15. Private inheritance
Public members of base class become
private members of derived class
Public and protected members are only
available to derived-class member
functions - not to a derived object.
16. Protected inheritance
private members of the base class are not
accessible in the derived class (to preserve
encapsulation)
Protected qualification allows encapsulated
data members which are not publicly
accessible to be accessible by derived
classes
("Protected" members are not accessible
from outside the class, except in derived
classes)
17. Initializer lists
Derived class constructor automatically
calls the "no argument" base class
constructor(s)
But what if a base class has a non-void
constructor which needs to be called?
specify which base-class constructor gets
called, as part of the definition of the
derived-class constructor
18. Initializer lists
class Coefficient
{ class StatusCoefficient : public Coefficient
public: {
Coefficient(void) public:
StatusCoefficient(void)
{ myValue = 0; myAccesses = 0; } { myStatus = OverStatus; }
Coefficient(double initval) StatusCoefficient(double initval,
{ myValue = initval; myAccesses = 0; Status initStatus)
} : Coefficient(initval)
{ myStatus = initStatus; }
// ETC. // ETC.
}; };
19. Using Initializer lists to initialize
values
Initializer lists can also be used to initialize
class members with specific value (instead of
assigning to them in the body of the constructor)
class First
{
public:
First() : _foo( "initialize foo first" ), _bar( "then bar" ) { }
private:
string _foo;
string _bar;
};
20. Polymorphism
Meaning: some code or operations or objects
behave differently in different contexts
Example: the + operation behaves differently depending on the
operands (overloading)
member function with the same name can me
implemented in different classes
Use :: to refer to a function in the base class with the same
name - baseCL::function()
appropriate version of function is determined
at runtime – dynamically
virtual member functions used to implement
polymorphism
21. Polymorphism
Dynamic binding:
At runtime the C++ program selects which
member function to execute - if the function
is virtual and exists at the different levels
within a inheritance hierarchy
Contrasts with Static Binding
emp.displayEmployeeInfo();
22. Resources
Data Structures with C++, William Ford and William
Topp
Single and Multiple Inheritance in C++, Douglas
Schmidt
Editor's Notes
See example - inheritance project
See example - inheritance project “inheritance2”
See example - inheritance project “inheritance2”
See example - inheritance3 project
What base class constructor gets called - when a derived class object is created?
See page 735 - (see example at bottom of page) derivedCL::derivedCL (bArg1,…bArgm, dArg1…dArgn): baseCL(bArg1,…bArgm), dData1(dArg1),…dDatan(dArgn) { };