Dynamic Constructors in C++: Implementation & Examples

In C++, constructors are special member functions invoked automatically when a class object is created. They are essential for initialising the object's data members. There are four primary types of constructors in C++

1. Default Constructor

A default constructor is a constructor that does not take any parameters and initialises an object with default values.

2. Parameterized Constructor

A parameterised constructor accepts one or more arguments to initialise an object with specific values, allowing for flexible object creation.

3. Copy Constructor

A copy constructor initialises a new object as a copy of an existing object of the same class, ensuring that the copied object's data members are appropriately initialised.

4. Move Constructor

A move constructor enables the efficient transfer of resources from one object to another without making a copy. This is particularly useful for managing dynamically allocated memory and optimising performance by avoiding unnecessary data copying.

Characteristics of Constructors

Here are the characteristics of constructors in C++:

• Constructor Name: The constructor's name should be the same as the class name.
• Access Modifiers: Constructors are typically public members of a class but may be private if needed.
• No Return Type: A constructor has no return type, not even void, since it is used to create an object instead of returning something.
• Automatic Invocation: A constructor is invoked automatically when an object of the class is created.
• Multiple Constructors: A class may have several constructors, a feature referred to as constructor overloading. This enables various means of object initialization. It is recommended to utilize multiple constructors as a part of the Rule of Three or Rule of Five to handle resources and initialize objects in the right manner.‍
• Constructor Selection: In case of several constructors, the one with arguments that can match the provided arguments at object creation is automatically selected.

When memory is allocated during a program's run using the `new` keyword in a constructor, it is called a dynamic constructor. This allows the program to create objects with sizes that are not known until the program is actually running. This means that the memory for the object's data members is allocated on the heap rather than on the stack, allowing for more flexible memory usage.

Syntax

class ClassName {
private:
    // Private members
public:
    // Dynamic constructor
    ClassName(/* parameters */) {
        // Initialization using new keyword
    }
    ~ClassName() {
        // Destructor to deallocate memory
    }
};

To implement dynamic constructors, you need to follow the below steps such as:

Step 1: To define a dynamic constructor, declare your class and its data members. Include pointers for any dynamically allocated memory.

#include <iostream>
using namespace std;

class MyClass {
private:
    int* data;
    int size;

public:
    MyClass(int s); // Dynamic constructor declaration
    ~MyClass(); // Destructor to free memory
    void display();
};

Step 2: Implement the dynamic constructor to allocate memory using new and initialise the object.

MyClass::MyClass(int s) {
    size = s;
    data = new int[size]; // Dynamically allocate memory
    for (int i = 0; i < size; i++) {
        data[i] = i + 1; // Initialize array elements
    }
}

Step 3: Always implement a destructor to free any dynamically allocated memory and prevent memory leaks.

MyClass::~MyClass() {
    delete[] data; // Deallocate memory
}

Here are the examples of dynamic constructors in C++:

1. Dynamic Memory Allocation Using Constructor

Code

#include <iostream>
using namespace std;

class DynamicArray {
private:
    int* arr;
    int size;

public:
    DynamicArray(int n) {
        size = n;
        arr = new int[size];  // Dynamically allocate memory
    }

    ~DynamicArray() {
        delete[] arr;  // Deallocate memory
    }

    void initializeArray() {
        for (int i = 0; i < size; i++) arr[i] = i + 1;
    }

    void displayArray() {
        for (int i = 0; i < size; i++) cout << arr[i] << " ";
        cout << endl;
    }
};

int main() {
    DynamicArray obj(5);
    obj.initializeArray();
    obj.displayArray();
}

Output

1 2 3 4 5

Explanation

• The constructor dynamically allocates memory for an array of integers using new, based on the size passed to it.
• The initializeArray() method initialises the array with values, and displayArray() prints the array elements.
• The destructor ensures that the dynamically allocated memory is deallocated using delete[] to avoid memory leaks.

2. Dynamic Constructor with Array of Objects

Code

#include <iostream>
using namespace std;

class Employee {
public:
    Employee(string name, int id) : name(name), id(id) {}
    void display() { cout << "ID: " << id << ", Name: " << name << endl; }

private:
    string name;
    int id;
};

class EmployeeList {
private:
    Employee** employees;
    int size;

public:
    EmployeeList(int n) {
        size = n;
        employees = new Employee*[size];
        for (int i = 0; i < size; i++) {
            employees[i] = new Employee("Employee_" + to_string(i+1), 1000 + i);
        }
    }

