Constructors and Destructors in C++

Welcome to the world of C++, where we’ll explore constructors and destructors! Imagine you’re building a robot from scratch, giving it life through programming, and finally, when its purpose is served, disassembling it. In C++, constructors are like the magical builders that create and set up the object for use. On the other hand, destructors are like the cleanup group that ensures the object’s resources are released when it’s no longer needed. We’ll dive deep into constructors and destructors, understanding why they are essential and how they help us manage objects efficiently. Let’s get started!

Constructors And Destructors In C++

Introduction to Constructor and Destructor in C++

When we write programs, sometimes we need to set up initial values for the properties of objects and prepare some actions before using them. Properties are like variables stored in a class, which can be simple types (like numbers) or more complex ones (like other classes or pointers). The actions are functions that are defined within the class and are called member functions.

Think of it this way: imagine you’re creating a video game. Every time a new player joins the game, you want to set their starting position, health level, speed, and other things to default values.

You could create separate functions to set each of these values, but that can make the process long and complicated. What if you could automatically set all these values when you create a new player? This is where constructors come in handy. A constructor is like a setup function that runs automatically when you create a new player, making things simpler and more organized.

Similarly, when a player leaves the game, you need to clean up any resources they were using. This cleanup process can be done using a destructor, which ensures that memory and resources are properly released when they’re no longer needed. This way, your program stays efficient and avoids memory leaks.

What Are Constructors in C++?

Constructors in C++ are special member functions that are automatically called when an object of a class is created. Their primary purpose is to initialize the object’s data members or properties. Constructors ensure that an object starts with valid and meaningful values, avoiding any unexpected behavior due to uninitialized data.

Here are some key points about constructors:

  • Constructors have the same name as the class they belong to.
  • They don’t have a return type, not even void.
  • They can be overloaded, meaning a class can have multiple constructors with different parameters.
  • If a class doesn’t have a constructor defined, C++ provides a default constructor that does nothing.

The syntax of a constructor is:

C++
class ClassName {
public:
    ClassName() {
        // Constructor code here
    }
};

Code example of a class Person with a constructor:

C++
#include <iostream>
using namespace std;

class Person {
public:
    string name;

    // Constructor
    Person() {
        cout << "A new person object is created!" << endl;
    }
};

int main() {
    Person person1; // Creating an object of Person
    person1.name = "Alice";

    return 0;
}

Output:

C++
A new person object is created!

Explanation:

  • Creating an object (person1) of the class (Person) triggers the constructor automatically.
  • The constructor (Person()) initializes the object.
  • The console displays the message “A new person object is created!”.
  • Constructors ensure objects have valid initial values.
  • This maintains object integrity for further actions.

What Are Destructors in C++?

In C++, a destructor is a special member function within a class that is used to clean up resources or perform tasks before an object of that class is destroyed or goes out of scope. Destructors are the counterpart to constructors, which initialize objects when they are created. They play a crucial role in managing memory and resources effectively, preventing memory leaks and other issues.

Destructors are automatically called when an object is about to be deleted or when it goes out of scope. They are used to release any dynamically allocated memory, close files, release system resources, or perform any other cleanup tasks that are necessary to maintain the integrity of the program.

Syntax of a Destructor:

A destructor is defined using the tilde (~) followed by the class name. It has the same name as the class and is preceded by the keyword virtual if the class is intended to be a base class.

C++
class ClassName {
    // class members and methods

    public:
        // Constructor
        ClassName();

        // Destructor
        ~ClassName();
};

Code Example:

C++
#include <iostream>
using namespace std;

class MyResource {
public:
    MyResource() {
        cout << "Resource acquired!" << endl;
    }

    ~MyResource() {
        cout << "Resource released!" << endl;
    }
};

int main() {
    MyResource obj; // Object created
    // Code block
    return 0; // Object goes out of scope, destructor is called
}

Output:

C++
Resource acquired!
Resource released!

