C/C++ Programming Techniques

ET2031/ ET2031E
 Chapter 6: Inheritance

Lecturer: PhD. DO Thi Ngoc Diep

SCHOOL OF ELECTRICAL AND ELECTRONIC ENGINEERING
HANOI UNIVERSITY OF SCIENCE AND TECHNOLOGY
Content

• 6.1. Basic concepts

• 6.2. Polymorphism
• Virtual methods
• Abstract class
• 6.3. Multiple inheritance
• Virtual base class
• 6.4. Class Design

3
6.1. Basic concepts

4
Fundamental principles of OOT

Object-Oriented Technology

Polymorphism
Encapsulation
Abstraction

Inheritance

5
Basic concepts

• Reuse the source code:

• Structured programming: reuse the functions/procedures
• OOP: Many types of objects that have similar or related properties and behaviors =>
How do we reuse the written class?
• How to reuse an existing class:
• Copy old class content to another class => Redundant and difficult to manage when
there are changes.
• Creating a new class is the collection of objects from existing classes => Aggregation
• Create a new class on the basis of developing from an existing class => Inheritance
• Advantages:
• Minimize effort and cost
• Improve software quality
• Enhance real world modeling capability
• Improve maintainability
Association

• A relationship between classes

• Show that instances of classes could be either linked to each other or combined
logically or physically into some aggregation

• Aggregation:
• A binary association between whole object and part object. 1 4
• "has-a" relationship (or “is-a-part-of” relationship) TuGiac Diem
• part instance is independent of the whole instance.
• Example:
• A quadrangle : includes 4 points  Use point definition to define a quadrangle
• Composition:
• A "strong" form of aggregation
• a part could be included in at most one composite (whole) at a time
• if a whole is deleted, all of its parts are "normally" deleted with.

7
Aggregation - Composition
class Diem {
private: int x, y;
public:
Diem(){}
Diem(int x, int y) { this->x = x; this->y = y;}
void setX(int x){ this->x = x; }
int getX() { return x; }
void printDiem(){ cout << "(" << x << ", " << y << ")" << endl; }
};
1 4
1
TuGiac Diem
class TuGiac { 4
TuGiac Diem class TuGiac {
private: Diem d1, d2, d3, d4; private:
public: Diem d1, d2, d3, d4;
TuGiac(Diem p1, Diem p2, public:
Diem p3, Diem p4){ TuGiac(){
d1 = p1; d2 = p2; d3 = p3; d4 = p4; d1 = Diem(); d2 = Diem(0,1);
} d3 = Diem (1,1); d4 = Diem (1,0);
void printTuGiac(){ }
d1.printDiem(); d2.printDiem(); void printTuGiac(){
d3.printDiem(); d4.printDiem(); d1.printDiem(); d2.printDiem();
} d3.printDiem(); d4.printDiem();
}; }
};

int main(){ int main(){

Diem d1(2,3); Diem d2(4,1); //part instance is independent TuGiac tg1;
Diem d3(5,1); Diem d4 (8,4); // of the whole instance tg1.printTuGiac();
TuGiac tg1(d1, d2, d3, d4); return 0;
tg1.printTuGiac(); }
return 0;
}

8
Inheritance

• Nature of inheritance
• Create a new class by developing an existing class
• The new class inherits what is already in the old class and develops new
features.
• Old class: Parent class, super class, base class
• New class: Child class, sub class, derived class
• Sub class
• is-a-kind-of super class
• Reuse by inheriting data elements and behaviors
of the super class
• Can be detailed to follow new definition
• Extension: Add new properties / behavior
• Redefinition (Method Overriding): Modifying
behavior inherited from the super class
Basic concepts

• Data object in memory

inherited attributes

class X {
int x;
string str;
new attributes
public:
X() {}
~X() {}
void printX() {}
};

class Y : public X {
int y;
Y class object can call
public:
this inherited method
Y() {}
~Y() {}
void printY() {} new methods
};

10
Constructor and Destructor in Inheritance

• Super class’ constructors and destructors cannot be inherited by sub classes

• Each sub class constructor must call a super class constructor
• otherwise it will implicitly call the default constructor, or constructor with no
parameter (if any), of the super class
• The sub class must call constructor of the super class in the initialization list

class Pet { class Bird {

string name; public:
public: Bird(bool canFly) {...}
Pet() {...} };
Pet(string name) {...}
}; class Eagle: public Bird {
public:
class Dog: public Pet { Eagle() {...} // error
... Eagle(): Bird(true) {...}
public: };
Dog() {...} // Pet()
Dog(string name): Pet(name) {...}
};