    ~EmployeeList() {
        for (int i = 0; i < size; i++) delete employees[i];
        delete[] employees;
    }

    void displayEmployees() {
        for (int i = 0; i < size; i++) employees[i]->display();
    }
};

int main() {
    EmployeeList list(3);
    list.displayEmployees();
}

Output

ID: 1000, Name: Employee_1
ID: 1001, Name: Employee_2
ID: 1002, Name: Employee_3

Explanation

• The constructor allocates memory for an array of pointers to Employee objects, then creates individual Employee objects dynamically.
• Each Employee object is initialised with a name (e.g., "Employee_1") and ID (e.g., 1000) in the constructor.
• The destructor deallocates memory for each Employee object and the array of pointers to avoid memory leaks.

3. Using Dynamic Constructor for 2D Arrays

Code

#include <iostream>
using namespace std;

class Matrix {
private:
    int** arr;
    int rows, cols;

public:
    Matrix(int r, int c) : rows(r), cols(c) {
        arr = new int*[rows];
        for (int i = 0; i < rows; i++) arr[i] = new int[cols];
    }

    ~Matrix() {
        for (int i = 0; i < rows; i++) delete[] arr[i];
        delete[] arr;
    }

    void initializeMatrix() {
        int val = 1;
        for (int i = 0; i < rows; i++)
            for (int j = 0; j < cols; j++) arr[i][j] = val++;
    }

    void displayMatrix() {
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) cout << arr[i][j] << " ";
            cout << endl;
        }
    }
};

int main() {
    Matrix m(3, 3);
    m.initializeMatrix();
    m.displayMatrix();
}

Output

1 2 3
4 5 6
7 8 9

Explanation

• The constructor dynamically allocates memory for a 2D array (array of arrays) using new for both rows and columns.
• The initializeMatrix() method fills the 2D array with sequential numbers, starting from 1.
• The destructor frees memory for each row and then the array of rows using delete[], ensuring proper cleanup

Here are the key benefits of using dynamic constructors:

• Resource Allocation Flexibility: Dynamic constructors allow developers to allocate resources as needed during runtime, optimising resource utilisation.
• Conditional Initialization: Objects can be initialised based on runtime parameters, providing greater flexibility than static initialisation.
• Dynamic Initialization: Objects can be initialised based on user inputs or other dynamic conditions, enhancing interactivity.
• Reduced Memory: By allocating memory only when necessary, applications can minimise overall usage.‍
• Exception Handling: Dynamic constructors facilitate robust error handling during initialisation, allowing developers to manage exceptions effectively.

Here are the best practices of dynamic constructors in c++:

• Keep Initialization Lightweight: Avoid heavy computations within constructors to maintain performance.
• Handle Initialization Errors: Implement error-handling mechanisms to manage potential issues during resource allocation.
• Minimise Dependency on External Factors: Reduce reliance on external conditions to enhance code reliability.
• Test Thoroughly: Conduct tests to ensure correct under various scenarios.
• Document Usage Guidelines: Document how dynamic constructors should be used within your codebase.

In conclusion, dynamic constructors in C++ provide a flexible mechanism for initialising objects with dynamically allocated memory at runtime. This feature allows developers to create more efficient and adaptable applications that respond to varying conditions and user inputs. Proper implementation ensures dynamic constructors enhance performance and maintainability in C++ programming.

1. What are objects created dynamically in C++?

• Dynamic objects are created during runtime using dynamic memory allocation (e.g., using new).
• These objects in the heap and their lifetime is managed manually (i.e., you need to delete them when done).

2. How is dynamic initialisation of objects achieved through constructors in C++?

Dynamic initialisation occurs when an object is created with parameters, often in the constructor.

Example: MyClass *obj = new MyClass(param1, param2);—the constructor runs with the passed parameters

3. What are the reasons for using dynamic memory allocation in C++?

• Dynamic allocation allows the creation of objects of unknown size at runtime.
• It helps manage memory when you don't know how many objects you need until the program runs.
• Memory can be freed explicitly using the delete

4. What is meant by dynamic type in C++?

Dynamic type refers to the actual type of an object at runtime, especially with polymorphism.

For example, a base class pointer can point to derived class objects, and the dynamic type determines which method to call at runtime.