Constructor and Destructor in C++ are the special member functions of the class and they are essential components of Object Oriented Programming. Constructors are special functions within a class that initialize the object when it is created, providing default or custom values to its attributes. On the other hand, destructors are used to clean up resources allocated by the object during its lifetime, and they are automatically invoked when the object goes out of scope or is explicitly deleted.
What is a Constructor in C++?
A constructor in C++ is a special member function of a class that is automatically invoked when an object of that class is created. Its primary purpose is to initialize the object's attributes or perform any necessary setup. Constructors have the same name as the class and do not have a return type.
There are many types of constructors available in C++. When an object is instantiated, the appropriate constructor is automatically called, ensuring that the object is properly initialized before it is used. Constructors play a crucial role in object-oriented programming by establishing the initial state of objects.
How many types of constructors in C++?
There are basically four types of constructors present in C++ and these are:
- Default Constructor.
- Parameterized Constructor.
- Copy Constructor.
- Dynamic Constructor.
Let's discuss each of them in detail one by one,
Default Constructor.
A default constructor in C++ is a constructor that takes no parameters. It is automatically generated by the compiler if no constructor is explicitly defined in the class. It is called when an object is created with no arguments.
Syntax:
class ClassName { public: ClassName() { // Constructor code } };
Example Code for Default Constructor:
// C++ code implementation for default constructor #include <iostream> using namespace std; class MyClass { private: int rollNo; string name; public: // Default Constructor MyClass() { std::cout << "Default Constructor Called" << std::endl; rollNo = 0; name = "NULL"; } void display(){ cout << "Student Name: " << name << endl; cout << "Roll No: " << rollNo << endl; } }; int main() { // Creating an object invokes the default constructor MyClass obj; obj.display(); return 0; }
Default Constructor Called
Student Name: NULL
Roll No: 0
In the above example, we created a class MyClass with a default constructor to initialize the initial values to data members of the class, and the default constructor is called as soon as we create the object of that class obj.
Note: It's important to explicitly define a default constructor when custom initialization is required or when other constructors are defined in the class. (alert-passed)
Parameterized Constructor.
A parameterized constructor in C++ is a constructor that accepts parameters during its invocation. It allows you to initialize the object with specific values based on the provided arguments.
Syntax:
class ClassName { public: ClassName(type1 param1, type2 param2, ...) { // Constructor code } };
Example Code for Parameterized Constructor:
// C++ code implementation for Parameterized constructor #include <iostream> using namespace std; class Car { private: string brand; int year; public: // Parameterized Constructor Car(string b, int y) { cout << "Parameterized Constructor Called" << endl; brand = b; year = y; } void display() { cout << "Brand: " << brand << ", Year: " << year << endl; } }; int main() { // Creating an object using the parameterized constructor Car myCar("Toyota", 2022); myCar.display(); return 0; }
Parameterized Constructor Called Brand: Toyota, Year: 2022
In the above example, the parameterized constructor takes parameters (in this case, a string and an integer) during its declaration. The constructor is called when an object is created, allowing custom initialization based on the provided arguments.
Copy Constructor.
A copy constructor in C++ is a special type of constructor that is used to create a new object as a copy of an existing object of the same class. It is invoked when an object is passed by value or returned by value.
Note: If a copy constructor is not explicitly defined, the compiler generates a default copy constructor. (alert-success)
Syntax:
class ClassName { public: // Copy Constructor ClassName(const ClassName& obj) { // Constructor code } };
Example Code for Copy Constructor:
// C++ code implementation for Copy constructor #include <iostream> using namespace std; class Student { private: string name; int age; public: // Parameterized Constructor Student(string n, int a) : name(n), age(a) { cout << "Parameterized Constructor Called" << endl; } // Copy Constructor Student(const Student& obj) : name(obj.name), age(obj.age) { cout << "Copy Constructor Called" << endl; } void display() { cout << "Name: " << name << ", Age: " << age << endl; } }; int main() { // Creating an object using the parameterized constructor Student originalStudent("John", 20); originalStudent.display(); // Creating a new object using the copy constructor Student copiedStudent = originalStudent; copiedStudent.display(); return 0; }
Name: John, Age: 20
Copy Constructor Called
Name: John, Age: 20
In the above example, the copy constructor takes a reference to an object of the same class (const ClassName& obj) as its parameter. It initializes the members of the new object with the values of the corresponding members of the existing object.
Dynamic Constructor.
In C++, a dynamic constructor is not a distinct type of constructor. Constructors are typically classified based on their parameters and use cases, such as default constructors, parameterized constructors, and copy constructors. However, there might be a misunderstanding or miscommunication about the term "dynamic constructor."
If you are referring to dynamic memory allocation within a constructor (e.g., using new), this is a common practice in C++ but doesn't give rise to a separate category of a constructor.
What is a Destructor in C++?
A destructor in C++ is a special member function of a class that is executed whenever an object of the class goes out of scope or is explicitly deleted. It is used to release resources or perform cleanup operations associated with the object before it is destroyed.
Syntax:
class ClassName { public: // Constructor(s) ClassName(); // Default constructor ClassName(parameters); // Parameterized constructor // Destructor ~ClassName(); };
Key points about Destructor:
- A destructor has the same name as the class but is prefixed with a tilde (~).
- Unlike constructors, which can be overloaded, a class can have only one destructor.
- The destructor is automatically invoked when an object goes out of scope or is explicitly deleted.
- It is used for releasing resources, closing files, releasing memory, or performing any cleanup necessary before the object is destroyed.
Example Code for Destructor in C++:
// C++ code implementation for Destructor #include <iostream> using namespace std; class MyClass { public: // Constructor MyClass() { std::cout << "Constructor Called" << std::endl; } // Destructor ~MyClass() { std::cout << "Destructor Called" << std::endl; } }; int main() { // Creating an object MyClass obj; // Object goes out of scope, destructor is called return 0; }
Constructor Called Destructor Called
Note: In the example, the destructor prints a message for demonstration purposes. In real-world scenarios, destructors are often used to deallocate memory, close files, or release other resources.(alert-passed)
(getButton) #text=(Access Specifiers in C++) #icon=(link) #color=(#2339bd)