11
Constructor and Destructor in Inheritance

• Sub class's destructor:

• Only need to handle additional/new properties of the sub class
• The destructor of the classes will be called automatically in reverse order from
the sub class to the super class
• ~Dog()  ~Pet()
• ~Eagle()  ~Bird()

12
Reminder: Access modifier for members of class

• public: The properties or methods are accessible from outside the

class.
• private: Properties or methods that are only accessible through the
method of the class itself.
• protected: Properties or methods can not be accessed from outside
of the class except from the methods of sub classes.

Access modifier public protected private

Access from methods of the class itself Ok Ok Ok

Access from methods of sub class Ok Ok X

Access from other classes Ok X X

13
Inheritance style

• Inheritance classification
• Number of base classes:
• Single Inheritance: a sub class inherits only one super class
• Multiple inheritance: a sub class inherits from 2 or more super classes
• Inheritance style:
• private
• protected
• public
• Syntax:
class A {
// members of class A
};
class B : <inheritance_style> A {
// new members of class B
};
Inheritance style

• A sub class can inherit from the super class according to the
following styles of inheritance: public, protected, private (default).
• The access scope of the members of the super class changes within
the sub class depending on the style of inheritance.

Access modifier in super class

Access modifier in sub class
will change to ... public protected private

public public protected Not accessible Unchanged

Inheritance style protected protected protected Not accessible All protected
private private private Not accessible All private

15
public inheritance style

class Employee { public

private:
string name; The access scope of member remains the
float salary; same, except the private is not accessible
public:
string getName() {...}
void pay() {...}

};

class Worker : public Employee{

private: Worker w;
int level; w.getName();
public: w.doWork();
void doWork() {...} w.pay();
void show() { w.salary = 10; // Error
cout << getName() w.show(); // Error
<< salary; // Error
}
};

16
public inheritance style

class Employee { public

private:
string name; The access scope of member remains the
float salary; same, except the private is not accessible
public:
string getName() {...}
void pay() {...}
float getSalary(){return salary;}
};

class Worker : public Employee{

private: Worker w;
int level; w.getName();
public: w.doWork();
void doWork() {...} w.pay();
void show() { w.getSalary(); // OK
cout << getName() w.show(); // OK
<< getSalary() ;
}
};

17
public inheritance style

class Employee { public

protected :
string name; The access scope of member remains the
float salary; same, except the private is not accessible
public:
string getName() {...}
void pay() {...}

};

class Worker : public Employee{

private:
int level; Worker w;
public: w.doWork();
void doWork() {...}
w.pay();
void show() {
cout << getName() w.name = "NV Tung"; // error
<< salary; cout << w.salary; // error
} cout << w.show(); // ok
};

18
private inheritance style

class LinkedList {
private: private
... All changes to private, except the
public: private is not accessible
void insertTail(int x) {...}
void insertHead(int x) {...}
void deleteHead() { ... }
void deleteTail() { ... }
int getHead() { ... }
int getTail() { ... }
...
};
Stack s;
class Stack : private LinkedList {
s.push(10);
public:
s.push(20);
void push(int x)
s.pop();
{ insertHead(x); }
int pop() {
s.insertTail(30); // error
int x = getHead(); // error
s.getTail();
deleteHead();
return x;
}
...
};

19
6.2. Polymorphism

20
Polymorphism concept

• Polymorphism: “one name, many forms”

• Perform an action in different ways
• For example:
• If you travel, you can choose a car, boat, or plane
• No matter what vehicle you go by, the result is the same: getting where you
need to go
• Different ways to perform a service
• Describe an object in different ways
• For example:
• One person is considered as an Intern, or a Staff of a company. Intern is
inherited some features of Staff.
• Depend on this person is “treated” as an Intern or a Staff, the suitable
method is applied at a time.

21
Polymorphism in programming

• Polymorphism in methods:
• Method with the same name, distinguished by list of parameters (method
overloading)
• Make different solutions using the same prototype (virtual method)
• ...
• Polymorphism in objects:
• Seeing objects in many different ways: one object has the ability to be acted
as other objects
• => An object can perform an action in many different ways

