Haresh Jaiswal

Rising Technologies,
Jalna.

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.

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.

3
Constructor Example
class add When class contains a
{ a it is
int m, n ; constructor
that an object created guarantee
by
public : ,
the
class be d
add will initialized
}; (); automatically
.Above declaration not
add :: add ()
add a ; the object only of
creates
{
m = 0; add,
a but also initializes itstype
n = 0; data members m and n to
} zero.
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 ( )

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.

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.

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.

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.
9
Types of Constructor
Default Constructor/Non-Arg Constructor
Parameterized Constructor
Copy Constructor
Dynamic Constructor

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.

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

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()
{
}
};
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 arguments are
take parameterized constructors. called

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.
}
};

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

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

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

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

18
Multiple Constructors in a Class
class add The first constructor receives no
{ arguments.
int m, n ;
public :
add ( ) The second constructor receives
{m = 0 ; two integer arguments.
n = 0 ;}
add The third constructor receives one
(int a, int
b) add object as an argument.
{m = a ; n = b ;}
add (add & i)
{m = i.m ;
19
Multiple Constructors in a Class
class add Add a1;
{ Would automatically invoke the
int m, n ; first constructor and set both
public : m 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 ; 20 respectively.
}; n = i.n ;}

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 ; function is defined in a class.
}; n = i.n ;}

21
Multiple Constructors in a Class
class complex complex ( ) { }
{
float x, y ;
public : This contains the empty body and
comple does not do anything.
x(){

} This is used to create objects

comple without any initial values.
x (float a)
{x=y
=a;}
comple
x (float r,
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.

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.

24
Constructors with Default Arguments
A : : A ( )  Default constructor
A : : A (int =  Default argument constructor
0)
The default argument constructor can be called with either one
argument or no arguments.
When called with no arguments, it becomes a default
constructor.

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.

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.

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.

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.

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.

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.

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 ( ) { }

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.

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.

34