Constructors, Destructors, call in parameterized Constructor, Multiple constructor in a class, Explicit/implicit call, Copy constructor, Dynamic Constructors and call in parameterized Constructor

1. CONSTRUCTORS
AND
DESTRUCTORS
Harinder Singh
Sukhpal Singh
Thapar University, Patiala
Batch: 2011-2013

2. WHAT IS A CONSTRUCTOR ?
 In c++ , a constructor is a ‘special’ member
function whose task is to initialize the objects
of its class.
 It is special because its name is the same as
the class name.
 It is called constructor because it constructs
the value of data members of the class.
 The constructor is invoked whenever an object
of its associated class is created.
ssgill©tupatiala

3. CLASS WITH A CONSTRUCTOR
Class integer {
int m, n;
public:
integer(void); // constructor declared
};
Integer : : integer (void) // constructor defined
{
m=0; n=0;
}
Object declartion:
Integer int1; // object int1 created
ssgill©tupatiala

4. CHARACTERISTICS OF THE CONSTRUCTOR
 They should be declared in public section.
 They are invoked automatically when the objects are
created.
 They don't have return types, cannot return values.
 A constructor that accepts no parameters is called
default constructor. The default constructor for class
A is A:: A() . The statement A a; invokes the default
constructor of the compiler to create the object a.
ssgill©tupatiala

5. PARAMETERIZED CONSTRUCTOR
The constructor that can take arguments.
Class integer {
int m, n;
public:
integer(int x, int y); //parameterized constructor
};
Integer : : integer (int x, int y)
{
m=x; n=y;
}
Object declaration statement “integer int1 ; “ do not work
here.
ssgill©tupatiala

6. CALL IN PARAMETERIZED CONSTRUCTOR
 We must pass the initial values as arguments to
the constructor function when object is created.
This can be done in two ways:
 By calling the constructor explicitly.
integer int1 = integer(0, 100);
 By calling the constructor implicitly.
integer int1(0, 100);
This method is also called shorthand method.
ssgill©tupatiala

7. EXPLICIT/IMPLICIT CALL
int main()
{
integer int1(0, 100); //implicit call
integer int2 = integer(25, 75); //explicit call
cout<<“object 1:”
int1.function1();
cout<<“object 2:”
int2.function1();
return 0;
}
Output
object1: m=0 and n= 100
object2: m=25 and n= 75
ssgill©tupatiala

8. MULTIPLE CONSTRUCTOR IN A CLASS
Class integer
{
int m, n;
public:
integer() //default constructor
{m=0; n=0;}
integer(int a, int b) //parameterized constructor
{m=a; n=b;}
integer(integer & i) //copy constructor
{m= i.m; n= i.n;}
};
ssgill©tupatiala

9. CONSTRUCTORS WITH DEFAULT ARGUMENTS
complex(float real , float imag=0)
{
}
 complex c1(5.0);
 complex c2(2.0,3.0);
 Difference b/w A::A() and A::A(int a=0).
ssgill©tupatiala

10. DYNAMIC INITIALIZATION OF OBJECTS
Provide various initialization formats using
overloaded constructors.
 Fixed_deposit() { }
 Fixed_deposit(long int p, int y ,float r=0.12);
 Fixed_deposit( long int p, int y, int r);
ssgill©tupatiala

11. COPY CONSTRUCTOR
 It is used to declare and initialize an object
from another object.
e.g
• code() { }
• code( int a) {id = a;}
• code( code &x){ id = x.id; } //copy constructor.
 And various calls for them are:
• code A(100); // object A is Created and initialized.
• code B(A); // copy constructor called.
• code C = A; // copy constructor called again.
• code D; // object D is created , not initialized
D=A; // copy constructor is not called.
ssgill©tupatiala

12. DYNAMIC CONSTRUCTORS
 It is used to allocate memory while creating
objects.
• Enable the system to allocate right amount of
memory for each object when objects are not of
same size.
• Thus resulting in saving of memory.
ssgill©tupatiala

13. DYNAMIC CONSTRUCTORS
class String
{
char *name;
int length;
public:
String ()
{ length = 0;
name = new char[length+1];
}
String (char *s)
{ length = strlen(s);
name = new char[length+1];
strcpy(name, s);
}
};
main()
{
Char *first = “ME_SE_CR” ;
String name1( first);
String name2(“ Rupinder”);
.
.
.
}
ssgill©tupatiala

14. DESTRUCTORS
 ~ integer() { }
 As new is used to allocate memory in
dynamic constructors, here we use delete to
free that memory.
 Never take any argument nor does it return any
value.
 It will be invoked implicitly by compiler upon
exit from program or a block or a function.
ssgill©tupatiala

15. DESTRUCTORS
Int count = 0;
class test1
{
public :
~test1()
{
count ++;
cout <<“n no. of object created “
<< count ;
}
~test1 ()
{ cout <<“n no. of object destroyed”
<< count ;
Count - - ;
}
};
main()
{
cout << “n Enter Main n”;
test1 t1, t2, t3, t4;
{
cout <<“n Entered in block1” ;
test1 t5;
}
{
cout <<“n Entered in block2” ;
test1 t6;
}
cout << “n Re-Enter Main n”;
return 0;
}
ssgill©tupatiala

16. OUT PUT
 Enter Main
No. of object created 1
No. of object created 2
No. of object created 3
No. of object created 4
 Enter block 1
No. of object created 5
No. of object destroyed 5
 Enter block 2
No. of object created 5
No. of object destroyed 5
 Re - Enter Main
No. of object destroyed 4
No. of object destroyed 3
No. of object destroyed 2
No. of object destroyed 1
ssgill©tupatiala

17. THANK YOU
ssgill©tupatiala