22
Pointer and reference variables to sub class object
class Base{ derived
public:
const char* getName(){ return "Base"; } Inherited
rBase
}; members
class Derived : public Base{ pBase
public:
New
int x = 10;
Overriding method members
const char* getName() { return "Derived"; }
const char* getValueDoubled() { return "Value Doubled"; }
};
int main(){
Derived derived; • rBase and pBase are declared as
Base &rBase = derived; variables of Base class
Base *pBase = &derived; • rBase and pBase only "see" the
cout << derived.x<< '\n'; 10 members of the Base class
cout << rBase.x<< '\n'; // error
cout << pBase->x<< '\n'; // error

cout << derived.getValueDoubled() << '\n'; Value Doubled

cout << rBase.getValueDoubled() << '\n'; // error
cout << pBase->getValueDoubled() << '\n'; // error

cout << derived.getName() << '\n';

Derived
cout << rBase.getName() << '\n';
Base
cout << pBase->getName() << '\n'; Base
return 0;
}
23
Pointer and reference variables to super class object
class Base{
public: base
const char* getName(){ return "Base"; }
}; pDe Inherited
class Derived : public Base{
public:
members
int x = 10; derived New
const char* getName() { return "Derived"; } members
const char* getValueDoubled() { return "Value Doubled"; }
};
int main(){
Base base;
Derived derived;
Derived &rDe = base; // error
Derived *pDe = (Derived *)&base;

cout << derived.x<< '\n'; 10

cout << pDe->x<< '\n'; 2661 // unsafe !!!

cout << derived.getValueDoubled() << '\n'; Value Doubled

cout << pDe->getValueDoubled() << '\n'; Value Doubled

cout << base.getName() << '\n';

Base
cout << derived.getName() << '\n';
Derived
cout << pDe->getName() << '\n';
Derived
return 0;
}
24
Polymorphism in methods

• Make different solutions using the same prototype

class Animal {
public: const char* speak() { return "???"; }};
class Cat: public Animal {
public: const char* speak() { return "Meow";}};
class Dog: public Animal {
public: const char* speak() { return "Woof"; }};

void report(Animal *pAnimal){ cout << " says " << pAnimal->speak() << '\n';}

int main()
{
Cat cat;
Dog dog;
Animal *pAnimal = &cat;
report(pAnimal) ; “Early binding” concept
pAnimal = &dog;
report(pAnimal);
return 0; void report(Cat &cat){
} cout << " says " << cat.speak() << '\n';}
need to add more functions? void report(Dog &dog){
cout << " says " << dog.speak() << '\n';}
...

25
Polymorphism in methods

• Make different solutions using the same prototype

using virtual method (late binding concept)
• for methods marked as virtual method:
• For object pointer, compiler delays the decision of method to call to runtime, instead
of compile time
class Animal {
public: virtual const char* speak() { return "???"; }};
class Cat: public Animal {
public: virtual const char* speak() { return "Meow";}};
class Dog: public Animal {
public: virtual const char* speak() { return "Woof"; }};

void report(Animal *pAnimal){ cout << " says " << pAnimal->speak() << '\n';}
int main()
{
Cat cat;
Dog dog;
Animal *pAnimal = &cat;
report(pAnimal) ;
pAnimal = &dog;
report(pAnimal)
return 0;
}
26
Virtual method

• Call to a virtual method from an object: as normal

• Call to a virtual method from a pointer: depends on type of the object at runtime
not on the type at compile time
must have
class A { public: virtual void check(){cout << "A";}};
class B : public A {public: virtual void check(){cout << "B";}};
class C : public B {public: virtual void check(){cout << "C";}};
class D : public B {}; can be ignored

A a; B b; C c; D d;
a.check();b.check();c.check();d.check(); ABCB

A *p;
p = &a; p->check(); // A::check();
p = &b; p->check(); // B::check();
ABCB // C::check();
p = &c; p->check();
p = &d; p->check(); // B::check();

void present(A *s){ s->check(); }

present(&a); // A::check();
present(&b); // B::check();
present(&c); // C::check();
present(&d); // B::check();

27
Pure virtual method

• Just as a virtual method declaration ...

• ... the definition will be defined in the sub class
=> can solve problem on different objects according to the same strategy
class Pet {
public:
virtual void say() = 0;
Pet* p[3] = {
};
new Dog(), new Cat(), new Cat() };
class Cat: public Pet {
for (int i=0; i<3; i++)
public:
p[i]->say();
virtual void say()
{ cout << "miao\n"; }
};
gruh
class Dog: public Pet { miao
public: miao
virtual void say()
{ cout << "gruh\n"; }
};

28
Abstract class

• A class that is used only as a base for other classes.