Explanation:

  • In the example, when the ‘obj‘ object is created within the ‘main()‘ function, the constructor is automatically called.
  • The constructor displays “Resource acquired!” indicating the acquisition of a resource or initialization.
  • As the ‘main()‘ function concludes and the object ‘obj‘ goes out of scope, the destructor is automatically triggered.
  • The destructor displays “Resource released!” indicating the cleanup or deallocation of the acquired resource.
  • This process highlights how destructors are automatically invoked when an object’s usage ends.
  • Destructors play a key role in effective resource management and memory cleanup in C++ programs.

Characteristics of Constructors and Destructors in C++

Constructors:

Constructors are special functions in C++ that are automatically called when an object of a class is created. Their purpose is to initialize the object’s attributes or set up any necessary resources. Key characteristics include:

  • Same Name as Class: Constructors have the same name as the class they belong to.
  • No Return Type: Constructors do not have a return type, not even void.
  • Automatic Invocation: Constructors are automatically invoked when an object is created.
  • Overloading: Multiple constructors with different parameters can exist in a class, allowing for various ways of object initialization.
  • Initialization: They are used to initialize data members of the object.
  • Default Constructor: If no constructor is defined in a class, a default constructor is provided by the compiler.

Destructors:

Destructors are also special functions in C++, called when an object’s lifecycle ends, such as when it goes out of scope or is explicitly deleted. Their main role is to release any resources acquired by the object. Key characteristics include:

  • Same Name with Tilde: Destructors have the same name as the class, preceded by a tilde (~).
  • No Parameters: Destructors do not take any parameters.
  • Automatic Invocation: Destructors are automatically invoked when an object’s scope ends or it’s explicitly deleted.
  • Cleanup: They are used to clean up resources, like releasing memory, closing files, etc.
  • No Overloading: Unlike constructors, there’s only one destructor per class.
  • No Return Type: Destructors also do not have a return type.

Types of Constructors in C++.

Constructors in C++ are special member functions that are used to initialize objects of a class. They are called when an object is created to set initial values or perform necessary tasks. There are several types of constructors:

  • Default Constructor: This constructor doesn’t take any arguments and is automatically called when an object is created without any parameters. It provides default values to the object’s attributes.
  • Parameterized Constructor: These constructors accept parameters when creating an object. They allow you to initialize object attributes with specific values based on the provided parameters.
  • Copy Constructor: This constructor is used to create a new object as a copy of an existing object. It helps in creating a duplicate of an object with the same attributes and values.
  • Constructor Overloading: Similar to function overloading, you can have multiple constructors with different parameter lists. This allows you to create objects in various ways, using different sets of parameters.
  • Conversion Constructor: This type of constructor allows automatic type conversion of one data type to another. It’s used to convert other data types to objects of the class.
  • Explicit Constructor: By using the ‘explicit‘ keyword, you can prevent unintentional implicit conversions caused by constructor overloads that take a single argument.
  • Virtual Constructor: In C++, there’s no direct support for virtual constructors like other methods. However, techniques involving Factory Design Patterns can simulate similar behavior.

Types of Destructors in C++.

In C++, there are primarily two types of destructors: Default Destructors and User-Defined Destructors.

  • Default Destructors:
    Default destructors are provided by the compiler when you don’t define your own destructor in a class. They don’t have any specific implementation and are responsible for releasing any resources allocated to objects of the class. These default destructors are invoked automatically when an object goes out of scope or is explicitly deleted.
  • User-Defined Destructors:
    User-defined destructors are those that you define in your class to perform specific cleanup tasks when an object is destroyed. You might need to define your own destructor when your class manages resources like memory or files. This allows you to release those resources properly when an object’s life ends. User-defined destructors are particularly useful when dynamic memory allocation is involved using new or malloc.

Here’s a code example of a user-defined destructor:

C++
#include <iostream>
using namespace std;

class MyClass {
public:
    // Constructor
    MyClass() {
        cout << "Constructor called" << endl;
    }

    // Destructor
    ~MyClass() {
        cout << "Destructor called" << endl;
    }
};

int main() {
    MyClass obj; // Creating an object
    return 0;
}

Output:

C++
Constructor called
Destructor called

Explanation:

