Slide 2: What are the Constructor & destructor ? Slide 3: Characteristics of Constructor Slide 4: Special CHaracteristics of Destructor Slide 5: Similarities Slide 6: Dissimilarities Slides 7: Default Constructor with example Slide 8: Parameterized Constructor Slide 9: Copy Constructor with example Slide 10: Destructor Slide 11: Bibliography

1. Name:- Sunipa Bera
Subject: Object Oriented Programing (OOP)
B. Tech CSE(CSF)
Roll no:- 17
PRN No.: 190105181016
Topic:-Constructor and Destructor

2. Constructor and Destructor
• Constructor
- It is a member function with the same name as its class is called
Constructor and it is used to initialize the objects of that class type
with a legal initial.
• Destructor
- A Destructor is also a member function whose name is the same as the
class name but is preceded by tilde (‘~’). A Destructor , as the name
itself suggests, is used to destroy the objects that have been created by a
constructor.

3. Special Characteristics of Constructor
• Their functions are invoked automatically when the object is created.
• If a class has a constructor, each object of that class will be initialized before any use is made of the object.
• Constructor functions obey the usual access rules.
• No return type(not even void) can be specified for a constructor.
• They cannot be inherited, though a derived class can call the base class constructor.
• A constructor may not be static.
• Constructor can belong to one of these categories: Default Constructors or Parameterized Constructor or Copy Constructor.
• It is not possible to take the address of a constructor.
• An object of a class with a constructor cannot be a member of a union.
• Member functions may be called from within a constructor.
• A constructor can be used explicitly to create new objects of its class type, using the syntax:
class- name(expression- list)
For example: sample obj1=sample(13,22,42);

4. Special Characteristics of Destructor
• Destructor functions are invoked automatically when the objects are destroyed.
• You can have only one destructor for a class. In other word, destructors can’t be overloaded.
• If a class has a destructor, each object of that class will be deinitialized before the object goes out of scope. ( local objects
at the end of the block defining them and global and static objects at the end of the program.)
• Destructor functions also, obey the usual access rules as other members do.
• No argument can be provided to a destructor, neither does it return any value.
• They cannot be inherited.
• A destructor may not be static.
• It is not possible to take the address of a destructor
• Member functions may be called from within a destructor.
• An object of a class with a destructor cannot be a member of a union.

5. Similarities
• Both Constructor and Destructor are associated with objects.
• Both Constructor and Destructor do not return any value.
• Both Constructor and Destructor are called automatically.

6. Dissimilarities
Basis of comparison Construction Destruction
Purpose It allocates the memory to an object. It deallocates the memory of an object.
Declaration class_name(arguments if any){ }; ~class_name(no arguments){ };
Arguments Constructor accepts arguments Destructor does not accept any arguments.
Calling
Constructor allows an object to initialize some of its
value before, it is used.
Destructor is called automatically, as blocked is
exited or program terminates.
Working
Construction allows an object to initialize some of
its value before, it is used.
Destructor allows an object to executes some
code at the time of its destruction .
Order of Execution Constructor are called in successive order.
Destructor are called in reverse order of
constructor.
In numbers There can be multiple constructors in a class. There is always a single destructor in the class.
Copy Constructor
Copy constructor allows a constructor allows a
constructor to declare and initialize a object from
another object.
No such Concept.
Over loading Constructors can be overloaded. Destructor can not be overloaded.

7. Default Constructors
• A constructor that accepts no parameter is called the Default Constructor.
• It is automatically invoked when an object.
• Default constructor is the constructor which doesn’t take any argument. It has no parameters.
Program:
// C++ program to illustrate the concept of Constructors
#include <iostream>
using namespace std;
class construct
{
public:
int a, b;
construct() //Default Constructor
{
a = 10;
b = 20;
}
};
int main()
{
construct c; /*Default constructor called automatically when the object is created*/
cout << "a: " << c.a << endl<< "b: " << c.b;
return 1;
}

8. Parameterized Constructor
• It is possible to pass arguments to constructors.
• Typically, these arguments help initialize an object when it is created.
• To create a parameterized constructor, simply add parameters to it the way you would to any other function.
• When you define the constructor’s body, use the parameters to initialize the object.
Program:
// CPP program to illustrate parameterized constructors
#include <iostream>
using namespace std;
class Point
{
private:
int x, y;
public:
Point(int x1, int y1) // Parameterized Constructor
{
x = x1;
y = y1;
}
int getX()
{
return x;
}
int getY()
{
return y;
}
};
int main()
{
Point p1(10, 15); // Constructor called
cout << "p1.x = " << p1.getX() << ", p1.y = " << p1.getY();
/*Access values assigned by constructor*/
return 0;
}
Output:
p1.x=10, p1.y = 15

9. Copy Constructor
• A copy constructor is a member function which initializes an object using another object of the same class.
• A copy constructor has the following general function Syntax:
ClassName (const ClassName &old_obj);
Program:
#include<iostream>
using namespace std;
class Point
{
private:
int x, y;
public:
Point(int x1, int y1)
{
x = x1;
y = y1;
}
Point(const Point &p2) // Copy constructor
{
x = p2.x;
y = p2.y;
}
int getX()
{
return x;
}
int getY()
{
return y;
}
};
int main()
{
Point p1(10, 15); // Normal constructor is called here
Point p2 = p1; // Copy constructor is called here
// Let us access values assigned by constructors
cout << "p1.x = " << p1.getX() << ", p1.y = " << p1.getY();
cout << "np2.x = " << p2.getX() << ", p2.y = " << p2.getY();
return 0;
}
Output:
p1.x = 10, p1.y = 15
p2.x = 10, p2.y = 15

10. Destructors
• Destructor is a member function which destructs or deletes an object.
• Syntax: ~constructor-name();
Program:
class String
{
private:
char* s;
int size;
public:
String(char*); // constructor
~String(); // destructor
};
String::String(char* c)
{
size = strlen(c);
s = new char[size + 1];
strcpy(s, c);
}
String::~String() { delete[] s; }

11. Bibliography
- Developerinsider
- Github
- W3school
Note:- Mentioned program in the presentation can be runnable only by using proper header files and logic.