Inheritance

Inheritance
 The mechanism by which one class can

inherit the properties of another.
 It allows a hierarchy of classes to be built,

moving from the most general to the most
specific.
Base Class, Derived Class
 Base Class
 Defines all qualities common to any derived
classes.
 Derived Class
 Inherits those general properties and adds
new properties that are specific to that class.
Example: Base Class
class 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 example

int y;
public:
/* 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.
// Inherit as private
class derived : private base {
int y;
public:
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!
}
class 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 Members
The 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 Derived
private members inaccessible
protected members private members
public members private members

 Type 2: inherit as protected

Base Derived
protected members protected members
public members protected members

 Type 3: inherit as public

Base Derived
protected members protected members
public 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
base
class base {
int i;
public:
base(int n) {
cout << “constructing base \n”;
i = n; }
~base() { cout << “destructing base \n”; }
};
Example: Constructor of derived

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;
}
constructing base
constructing derived
destructing derived
destructing base
Multiple Inheritance
 Type 1:
base 1
derived 1
derived 2
Multiple Inheritance
• Type 2:
base 1 base 2
derived
Example: Type 2
// Create first base class

class B1 {
int a;
public:
B1(int x) { a = x; }
int geta() { return a; }
};
Example: Type 2
// Create second base class

class B2 {
int b;
public:
B2(int x) { b = x; }
int getb() { return b; }
};
Example: Type 2
// 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 Base
Derived 1 Derived 2
Derived 3
 Base is inherited twice by Derived 3!

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.
Example
base *p; // base class pointer

base 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.
Example
class base {
public:
int i;
base (int x) { i = x; }
virtual void func() {cout << i; }
};
Example

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

void func() {cout << i * i; }
};
Example
int 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: area
class area {
public:
double dim1, dim2;
area(double x, double y)
{dim1 = x; dim2 = y;}
// pure virtual function
virtual double getarea() = 0;
};
Example: rectangle
class rectangle : public area {

public:
// function overriding
double getarea() {
return dim1 * dim2;
}
};
Example: triangle
class triangle : public area {

public:
// function overriding
double getarea() {
return 0.5 * dim1 * dim2;
}
};

Inheritance

Uploaded by

Copyright:

Available Formats

Inheritance

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Inheritance

Uploaded by

Copyright:

Available Formats

Inheritance

 The mechanism by which one class can

 It allows a hierarchy of classes to be built,

 The keyword public tells the compiler that

 However, all private elements of base will

class derived : public base {

 If the access specifier is private:

class derived : private base {

 Sometimes you want to do the following:

The full general form of a class declaration:

 Type 1: inherit as private

private members inaccessible

protected members private members

public members private members

 Type 2: inherit as protected

private members inaccessible

protected members protected members

public members protected members

 Type 3: inherit as public

private members inaccessible

protected members protected members

public members public members

 It is possible for both the base class and

 What if the constructor functions of both

class derived : public base {

// Create first base class

// Create second base class

 Base is inherited twice by Derived 3!

 To resolve this problem, virtual base class

// Inherit base as virtual

/* Here, D3 inherits both D1 and D2.

class D3 : public D1, public D2 {

 A pointer declared as a pointer to base

 However, only those members of the

base *p; // base class pointer

p = &B_obj; // p can point to base object

 A virtual function is a member function

 It can be used to support run-time

class derived : public base {

// The keyword virtual is not needed.

 A pure virtual function has no definition

class rectangle : public area {

class triangle : public area {

You might also like