• No objects of this abstract class are ever created
• However, pointers and references to “objects” of the abstract class are still valid
• Abstract class contains pure virtual method
class Shape {
public: Shape p; // error
virtual void draw() = 0;
virtual void erase() = 0;
virtual void area() = 0; Circle c;
void redraw() { ... } Shape p2 = c; // error
}; Shape& p3 = c; // OK
Shape* p4 = &c; // OK
class Circle: public Shape {
public: void func(Shape s) {...} // error
...
virtual void draw() { ... }
void func(Shape& s) {...} // OK
virtual void erase() { ... } void func(Shape* s) {...} // OK
virtual void area() { ... }
};

29
Virtual destructor

• Needed when using pointer to base class

class ClassA { class ClassA {

public: public:
ClassA() { ... } ClassA() { ... }
~ClassA() { ... } virtual ~ClassA() { ... }
}; };

class ClassB: public ClassA { class ClassB: public ClassA {

public: public:
ClassB() { ... } ClassB() { ... }
~ClassB() { ... } virtual ~ClassB() { ... }
}; };

ClassB *b = new ClassB; ClassB *b = new ClassB;

ClassA *a =(ClassA *)new ClassB; ClassA *a =(ClassA *)new ClassB;

delete b; // ~ClassB, ~ClassA delete b; // ~ClassB, ~ClassA

delete a; // ~ClassA delete a; // ~ClassB, ~ClassA

30
Layout of an Object With Virtual Function

class X {
int x;
float xx;
static int count;

public:
X() {}
virtual ~X() {}

virtual void printAll() {}

void printInt() {}
void printFloat() {}
static void printCount() {}
};

http://www.vishalchovatiya.com/memory-layout-of-cpp-object/ 31
Layout of an Object With Virtual Function and Inheritance

class X {
int x;
string str;
public:
X() {}
virtual ~X() {}
virtual void printAll() {}
};

class Y : public X {
int y;
public:
Y() {}
~Y() {}
void printAll() {}
};

32
Resume

• Virtual functions ensure that the correct function is called for an object,
regardless of the type of reference (or pointer) used for function call.
• They are mainly used to achieve Runtime polymorphism
• Virtual functions cannot be static or friend function of another class.
• Virtual functions should be accessed using pointer or reference of base class
type to achieve run time polymorphism.
• The prototype of virtual functions should be same in base as well as derived
class.
• It is not mandatory for derived class to override (or re-define the virtual
function), in that case base class version of function is used.
• A class may have virtual destructor but it cannot have a virtual constructor.

33
6.3. Multiple inheritance

34
Multiple inheritance

• C++ allows a class to inherit from many different classes, at different

levels.
class Camera { class CellPhone:
public: public Camera,
void takePicture(); protected FMDevice,
... public Phone
}; {
public:
class FMDevice { void turnFMOn();
public: void turnFMOff();
void turnOn(); void setFMFreq(float f);
void turnOff(); ...
void setFreq(float f); };
...
};
CellPhone p;
class Phone { p.takePicture();
public: p.turnOn(); // error
void call(string num); p.turnFMOn();
... p.call("0912345678");
};

35
Virtual base class

• A sub class mentioned more than once in a super class can cause
the ambiguity  using a virtual base class
class A {
public: int a;
};
class B : public A {};
class C : public A {};
class D : public B, public C {};

D h;
h.a = 1; // error: ambiguity

class B : virtual public A {};

Class D will have only 1 sub class A
class C : virtual public A {};

36
Multiple inheritance

• Working with elements of the same name

• (1) specify the class name in the call C h; // class C
class A { public: void check();}; h.check(); // from C
class B : public A {public: void check();}; h.B::check(); //from B
class C : public B {public: void check();}; h.A::check(); //from A

• (2) note for un-virtual methods !

A *p, *q, *r; // declared as pointer of the class A
A a; p = &a;
B b; q = &b;
C c; r = &c;
p->check(); // A::check();
q->check(); // A::check();
r->check(); // A::check();

37
Layout of an Object With Virtual Function and Multiple Inheritances

class X {
public:
int x;
virtual ~X() {}
virtual void printX() {}
};

class Y {
public:
int y;
virtual ~Y() {}
virtual void printY() {}
};

class Z : public X, public Y {

public:
int z;
~Z() {}
void printX() {}
void printY() {}
void printZ() {}
};

38
6.4. Class Design
(READ AT HOME)

39
Class Design

• To manage the company's human resources, we can define classes according to the
working positions:

