Introduction to C++: Part 3
Tutorial Outline: Part 3
Inheritance and overrides
Virtual functions and interfaces
The formal concepts in OOP
Polymorphism
Next up: Polymorphism
Encapsulation
OOP
Inheritance
Abstraction
Using subclasses
A function that takes a superclass
argument can also be called with void PrintArea(Rectangle &rT) {
a subclass as the argument. cout << rT.Area() << endl ;
}
The reverse is not true – a int main() {
function expecting a subclass Rectangle rT(1.0,2.0) ;
Square sQ(3.0) ;
argument cannot accept its
PrintArea(rT) ;
superclass. PrintArea(sQ) ;
}
Copy the code to the right and
add it to your main.cpp file. The PrintArea function
can accept the Square
object sQ because
Square is a subclass of
Rectangle.
Overriding Methods class Super {
public:
Sometimes a subclass needs to have the void PrintNum() {
same interface to a method as a cout << 1 << endl ;
superclass with different functionality. }
} ;
This is achieved by overriding a method. class Sub : public Super {
public:
// Override
Overriding a method is simple: just re- void PrintNum() {
cout << 2 << endl ;
implement the method with the same }
name and arguments in the subclass. } ;
Super sP ;
sP.PrintNum() ; // Prints 1
Sub sB ;
In C::B open project: sB.PrintNum() ; // Prints 2
CodeBlocks Projects Part 2 Virtual Method Calls
Overriding Methods
class Super {
public:
Seems simple, right? void PrintNum() {
cout << 1 << endl ;
}
} ;
class Sub : public Super {
public:
// Override
void PrintNum() {
cout << 2 << endl ;
}
} ;
Super sP ;
sP.PrintNum() ; // Prints 1
Sub sB ;
sB.PrintNum() ; // Prints 2
class Super {
How about in a function call… public:
void PrintNum() {
cout << 1 << endl ;
}
} ;
Using a single function to operate
on different types is class Sub : public Super {
public:
polymorphism. // Override
void PrintNum() {
cout << 2 << endl ;
}
Given the class definitions, what } ;
is happening in this function call? void FuncRef(Super &sP) {
sP.PrintNum() ;
}
Super sP ;
“C++ is an insult to the human brain” Func(sP) ; // Prints 1
– Niklaus Wirth (designer of Pascal) Sub sB ;
Func(sB) ; // Hey!! Prints 1!!
void FuncRef(Super &sP) {
sP.PrintNum() ;
Type casting }
The Func function passes the argument as a reference (Super &sP).
What’s happening here is dynamic type casting, the process of converting from
one type to another at runtime.
Same mechanism as the dynamic_cast<type>() function
The incoming object is treated as though it were a superclass object in
the function.
When methods are overridden and called there are two points where
the proper version of the method can be identified: either at compile
time or at runtime.
class SuperVirtual
{
public:
Virtual methods virtual void PrintNum()
{
When a method is labeled as virtual and cout << 1 << endl ;
}
overridden the compiler will generate } ;
code that will check the type of an object
class SubVirtual : public SuperVirtual
at runtime when the method is called. {
public:
// Override
The type check will then result in the virtual void PrintNum()
expected version of the method being {
cout << 2 << endl ;
called. }
} ;
When overriding a virtual method in a void Func(SuperVirtual &sP)
{
subclass, it’s a good idea to label the sP.PrintNum() ;
method as virtual in the subclass as well. }
…just in case this gets subclassed again! SuperVirtual sP ;
Func(sP) ; // Prints 1
SubVirtual sB ;
Func(sB) ; // Prints 2!!
Early (static) vs. Late (dynamic) binding
Leaving out the virtual keyword on a Making a method virtual adds code
method that is overridden results in the behind the scenes (that you, the
compiler deciding at compile time which programmer, never interact with directly)
version (subclass or superclass) of the Lookups in a hidden table, called the
method to call. vtable, are done to figure out what version
This is called early or static binding. of the virtual method should be run.
At compile time, a function that takes a
superclass argument will only call the This is called late or dynamic binding.
non-virtual superclass method under
early binding. There is a small performance penalty for
late binding due to the vtable lookup.
This only applies when an object is
referred to by a reference or pointer.
Behind the scenes – vptr and vtable
Func(SuperVirtual &sP)
C++ classes have a hidden pointer (vptr) sP is a reference to a…
generated that points to a table of virtual
methods associated with a class (vtable).
SuperVirtual SubVirtual
When a virtual class method (base class
or its subclasses) is called by reference ( SuperVirtual’s SubVirtual’s
vptr vptr
or pointer) when the program is running
the following happens:
The object’s class vptr is followed to its class
vtable
Vtable Vtable
The virtual method is looked up in the vtable
and is then called.
One vptr and one vtable per class so minimal & SuperVirtual::PrintNum() & SubVirtual::PrintNum()
memory overhead
If a method override is non-virtual it won’t be in
the vtable and it is selected at compile time.
Let’s run this through the debugger
Open the project: Parts 2- Make sure the “Watches”
3/Virtual Method Calls. debugging window is open.
Everything here is
implemented in one big
main.cpp
Place a breakpoint at the first
line in main() and in the two
implementations of Func()
When to make methods virtual
If a method will be (or might be) Constructors are never virtual in C++.
overridden in a subclass, make it virtual Destructors in a base class should
There is a minor performance penalty. always be virtual.
Will that even matter to you? Also – if any method in a class is virtual,
i.e. Have you profiled and tested your code to
show that virtual method calls are a performance
make the destructor virtual
issue? These are important when dealing with
When is this true? objects via reference and it avoids some
Almost always! Who knows how your code will subtleties when manually allocating
be used in the future? memory.
Why all this complexity?
void FuncEarly(SuperVirtual &sP) void FuncLate(SuperVirtual sP)
{ {
sP.PrintNum() ; sP.PrintNum() ;
} }
Called by reference – late binding Called by value – early binding to
to PrintNum() PrintNum even though it’s virtual!
Late binding allows for code libraries to be updated for new functionality. As methods are identified
at runtime the executable does not need to be updated.
This is done all the time! Your C++ code may be, for example, a plugin to an existing simulation
code.
Greater flexibility when dealing with multiple subclasses of a superclass.
Most of the time this is the behavior you are looking for when building class hierarchies.
Shape
virtual float Area() {}
Remember the Deadly Diamond of
Death? Let’s explain.
Look at the class hierarchy on the right.
Square and Circle inherit from Shape
Squircle inherits from both Square and Circle Square
Circle
Syntax:
virtual float
class Squircle : public Square, public Circle Area() {…} virtual float
Area() {…}
The Shape class implements an empty
Area() method. The Square and Circle
classes override it. Squircle does not.
Under late binding, which version of Area
is accessed from Squircle?
Square.Area() or Circle.Area()?
Squircle
Interfaces
Shape Log
Another pitfall of multiple inheritance: the
fragile base class problem.
If many classes inherit from a single base
(super) class then changes to methods in the
base class can have unexpected
consequences in the program. Square Circle
This can happen with single inheritance but it’s
much easier to run into with multiple
inheritance.
Interfaces are a way to have your Example: for debugging you’d like each class
classes share behavior without them to have a Log() method that would write some
sharing actual code. info to a file.
Implement with an interface.
Gives much of the benefit of multiple
inheritance without the complexity and
pitfalls
#ifndef SQUARE_H
Interfaces #define SQUARE_H
#include "rectangle.h"
An interface class in C++ is called a pure virtual class.
class Log {
It contains virtual methods only with a special syntax. virtual void LogInfo()=0 ;
Instead of {} the function is set to 0. };
Any subclass needs to implement the methods!
Modified square.h shown. class Square : public Rectangle, Log
{
What happens when this is compiled? public:
(…error…) Square(float length);
include/square.h:10:7: note: because the following virtual virtual ~Square();
functions are pure within 'Square': // virtual void LogInfo() {}
class Square : public Rectangle, Log
^ protected:
include/square.h:7:18: note: virtual void Log::LogInfo()
virtual void LogInfo()=0 ; private:
};
Once the LogInfo() is uncommented it will compile.
#endif // SQUARE_H
C++ offers another fix for the diamond problem, Virtual inheritance. See: https://en.wikipedia.org/wiki/Virtual_inheritance
Putting it all together
Shape
Now let’s revisit our Shapes
project. ???
In the directory of C::B Part 2-3
projects, open the “Shapes with Rectangle Circle
Circle” project.
This has a Shape base class with a
Rectangle and a Square
Add a Circle class to the class
Square
hierarchy in a sensible fashion.
Hint: Think first, code second.
New pure virtual Shape class
#ifndef SHAPE_H
Slight bit of trickery: #define SHAPE_H
An empty constructor is defined in shape.h
No need to have an extra shape.cpp file if these
functions do nothing! class Shape
{
public:
Q: How much code can be in the header file? Shape() {}
virtual ~Shape() {}
A: Most of it with some exceptions.
.h files are not compiled into .o files so a virtual float Area()=0 ;
header with a lot of code gets re-compiled protected:
every time it’s referenced in a source file.
private:
};
#endif // SHAPE_H
Give it a try
Add inheritance from Shape If you just want to see a
to the Rectangle class solution, open the project
Add a Circle class, inheriting “Shapes with Circle solved”
from wherever you like.
Implement Area() for the
Circle
A Potential Solution
Shape
A Circle has one dimension
(radius), like a Square.
Would only need to override the
Area() method Rectangle
But…
Would be storing the radius in the
members m_width and m_length.
This is not a very obvious to
someone else who reads your code.
Square
Maybe:
Change m_width and m_length
names to m_dim_1 and m_dim_2? Circle
Just makes everything more muddled!
A Better Solution
Shape
Inherit separately from the Shape
base class
Seems logical, to most people a
circle is not a specialized form of Rectangle Circle
rectangle…
Add a member m_radius to store
the radius.
Implement the Area() method
Square
Makes more sense!
Easy to extend to add an Oval
class, etc.
#ifndef CIRCLE_H
#define CIRCLE_H
New Circle class
#include "shape.h"
Also inherits from Shape class Circle : public Shape
Adds a constant value for p {
Constant values can be defined right in the public:
header file. Circle();
Circle(float radius) ;
If you accidentally try to change the value of PI
virtual ~Circle();
the compiler will throw an error.
virtual float Area() ;
const float PI = 3.14;
float m_radius ;
protected:
private:
};
#endif // CIRCLE_H
#include "circle.h"
Circle::Circle()
{
//ctor
}
circle.cpp
Circle::~Circle()
Questions? {
//dtor
}
// Use a member initialization list.
Circle::Circle(float radius) : m_radius{radius}
{}
float Circle::Area()
{
// Quiz: what happens if this line is
// uncommented and then compiled:
//PI=3.14159 ;
return m_radius * m_radius * PI ;
}
Quiz time!
void PrintArea(Shape &shape) {
cout << "Area: " << shape.Area() << endl ;
}
int main()
What happens behind {
the scenes when the Square sQ(4) ;
Circle circ(3.5) ;
function PrintArea is Rectangle rT(21,2) ;
called?
// Print everything
How about if PrintArea’s PrintArea(sQ) ;
argument was instead: PrintArea(rT) ;
PrintArea(circ) ;
return 0;
void PrintArea(Shape shape) }
Quick mention…
Aside from overriding functions it Syntax:
is also possible to override MyClass operator*(const MyClass& mC) {...}
operators in C++. Recommendation:
As seen in the C++ string. The +
Generally speaking, avoid this. This
operator concatenates strings:
is an easy way to generate very
string str = "ABC" ; confusing code.
str = str + "DEF" ;
// str is now "ABCDEF" A well-named function will almost
always be easier to understand than
It’s possible to override +,-,=,<,>, an operator.
brackets, parentheses, etc. An exceptions is the assignment
operator: operator=
Summary
C++ classes can be created in hierarchies via Subclasses can override a superclass
inheritance, a core concept in OOP. method for their own purposes and can still
Classes that inherit from others can make use explicitly call the superclass method.
of the superclass’ public and protected Abstraction means hiding details when they
members and methods don’t need to be accessed by external code.
You write less code! Reduces the chances for bugs.
Virtual methods should be used While there is a lot of complexity here – in
whenever methods will be overridden in terms of concepts, syntax, and application –
keep in mind that OOP is a highly successful
subclasses.
way of building programs!
Avoid multiple inheritance, use interfaces
instead.