User-Defined Destructors in C++:

  • When an object’s scope ends, the user-defined destructor is automatically invoked.
  • It’s a special function in a class used for cleanup tasks when an object is destroyed.
  • Helps release resources, like memory or files, associated with the object.
  • Useful for managing dynamic memory allocation and proper resource cleanup.
  • Demonstrates how destructors contribute to better resource management in classes.

Difference Between Constructors and Destructors

AspectConstructorsDestructors
PurposeInitialize an object’s data membersCleanup resources held by an object
InvocationAutomatically called when an object isAutomatically called when an object goes out of scope
createdor is explicitly deleted
NameSame as class nameSame as class name, prefixed with a tilde (~)
Return TypeNo return typeNo return type
ParametersCan take parameters to initialize dataTypically no parameters
members
OverloadingCan be overloaded to have differentCannot be overloaded
parameter lists
Use CasesSet initial values of object’s propertiesRelease resources like memory, files, etc.
Explicit CallingCan be explicitly called if requiredCannot be explicitly called
Difference Between Constructors and Destructors

A Problem to Solve

Problem Statement:

You’ve been tasked with developing a simple Book class for a digital library system. Each book has a title, an author, and a unique identification number (ID). The library system should keep a count of how many books are currently loaded in memory (i.e., how many book objects are created).

Requirements:

  • The ‘Book‘ class should have private attributes for the title, author, and ID.
  • The ‘Book‘ class should have a static integer attribute that keeps track of how many books are loaded into memory.
  • There should be a constructor that initializes a book with a title, author, and ID. Every time a book is created, the count of books loaded into memory should increase by one.
  • There should be a destructor that decrements the book count every time a book object is destroyed.
  • Include public member functions to get and display the details of the book and the current count of books loaded in memory.

Your task: Implement the Book class with the mentioned requirements and write a main function to test the behavior of the class.

Hints:

  • Use a static member function to display the current count of books in memory as it’s related to a static attribute.
  • Remember that the destructor will be automatically called when an object goes out of scope or is explicitly deleted.

Expected Output:

When testing the class in the main function, the program should be able to display individual book details and show the number of books currently loaded in memory. The count should increase when new books are created and decrease when they’re destroyed.

Examples of Using Constructors and Destructors in C++

Example 1

C++
#include<iostream>
using namespace std;

class Robot {
public:
    // Constructor
    Robot() {
        cout << "Robot created!" << endl;
    }

    // Destructor
    ~Robot() {
        cout << "Robot destroyed!" << endl;
    }
};

int main() {
    Robot r;
    return 0;
}

Output:

C++
Robot created!
Robot destroyed!

Explanation:

  • Constructor and destructor are special member functions in object-oriented programming languages.
  • The constructor is called when an object is created, and it initializes the object’s data members.
  • In this example, a Robot object is created using a constructor.
  • The constructor for the Robot object is executed, setting up its initial state and allocating any necessary resources.
  • The destructor is a special member function that is automatically called when an object goes out of scope or is explicitly destroyed.
  • In this example, the destructor is called when the Robot object ‘r’ goes out of scope.
  • The destructor releases any resources that were acquired by the object during its lifetime, such as memory or file handles.
  • Using constructors and destructors helps ensure proper initialization and cleanup of objects, improving code reliability and maintainability.

Example 2

C++
#include<iostream>
using namespace std;

class Robot {
public:
    string name;

    // Constructor
    Robot(string n) {
        name = n;
        cout << name << " created!" << endl;
    }

    // Destructor
    ~Robot() {
        cout << name << " destroyed!" << endl;
    }
};

int main() {
    Robot r1("Robo1");
    Robot r2("Robo2");
    return 0;
}

Output:

C++
Robo1 created!
Robo2 created!
Robo2 destroyed!
Robo1 destroyed!

Explanation:

  • Constructors with parameters allow us to create objects with different initial values or characteristics.
  • In this example, a constructor with a parameter is used to create Robot objects with different names.
  • The constructor takes a name as a parameter and sets the name of the Robot object being created.
  • By providing different names as arguments to the constructor, we can create multiple Robot objects with unique names.
  • The destructor is still called for each Robot object when they go out of scope, regardless of their individual names.
  • The destructor performs cleanup tasks specific to each object, such as releasing resources associated with the object.
  • Using a constructor with a parameter enables customization and flexibility in creating objects, while the destructor ensures proper cleanup for each object.

