InheritanceSpeaker: Muhammad Hammad Waseem

m.hammad.wasim@gmail.com

Inheritance• Inheritance: The mechanism by which one class can inherit the

properties of another.• Inheritance: A parent-child relationship between classes• Inheritance allows sharing of the behavior of the parent class into its

child classes.• child class can add new behavior or override existing behavior from parent

• It allows a hierarchy of classes to be built, moving from the most general to the most specific.• Eg: point -> 3D_point -> sphere…

Base Class, Derived Class• Base Class• Terms to describe the parent in the relationship, which shares its functionality• Also called Superclass, Parent class

• Derived Class• Terms to describe the child in the relationship, which accepts functionality

from its parent• Also called Subclass, Child class

• General Syntax:• class derivedClassName : AccessSpecifier baseClassName{… … …}

Example: Base Classclass base {int x;

public:void setx(int n) { x = n; }void showx(){ cout << x << ‘\n’ }

};

Example: Derived Class// Inherit as public

class derived : public base {int y;

public:void sety(int n) { y = n; }void showy() { cout << y << ‘\n’;}

};

Access Specifier: public• The keyword public tells the compiler that base will be

inherited such that:• all public members of the base class will also be public members of

derived.• However, all private elements of base will remain private to it

and are not directly accessible by derived.

Example: main()int main() {

derived ob;ob.setx(10);ob.sety(20);ob.showx();ob.showy();

}

An Incorrect Exampleclass derived : public base {

int y;public:

void sety(int n) { y = n; }/* Error ! Cannot access x, which is private member of base. */

void show_sum() {cout << x+y; }};

Access Specifier: private• If the access specifier is private:• public members of base become private members of

derived.• these members are still accessible by member functions

of derived.

Example: Derived Class // Inherit as private

class derived : private base {int y;

public:void sety(int n) { y = n; }void showy() { cout << y << ‘\n’;}

};

Example: main()int main() {derived ob;ob.setx(10); // Error! setx() is private.

ob.sety(20); // OK!

ob.showx(); // Error! showx() is private.

ob.showy(); // OK!

}

Example: Derived Classclass derived : private base {int y;

public:// setx is accessible from within derived

void setxy(int n, int m) { setx(n); y = m; }// showx is also accessible

void showxy() { showx(); cout<<y<< ‘\n’;}};

Protected Members• Sometimes you want to do the following:• keep a member of a base class private• allow a derived class access to it

• Use protected members!• If no derived class, protected members is the same as private

members.

Protected MembersThe full general form of a class declaration:

class class-name {// private members

protected:// protected members

public:// public members

};

3 Types of Access Specifiers• Type 1: Inherit as Private

Base DerivedPrivate members InaccessibleProtected members Private membersPublic members Private members

3 Types of Access Specifiers• Type 2: Inherit as Protected

Base DerivedPrivate members InaccessibleProtected members Protected membersPublic members Protected members

3 Types of Access Specifiers• Type 3: Inherit as Public

Base DerivedPrivate members InaccessibleProtected members Protected membersPublic members Public members

Constructor and Destructor• It is possible for both the base class and the derived class to have

constructor and/or destructor functions. • The constructor functions are executed in order of derivation.• i.e. the base class constructor is executed first.

• The destructor functions are executed in reverse order.

Passing arguments• What if the constructor functions of both the base class and

derived class take arguments?1. Pass all necessary arguments to the derived class’s constructor.2. Then pass the appropriate arguments along to the base class.

Example: Constructor of baseclass base {

int i;public:

base(int n) {cout << “constructing base \n”; i = n; }

~base() { cout << “destructing base \n”; }};

Example: Constructor of derivedclass derived : public base {int j;

public:derived (int n, int m) : base (m) {

cout << “constructing derived\n”;j = n; }

~derived() { cout << “destructing derived\n”;}};

Example: main()int main() {

derived o(10,20);return 0;

}

OUTPUT:

constructing baseconstructing deriveddestructing deriveddestructing base

Multiple Inheritance• Type 1:

Base 1

derived 1

derived 2

base 1 base 2

derived

Multiple Inheritance• Type 2:

Example: Type 2 (first base class)// Create first base class

class B1 {int a;

public:B1(int x) { a = x; }int geta() { return a; }

};

Example: Type 2 (second base class)// Create second base class

class B2 {int b;

public:B2(int x) { b = x; }int getb() { return b; }

};

Example: Type 2 (inherit two base classes)// Directly inherit two base classes.

class D : public B1, public B2 {int c;

public:D(int x, int y, int z) : B1(z), B2(y) {c = x; }void show() {cout << geta() << getb() << c;}

} ;

Potential Problem• Base is inherited twice by Derived 3!

Derived 3

Base Base

Derived 1 Derived 2

Virtual Base Class• To resolve this problem, virtual base class can be used.

class base {public:

int i;};

Virtual Base Class// Inherit base as virtual

class D1 : virtual public base {public:int j;

};class D2 : virtual public base {public:int k;

};

Virtual Base Class/* Here, D3 inherits both D1 and D2. However, only one copy of base is present */

class D3 : public D1, public D2 {public:

int product () { return i * j * k; }};

Pointers to Derived Classes• A pointer declared as a pointer to base class can also be used to point

to any class derived from that base.

• However, only those members of the derived object that were inherited from the base can be accessed.

Examplebase *p; // base class pointerbase B_obj;derived D_obj;

p = &B_obj; // p can point to base object p = &D_obj; // p can also point to derived object

Virtual Function• A virtual function is a member function• declared within a base class• redefined by a derived class (i.e. overriding)

• It can be used to support run-time polymorphism.

Exampleclass base {public:

int i;base (int x) { i = x; }virtual void func() {cout << i; }

};

Exampleclass derived : public base {public:

derived (int x) : base (x) {}// The keyword virtual is not needed.

void func() {cout << i * i; }};

Exampleint main() {base ob(10), *p;derived d_ob(10);

p = &ob;p->func(); // use base’s func()

p = &d_ob;p->func(); // use derived’s func()

}

Pure Virtual Functions• A pure virtual function has no definition relative to the base class. • Only the function’s prototype is included.

• General form:virtual type func-name(paremeter-list) = 0

Example: areaclass area {public:double dim1, dim2; area(double x, double y)

{dim1 = x; dim2 = y;}// pure virtual function

virtual double getarea() = 0;};

Example: rectangleclass rectangle : public area {public:

// function overriding

double getarea() {return dim1 * dim2;

}};

Example: triangleclass triangle : public area {public:

// function overriding

double getarea() {return 0.5 * dim1 * dim2;

}};