Constructor and Destructor in C++

By: Rajesh P.S.

Constructors and destructors are special member functions in C++ that are used to initialize and clean up objects of a class, respectively. They play a crucial role in object creation and lifetime management.

Constructors

Constructors are special member functions that are automatically called when an object of a class is created. They initialize the object's attributes, allocate resources, and perform any setup required for the object's proper functioning. Also, constructors have the same name as the class and do not have a return type. They can have parameters to accept initial values for attributes.

class Student { private: std::string name; int age; public: // Parameterized constructor Student(const std::string& n, int a) : name(n), age(a) { // Initialization code } // Default constructor (no parameters) Student() { name = "Unknown"; age = 0; } };

In this example, the Student class has both a parameterized constructor and a default constructor. The parameterized constructor takes the name and age as input and initializes the object's attributes accordingly. The default constructor sets default values if no arguments are provided during object creation.

Destructors

Continue Reading...

Destructors are also special member functions with a specific role: they clean up and release resources when an object goes out of scope or is explicitly deleted. Destructors have the same name as the class, preceded by a tilde (~), and do not have parameters or return values. They are automatically called when an object's lifetime ends, typically when it goes out of scope or when delete is used for dynamic memory allocation.

class DynamicArray { private: int* data; public: DynamicArray(int size) { data = new int[size]; } ~DynamicArray() { delete[] data; // Release dynamically allocated memory } };

In this example, the DynamicArray class allocates memory dynamically in its constructor. The destructor is responsible for releasing this memory using delete[] when an object of the class is destroyed.

Usage of Constructors and Destructors

Constructors and destructors are fundamental for proper object initialization and cleanup. They are automatically invoked, ensuring that objects are in a consistent state when created and that resources are released when they are no longer needed.

int main() { // Constructor is called when creating a Student object Student student1("Alice", 25); // Destructor is automatically called when student1 goes out of scope // Creating a DynamicArray object DynamicArray arr(10); // Destructor will be called when arr goes out of scope, releasing allocated memory }

Constructors and destructors are essential in C++ to manage the lifetime and resources associated with objects, contributing to the overall integrity and robustness of C++ programs.

Full Source

#include <iostream> #include <string> class Student { private: std::string name; int age; public: // Parameterized constructor Student(const std::string& n, int a) : name(n), age(a) { // Initialization code } // Default constructor (no parameters) Student() { name = "Unknown"; age = 0; } }; class DynamicArray { private: int* data; public: DynamicArray(int size) { data = new int[size]; } ~DynamicArray() { delete[] data; // Release dynamically allocated memory } }; int main() { // Constructor is called when creating a Student object Student student1("Alice", 25); // Destructor is automatically called when student1 goes out of scope // Creating a DynamicArray object DynamicArray arr(10); // Destructor will be called when arr goes out of scope, releasing allocated memory return 0; }

Types of Constructors in C++

There are several types of constructors, each serving a different purpose in object initialization. Here are the primary types of constructors with examples:

Default Constructor
Parameterized Constructor
Copy Constructor
Initializer List Constructor
Copy Assignment Operator

Default Constructor

A default constructor is one that takes no arguments and is automatically provided by the compiler if no constructors are defined in a class. It initializes the attributes to default values or leaves them uninitialized.

class MyClass { public: // Default constructor is automatically generated if not defined };

Parameterized Constructor

A parameterized constructor accepts one or more arguments and initializes the object's attributes with the provided values.

class Student { private: std::string name; int age; public: // Parameterized constructor Student(const std::string& n, int a) : name(n), age(a) { // Initialization code } };

Copy Constructor

A copy constructor is used to create a new object as a copy of an existing object of the same class. It is automatically generated by the compiler if not explicitly defined and performs a shallow copy of the attributes.

class Point { private: int x, y; public: // Copy constructor Point(const Point& other) : x(other.x), y(other.y) { // Copy initialization code } };

Initializer List Constructor

An initializer list constructor is a type of parameterized constructor that uses an initializer list to initialize attributes. It can improve performance and is particularly useful for complex object initialization.

class Rectangle { private: double length, width; public: // Initializer list constructor Rectangle(double l, double w) : length(l), width(w) { // Initialization code } };

Copy Assignment Operator

While not a constructor, the copy assignment operator (operator=) allows you to create a new object by assigning an existing object's value to it. It is used for object assignment.

MyClass obj1; MyClass obj2 = obj1; // Copy assignment, invoking the copy constructor or a user-defined one

These various types of constructors provide flexibility for initializing objects in C++ classes. Depending on the use case, you can define and utilize the appropriate constructor to ensure objects are properly initialized.

Difference between Constructor and Destructor in C++

The key difference between constructors and destructors lies in their respective roles during an object's lifecycle. Constructors initialize objects, ensuring they are in a valid state when created, while destructors clean up and release resources, ensuring that objects do not cause resource leaks when they are no longer in use. Constructors are called when objects are created, while destructors are automatically invoked when objects are destroyed or go out of scope. Together, these two functions provide a comprehensive mechanism for managing objects' lifecycle and resource management in C++ programs.

Conclusion

Constructors in C++ are special member functions that initialize objects of a class, and they can have parameters to set initial values. Destructors, also special member functions, clean up resources and perform cleanup operations when objects go out of scope or are explicitly deleted, ensuring proper resource management and memory deallocation.

Next > C++ Inheritance

Related Topics

More Related Topics.....