class Worker { class Manager { class Director {

private: private: private:
string name; string name; string name;
float salary; float salary; float salary;
int level; int dept; public:
public: public: string getName() {...}
string getName() {...} string getName() {...} void report() {...}
void pay() {...} void pay() {...} void pay() {...}
void doWork() {...} void manage() {...} ...
... ... };
}; };

• All 3 classes above have identical properties and functions in terms of content
 create an Employee class containing that common information for reuse

40
Class Design

class Worker { class Manager { class Director {

private: private: private:
string name; string name; string name;
float salary; float salary; float salary;
int level; int dept; public:
public: public: string getName() {...}
string getName() {...} string getName() {...} void report() {...}
void pay() {...} void pay() {...} void pay() {...}
void doWork() {...} void manage() {...} ...
... ... };
}; };

string name;
Super class float salary;
Employee string getName() {...}
void pay() {...}

Sub classes
Worker Manager Director
int level; int dept; void report(){...}
void doWork(){...} void manage(){...}

41
UML - Class diagram

• UML (Unified Modeling Language): a visual language for visualizing,

specifying, constructing, documenting the components of a software system
• Establish a unified way for building and “drawing” requirements following an
object-oriented design during software development
• Class Diagram: one of Static Structural Diagrams
• show the existence of classes and their relationships in the logical design of a system
• Class representation

42
UML - Class diagram

• Class: class name, attributes/properties, action/methods

• Italic: abstract members
• Underline: static members
• ALL_CAPS: final members
• Access modifier: (+, -, #)

43
UML - Class diagram

• Relationship between classes:

• Association: having connection with, using object from other class
• Multiplicity
• Navigability: specifies the direction of the link
• Constraint (constraint): has a condition on association

author

<Person>

Navigability

44
UML - Class diagram

• Relationship between classes:

• Association
• Type of association:
• Aggregation: describes the whole-part relationship, also known as the "is a part of"
relationship.
• Composition: is a form of aggregation, the part cannot exist if the whole is
destroyed.

• Generalization: Also known as “is a kind of”/inheritance relationship

Generalization

45
3.1.1 Symbols in class diagram

• Relationship between classes:

• Dependency: a set of suppliers provides something to the clients.
• Modification of the supplier may impact the client elements

https://www.uml-diagrams.org

46
UML - Class diagram

• Example
• Course registration system
Basic classes

CloseRegistrationForm Schedule CloseRegistrationController

- semester
+ open() + is registration open?() Professor
+ close registration() + commit() + close registration() - name
+ select alternate() - employeeID : UniqueId
+ remove offering() - hireDate
+ level() - status
+ cancel() - discipline
Student + get cost() - maxLoad
+ delete()
+ submit() + submitFinalGrade()
+ get tuition()
+ save() + acceptCourseOffering()
+ add schedule()
+ any conflicts?() + setMaxLoad()
+ get schedule()
+ create with offerings() + takeSabbatical()
+ delete schedule()
+ update with new selections() + teachClass()
+ has pre-requisites()

47
UML - Class diagram

• Example
• Course registration system
Simple class diagram

LoginForm RegistrationController
RegisterForCoursesForm 1
0..1
1 CloseRegistrationController
0..1
Schedule Professor
CloseRegistrationForm
0..*
0..*
instructor 0..1
1 0..4
Student
Course CourseOffering
0..*
CourseCatalogSystem
BillingSystem

48
UML - Object diagram

• Like class diagrams, instead of class diagrams, object diagrams

represent actual instances of classes and the relationships between
them.

Object/instance name

Class name

49
Exercises

1. Viết các lớp Shape (lớp trừu tượng) và các lớp con Circle, Square, Rectangle, Ellipse,
Sphere. Hãy thiết kế việc kế thừa sao cho hợp lý. Viết các hàm ảo tính diện tích hình.
2. Một Company có nhân viên gồm Director, Manager, và Worker. Mỗi nhân viên có tên,
mức lương khác nhau. Viết chương trình thực hiện việc thêm nhân viên, in thông tin
nhân viên, xóa toàn bộ nhân viên.

50
Exercises

1. Write a Shape class (an abstract class) and sub classes named Circle, Square, Rectangle,
Ellipse, Sphere. Design inheritance properly. Write virtual functions that calculate the
area of a shape.
2. A Company has employees consisting of Director, Manager, and Worker. Each employee
has a different name and salary. Write a program to add an array of employees, print
employee information, and delete all employees.

51