INHERITANCE

Order of execution of constructor and

destructor during inheritance
 Basic points[Order of execution of constructor and destructor during inheritance ]

• If a constructor is defined in the base class and derived class, then on

creating the object of derived class, base class constructor will be executed
first, then derived class constructor will be called.
• Order of execution of destructor will be in reverse order as that of the
order of execution of constructor
• If a base class is having default constructor, then it is optional for derived
class to have a default constructor
• If a base class is having parameterized constructor, then it is mandatory for
derived class to have a parameterized constructor which will pass the
parameters to the base class constructor through initializer list.
 Order of execution of constructor and destructor
during single inheritance[Default constructor in both
classes]
#include<iostream> class B:public A
using namespace std; {
class A public:
{ B()
public: {
A() cout<<"\n Calling default derived constructor";
{ }
cout<<"\nCalling default base class ~B()
constructor"; {
} cout<<"\nCalling derived class destructor";
~A() }
{ };
cout<<"\nCalling base class destructor"; int main()
} {
}; B obj1;
return 0;
}
Output:
Calling default base class constructor
Calling default derived constructor
Calling derived class destructor
Calling base class destructor
 Order of execution of constructor and destructor during single
inheritance[Parameterized constructor in both classes]
class B:public A
{
int l;
#include<iostream> public:
using namespace std; B(int p):A(p)
class A {
{ l=p;
int x; cout<<"\nCalling derived class
public: parameterized:"<<l;
A(int a) }
{ ~B()
x=a; {
cout<<"\nCalling base class parameterized cout<<"\nCalling derived class destructor";
"<<x; }
} };
~A() int main()
{ {
cout<<"\nCalling base class destructor"; B obj2(1);
} return 0;
}; }
Output:
Calling base class parameterized 1
Calling derived class parameterized: 1
Calling derived class destructor
 Order of execution of constructor and destructor during single
inheritance[Parameterized and default constructor in both classes]

#include<iostream> class B:public A

using namespace std; {
class A int l;
public:
{ B()
int x; {
public: cout<<"\nCalling derived class default";
A() }
{ B(int p):A(p)
cout<<"\nCalling base class default"; {
} l=p;
cout<<"\nCalling derived class parameterized:"<<l;
A(int a) }
{ ~B()
x=a; {
cout<<"\nCalling base class parameterized
cout<<"\nCalling derived class destructor";
"<<x; }
} };
~A() int main()
{
{ //B obj1; //Either default/ or parameterized constructor can be called
cout<<"\nCalling base class destructor"; B obj2(1);
} return 0;
}; }
 Polling Questions(Q1)

In case of inheritance where both base and derived class are having
constructors, when an object of derived class is created then___________ .
A. constructor of derived class will be invoked first
B. constructor of base class will be invoked first
C. constructor of derived class will be executed first followed by base class
D. constructor of base class will be executed first followed by derived class
 Q2
If base class has constructor with arguments, then it will be ________________ for the
derived class to have constructor and pass the arguments to base class constructor.
A. Optional
B. Mandatory
C. Compiler dependent
D. Compiler Error Situation
 Q3
In case of inheritance where both base and derived class are having constructor and
destructor, then which if the following are true ?
1. Constructors are executed in their order of derivation
2. Constructors are executed in reverse order of derivation
3. Destructors are executed in their order of derivation
4. Destructors are executed in reverse order of derivation
A. Only 2 ,4
B. Only 1 , 3
C. Only 1 , 4
D. Only 2, 3
 Q4
#include <iostream>
using namespace std;
class Base
{
public:
Base() { cout << "Base"; }
};
class Derived : public Base
{
public:
Derived(int i) { cout << i; }
};
int main()
{
Derived d2(10);
return 0;
}
A. Base10
B. 10Base
C. Base
D. 10
Order of execution of constructor and destructor during Multilevel inheritance
 Program-Order of execution of constructor and destructor during Multilevel
inheritance
#include<iostream> class B:public A
using namespace std; {
class A int l,m;
{ public:
int x,y; B(int p,int q,int r,int s):A(r,s)
public: {
A(int r,int s) l=p;
{ m=q;
x=r; cout<<"\nCalling derived class B constructor:"<<l<<"
y=s; "<<m;
cout<<"\nCalling base class constructor:"<<x<<" "<<y; }
} ~B()
~A() {
{ cout<<"\nCalling derived B class destructor";
cout<<"\nCalling base class destructor"; }
} };
};
 Program-Order of execution of constructor and destructor during Multilevel
inheritance….Continued
class C:public B
{
int n,m;
public:
C(int u,int v,int p,int q,int r,int s):B(p,q,r,s)
{
n=u;
m=v;
cout<<"\nCalling derived class C constructor with
values:"<<n<<" "<<m;
}
~C()
{
cout<<"\nCalling derived class C destructor";
}
};

int main()
{
C obj1(1,2,3,4,5,6);
return 0;
}
 Order of execution of constructor and destructor during Multiple inheritance

• Order of execution of constructor during multiple inheritance is dependent upon

the order of derivation(or order of inheritance).
• Order of execution of destructor will be reverse as that of order of execution of
constructor
 Order of execution of constructor and destructor during
Multiple inheritance…continued…

Class A:public B, virtual C

{
};
Order of execution of constructor
//C() virtual base
//B() ordinary base
//A() derived
If one of the class is inherited in virtual mode, then constructor of
that will be executed first and then order of inheritance will be
followed and if both are derived in virtual mode, then order of
inheritance will be followed(as usual)
 Polling Questions
//Output?? A. Compiler Dependent
#include<iostream>
using namespace std; B. Base1′s constructor called
class Base1 {
Base2′s constructor called
public:
Base1() Derived’s constructor called
{ cout << " Base1's constructor called" <<
endl; } C. Base2′s constructor called
};
Base1′s constructor called
class Base2 {
public: Derived’s constructor called
Base2()
{ cout << "Base2's constructor called" << D. Compiler Error
endl; }
};
class Derived: public Base1, public Base2 {
public:
Derived()
{ cout << "Derived's constructor called" <<
endl; }
};
int main()
{
Derived d;
return 0;
}
 Output??
//Output? A. Base1's destructor
#include <iostream>
using namespace std; Base2's destructor
class Base1 { Derived's destructor
public:
~Base1() { cout << " Base1's destructor" << endl; } B. Derived's destructor
};
class Base2 { Base2's destructor
public:
Base1's destructor
~Base2() { cout << " Base2's destructor" << endl; }
}; C. Derived's destructor
class Derived: public Base1, public Base2 {
public: D. Compiler Dependent
~Derived() { cout << " Derived's destructor" <<
endl; }
};
int main()
{
Derived d;
return 0;
}
 Output??
What will be the order of execution of base class constructors in the following method
of inheritance?
class A: public B, virtual public C {….};
A) B(); C(); A();
B) C(); B(); A();
C) A(); B(); C();
D) B(); A(); C();
Program-Order of execution of constructor and destructor during Multiple
inheritance
class P:public M,public N
#include<iostream> {
using namespace std; int l;
class M public:
{ P(int p,int q,int r):M(r),N(q)
protected: {
int m; l=p;
public: cout<<"\nIn P";
M(int x) }
{ void display()
m=x; {
cout<<"\nIn M"; cout<<“\n”<<"m="<<m<<"
} "<<"n="<<n<<" "<<"l="<<l;
}; }
class N };
{ int main()
protected: {
int n; P obj1(3,2,1);
public: obj1.display();
N(int y) return 0;
{ }
n=y; Output:
cout<<"\nIn N"; In M
In N
}
In P
};
m=1 n=2 l=3
 Order of execution of constructor and destructor during hierarchical inheritance

#include<iostream> class P:public M

using namespace std; {
class M int l;
{ public:
protected: P(int p):M(p)
int m; {
public: l=p;
M(int x) cout<<"\nIn P";
{ }
m=x; };
cout<<"\nIn M"; int main()
} {
}; N obj1(1);//Output In M,In N
class N:public M P obj2(2);//Output In M,In P
{ return 0;
protected: }
int n;
public:
N(int y):M(y)
{
n=y;
cout<<"\nIn N";

}
};