Haresh Jaiswal

Rising Technologies, Jalna.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 1

Introduction
 A constructor is a special member function whose task is to
initialize the data members of an objects of its class.
 It is special because it has same name as its class name.
 It invokes automatically whenever a new object of its associated
class is created.
 It is called constructor because it constructs the initial values of
data members and build your programmatic object.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 2

Introduction
 It is very common for some part of an object to require
initialization before it can be used.
 Suppose you are working on 100's of objects and the default
value of a particular data member is needed to be zero.
 Initialising all objects manually will be very tedious job.
 Instead, you can define a constructor function which initialises
that data member to zero. Then all you have to do is declare
object and constructor will initialise object automatically.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 3

Constructor Example
class add  When a class contains a
{ constructor, it is guaranteed
int m, n ; that an object created by the
public : class will be initialized
add (); automatically.
};  add a ;
 Above declaration not only
add :: add ()
{ creates the object a of type
m = 0; add, but also initializes its data
n = 0; members m and n to zero.
}
Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 4
Constructors
 There is no need to write any statement to invoke the constructor
function.
 If a ‘normal’ member function is defined for initialization, we
need to invoke that function for each and every objects
separately.
 A constructor that accepts no parameters is called the default
constructor.
 The default constructor for class A will be A : : A ( )

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 5

Characteristics of Constructor
 They must be declared in the public scope.
 They are invoked automatically when the objects are created.
 They do not have return types, not even void and they cannot
return values.
 They cannot be inherited, though a derived class can call the base
class constructor.
 Like other C++ functions, Constructors can have default
arguments.
 Constructors can not be virtual.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 6

Characteristics of Constructor
 We can not refer to their addresses.
 An object with a constructor (or destructor) can not be used as a
member of a union.
 They make ‘implicit calls’ to the operators new and delete when
memory allocation is required.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 7

Constructor
 The constructor function is responsible for creation of object.
 But in previous examples, we have not defined any constructor in
class, so how come the objects were created of those classes?
 The answer is, If no constructor is defined in the class in such
situation the compiler implicitly provides a constructor, which is
called as default constructor.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 8

Constructor
class sample class sample
{ {
int someDataMember; int someDataMember;
public: public :
void someFunction () sample()
{ {
.. After }
Compilation
.. void someFunction ()
} {
}; ..
..
}
};

Compiler has implicitly added a constructor to the class, which has

empty body, because compiler is not supposed to put any logic in that.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 9

Types of Constructor
 Default Constructor/Non-Arg Constructor
 Parameterized Constructor
 Copy Constructor
 Dynamic Constructor

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 10

Default Constructor
 A constructor without any parameter is known as non-arg
constructor or simply default constructor.
 If no constructor is defined in a class, then compiler implicitly
provides an empty body constructor which is called as default
constructor.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 11

Non-Arg Constructor Example
class circle  In example beside, the
{ constructor function takes no
float radius;
public: argument, and simply initializes
circle() radius to zero.
{
radius = 0;  Non-arg constructor is also
} called as default constructor.
};

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 12

Default Constructor Example
class circle  In example beside, we have not
{ defined any constructor, so
float radius;
public: compiler will provide an empty
body constructor to the class,
}; which is called as default
constructor.
class circle
{
float radius;
public:
circle()
{
}
};
Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 13
Parameterised Constructors
 Sometimes it becomes necessary to initialize the various data
elements of an objects with different values when they are
created.
 This is achieved by passing arguments to the constructor
function when the objects are created.
 The constructors that can take arguments are called
parameterized constructors.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 14

Parameterised Constructors
class circle
{
float radius; Non-Arg (Default) constructor,
public: which takes no arguments
circle()
{
radius = 0;
}

circle(float r)
{ Parametirised constructor, which
radius = r; takes 1 arguments as radius.
}
};

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 15

Parameterised Constructors
class circle
{
 When a constructor is
float radius; parameterized, we must pass the
public: arguments to the constructor
circle()
{ function when an object is
radius = 0; declared.
}
 Consider following declaration
circle(float r) circle firstObject;
{ circle secondObject(15);
radius = r;
}
};

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 16

Two Ways of calling a Constructor
class circle
{
o Implicit call (shorthand method)
float radius;  circle ob(7.6);
public:
circle() o Explicit call
{  circle ob;
radius = 0;
}  ob = circle(7.6);

circle(float r)
{
radius = r;
}
};

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 17