Example 3

C++
#include<iostream>
using namespace std;

class Robot {
public:
    string name;

    // Constructor
    Robot(string n) {
        name = n;
        cout << name << " created!" << endl;
    }

    // Destructor
    ~Robot() {
        cout << name << " destroyed!" << endl;
    }
};

void createRobot() {
    Robot r("TemporaryRobo");
}

int main() {
    createRobot();
    return 0;
}

Output:

C++
TemporaryRobo created!
TemporaryRobo destroyed!

Explanation:

  • This example demonstrates the creation of a Robot object inside a function.
  • The object is created locally within the function’s scope.
  • The destructor for the Robot object is automatically called when the object goes out of scope.
  • In this case, the object goes out of scope when the function ends.
  • The destructor performs any necessary cleanup for the object, such as releasing resources or deallocating memory.
  • Creating objects inside functions allows for local and temporary usage of objects.
  • The automatic invocation of the destructor ensures that resources associated with the object are properly released, promoting efficient memory management.

The Pros and Cons of Using Constructors and Destructors

Pros of ConstructorsCons of Constructors
Simplify object creationCan be complex to implement
Ensure proper initialization of object propertiesThis may lead to unnecessary overhead
Provide default values for object propertiesCan’t be overloaded with different parameter lists
Support inheritance and derived classesCan’t return values or have a return type
Improve code readability and organizationMay require extra effort to handle exceptions
The Pros and Cons of Constructors
Pros of DestructorsCons of Destructors
Automatically release resourcesNot suitable for managing external resources
Ensure proper cleanup and memory deallocationCan’t be overloaded with different parameter lists
Support inheritance and derived classesCan’t return values or have a return type
Improve code readability and organizationCan’t be called explicitly, only called when the object is destroyed
Help prevent memory leaks and resource wastageCan’t handle exceptions directly
The Pros and Cons of Destructors

Key Takeaways

  • Constructors and destructors are special member functions in C++.
  • They are used to manage resources efficiently in C++ programs.
  • Constructors are called when an object is created, allowing the initialization of its data members.
  • Destructors are called when an object is destroyed or goes out of scope, facilitating cleanup tasks.
  • Proper usage of constructors and destructors can improve program efficiency and resource management.
  • Constructors ensure objects are properly initialized, avoiding undefined behavior.
  • Destructors release resources held by objects, preventing memory leaks and other resource-related issues.
  • Understanding how to use constructors and destructors enables you to write better, more efficient programs.
  • By appropriately utilizing these special member functions, you can enhance program reliability and maintainability.

Conclusion

In summary, constructors and destructors in C++ play important roles in creating and managing objects. Learning their usage improves your ability to develop efficient and well-structured programs. With practice, you’ll gain mastery over these tools, enabling you to build more sophisticated and reliable software. Embrace the learning process, and you’ll soon become adept at harnessing the capabilities of constructors and destructors to create high-quality code.

FAQs

  • What are constructors in C++?
    Constructors in C++ are special member functions that are automatically called when an object of a class is created. They help us initialize the object.
  • What are destructors in C++?
    Destructors in C++ are special member functions that are automatically called when an object is destroyed or goes out of scope. They help us clean up and free the resources that were allocated to the object.
  • Why do we use constructors and destructors in C++?
    We use constructors and destructors in C++ to manage resources efficiently. Constructors allow us to initialize an object’s data members when the object is created, and destructors allow us to clean up and free the resources that were allocated to the object when it is destroyed or goes out of scope.
  • Can using constructors and destructors make code more confusing?
    Yes, if you use constructors and destructors incorrectly, it can lead to problems like memory leaks. It’s important to understand how constructors and destructors work and when to use them.
  • What are some examples of using constructors and destructors in C++?
    Some examples include using constructors to initialize an object’s data members when the object is created and using destructors to clean up and free the resources that were allocated to the object when it is destroyed or goes out of scope.
Avatar Of Deepak Vishwakarma
Deepak Vishwakarma

Founder

RELATED Articles

Leave a Comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.