Constructor & Destructor

Presented by:1.Somnath Kulkarni2.Indrajit Patil3.Sourabh Pandare

ContentsoIntroductionoCharacteristics of Constructor.oTypes of constructor.- Default Constructor- Parameterized Constructor- Copy Constructor oOverloaded Constructor-Multiple Constructor in a class -Constructor with default argumentoDestructoroDifference between constructor & destructor.oConclusion

Concept of constructor

In C++, a constructor is a ‘special’ member function whose task is

to initialize the objects of it’s class when it is created.

It is special because it’s 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 it’s associated

class is created.

They should be declared in the public section.They are invoked automatically when the objects are created.Do not have return types.Cannot be virtual .Cannot be inherited through a derived class can call the base class constructor.

Characteristics of Constructor

#include<iostream.h>#include<conio.h>class stud {int roll_no;char name[20];public:stud();void show(){cout<<“roll_no”<<roll_no<<endl;cout<<“name”<<name<<endl; }};

stude::stud(){cout<<“enter roll_no”<<endl;cin>>roll_no;cout<<“enter name”<<endl;cin>>name;}

void main(){stud s;clrscr();s.show();getch();}

Program to explain concept of constructor

Types of constructor

Constructor

1.Default 2.Parameterized 3.Copy

1.Default Constructor A constructor that accepts no parameters is called the default constructor.If no such constructor is defined , then the compiler supplies a default constructor.E.g.#include<iostream.h>class integer{int x;public:integer();};integer::integer(){x= 10;}void main(){integer int 1;getch();}

The constructors that can take arguments are as shown bellow:class integer{int m,n;public:integer(intx,inty);//parameterized constructor--------------------------------};integer::integer(int x,int y){m=x;n=y;}

Parameterized constructor

By calling the constructor explicitly integer int1=integer(0,100);//explicit callThis statement creates an integer object int1 and passes the values 0 and 100 to it.By calling the constructor implicitlyinteger int1(0,100);//implicit call.

Calling to Constructor

The constructor functions can also be defined as inline functions,

e.g.class integer{int m,n;public:integer(int x,int y){ m=x; n=y;}--------------------------------};

e.g.class a{- - - - - - - - - - - - - - public:a(a);};it is illegalclass a{-- - - - - -- - - - -public:a(a&);};is valid

- However a constructor can accept a reference to it’s own class as a parameter, in such cases, the constructor is called the copy constructor.

Syntax:class integer{int x;public:integer(integer &i){x=i.x;}-- - - - };

Copy Constructor

# include<iostream.h>#include<conio.h>class integer{int x;public:integer(int a){x=a;}integer(integer &i){x=i.x;}void show(){cout<<“x=”<<x<<endl;}};

void main(){integer i1(100);integer i2(i1);integer i3=i1integer i4;i4=i1; // it is not copy constrcout<<“i1”;i1.show();cout<<“i2”;i2.show();cout<<“i3”;i3.show();getch();}

Program to explain copy constructor

- We are used two kinds of constructors, they are:

1. integer(); //no arguments2. Integer(int,int); //two arguments- e.g class integer{ int m,n;public:integer() // constructor 1 {m=0;n=0;}integer(int a,int b) //constructor 2{m=a;n=b;}

integer(integer &i) //constructor3{m=i.m;n=i.n;}};

Overloaded Constructors: Multiple Constructors in a class

Program shows the use of overloaded constructors#include<iostream.h>

class integer{int m,n;public: integer(){m=0;n=0;}integer(int a,int b){ m=a; n=b;}integer(ineger &x) {m=x.m;n=x.n;} };

void main(){integer i1;integer i2(30,60);integer i3(i2);getch();}

Constructors with default arguments- It is possible to define constructors with

default arguments.- For example, the constructor complex()

can be declared as follows: complex(float teal, float imag=0);- e.g. program#include<iostream.h>#include<conio.h>class student{int roll_no;float marks;public:student(int x=10;float y=40) {roll_no=x;marks=y;}

void display(){cout<<“roll no”<<roll_no<<endl;cout<<“marks”<<marks<<endl;}};void main(){student s1;student s2(1,60);clrscr();cout<<“output using default constructor argumets:\n”;s1.display();cout<<“output without default constructor arguments:\n”;s2.display();getch();}

1. Constructor is invoked automatically as soon as the object of that class is created this concept is also known as automatic initialization of objects.

2. A key benefit of using a constructor is that it guarantees that the object will go through proper initialization before being used.

3. When a user instantiates an object, that object’s constructor is called and must return before the user can perform any other work with that object.

4. The main use and advantage of constructors is to initialize objects.

Advantages of constructor

- A destructor, as the name implies, is used to destroy the objects that have been created by a constructor.

- Like a constructor, the destructor is a member function whose name is the same as the class name but is precede by a tilde ( ~ ).

- E.g. ~integer(){------------------------------}

- Destructor never take any arguments.- The object is destroyed when end of scope of program.

Destructors

Constructor Destructor1.Constructor is a special member function whose task is to initialize the object’s of it’s class.

1.Destructor is used to destroy objects that have been created by a constructor.

2. It’s name is same as class name .

2. it’s name is same as class name but is preceded by tilde.

3.Constructor is invoked when the object of it’s associated class is created.

3.It is invoked implicitly by the compiler upon exit of the program to clean up the storage that is no longer accessible.

4.Constructor can take arguments.

4. Destructor does not take any arguments.

5.e.g. student(int a,int b) 5. e.g. ~student()

Difference Between Constructor & Destructor