Multiple Constructors in a Class
 C + + permits to use more than one constructors in a single class.

 Add( ) ; // No arguments

 Add (int, int) ; // Two arguments

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 18

Multiple Constructors in a Class
class add  The first constructor receives no
{ arguments.
int m, n ;
public :
add ( ) {m = 0 ; n = 0 ;}  The second constructor receives
add (int a, int b) two integer arguments.
{m = a ; n = b ;}
add (add & i)  The third constructor receives one
{m = i.m ; n = i.n ;}
add object as an argument.
};

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 19

Multiple Constructors in a Class
class add  Add a1;
{  Would automatically invoke the
int m, n ; first constructor and set both m
public : and n of a1 to zero.
add ( ) {m = 0 ; n = 0 ;}  Add a2(10,20);
add (int a, int b)
 Would call the second constructor
{m = a ; n = b ;} which will initialize the data
add (add & i) members m and n of a2 to 10 and
{m = i.m ; n = i.n ;} 20 respectively.
};

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 20

Multiple Constructors in a Class
class add  Add a3(a2);
{  Would invoke the third
int m, n ; constructor which copies the
public : values of a2 into a3.
add ( ) {m = 0 ; n = 0 ;}  This type of constructor is called
add (int a, int b) the “copy constructor”.
{m = a ; n = b ;}  Construction Overloading
add (add & i)
 More than one constructor
{m = i.m ; n = i.n ;} function is defined in a class.
};

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 21

Multiple Constructors in a Class
class complex  complex ( ) { }
{
float x, y ;
public :  This contains the empty body and
complex ( ) { } does not do anything.
complex (float a)
{x=y=a;}
complex (float r, float i)  This is used to create objects
{x=r;y=i} without any initial values.
------
};

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 22

Multiple Constructors in a Class
 C + + compiler has an implicit constructor which creates objects,
even though it was not defined in the class.
 This works well as long as we do not use any other constructor in
the class.
 However, once we define a constructor, we must also define the
“do-nothing” implicit constructor.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 23

Constructors with Default Arguments
 It is possible to define constructors with default arguments.
 Consider complex (float real, float imag = 0);
 The default value of the argument imag is zero.
 complex C1 (5.0) assigns the value 5.0 to the real variable and 0.0 to
imag.
 complex C2(2.0,3.0) assigns the value 2.0 to real and 3.0 to imag.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 24

Constructors with Default Arguments
 A::A()  Default constructor
 A : : A (int = 0)  Default argument constructor

 The default argument constructor can be called with either one

argument or no arguments.
 When called with no arguments, it becomes a default
constructor.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 25

Dynamic Initialization of Objects
 Providing initial value to objects at run time.

 Advantage – We can provide various initialization

formats, using overloaded constructors.

This provides the flexibility of using

different format of data at run time
depending upon the situation.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 26

Copy Constructor
A copy constructor is used to declare and initialize an object
from another object.

integer (integer & i) ;

integer I 2 ( I 1 ) ; or integer I 2 = I 1 ;
The process of initializing through a copy constructor is known as
copy initialization.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 27

Copy Constructor
The statement
I 2 = I 1;
will not invoke the copy constructor.

If I 1 and I 2 are objects, this statement is legal and assigns the

values of I 1 to I 2, member-by-member.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 28

Copy Constructor
 A reference variable has been used as an argument to the copy
constructor.

 We cannot pass the argument by value to a copy constructor.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 29

Dynamic Constructors
 The constructors can also be used to allocate memory while
creating objects.

 This will enable the system to allocate the right amount of

memory for each object when the objects are not of the same
size.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 30

Dynamic Constructors
 Allocation of memory to objects at the time of their
construction is known as dynamic construction of objects.

 The memory is created with the help of the new operator.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 31

Destructors
 A destructor is used to destroy the objects that have been
created by a constructor.

 Like constructor, the destructor is a member function whose

name is the same as the class name but is preceded by a tilde.
eg: ~ integer ( ) { }

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 32

Destructors
 A destructor never takes any argument nor does it return any
value.

 It will be invoked implicitly by the compiler upon exit from the

program – or block or function as the case may be – to clean
up storage that is no longer accessible.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 33

Destructors
 It is a good practice to declare destructors in a program since it
releases memory space for further use.

 Whenever new is used to allocate memory in the constructor,

we should use delete to free that memory.

Rising Technologies, Jalna (MH). + 91 9423156065, http://www.RisingTechnologies.in 34