Dynamic Initialization Using Constructors

In C++, Dynamic initialization is the process of initializing variables or objects at runtime

Where constructors play an important role in object creation and can be used to initialize
both static and dynamic data members of a class.

While creating an object, its constructor is called and if the constructor contains logic to
initialize the data members with values, is known as dynamic initialization. This is helpful
because here the value is calculated, retrieved, or determined during runtime, which is
more flexible than static initialization.

Syntax

Here is the following syntax for dynamic initialization using constructors.

ClassName* objectName = new ClassName(constructor_arguments);

Here, ClassName is the class type.

objectName is the pointer to the object.

constructor_arguments are the arguments passed to the constructor.

Example of Dynamic Initialization Using Constructors

Here is the following example of dynamic initialization using constructors.

Open Compiler

#include <iostream>

using namespace std;

class Rectangle {

public:

int width, height;

// Constructor to initialize width and height

Rectangle(int w, int h) : width(w), height(h) {}

void display() {

cout << "Width: " << width << ", Height: " << height << endl;
 }

};

int main() {

// Dynamically creating a Rectangle object using the constructor

Rectangle* rect = new Rectangle(10, 5);

// Display the values

rect->display();

// Deallocate memory

delete rect;

return 0;

Output

Width: 10, Height: 5

Explanation

 The new Rectangle(10, 5) dynamically created a Rectangle object having width 10

 This rect->display() is displaying the rectangle's dimensions.

 The delete rect; deallocates the memory used by the Rectangle object.

Why Use Constructors for Dynamic Initialization?

 Allows initialization with values known only at runtime.

 Simplifies object creation and initialization logic.

 Combines initialization and validation in a single step.

Using a constructor to initialize dynamically within C++ makes it so much easier to create
an object where the values get determined only at runtime. Encapsulation of initialization
logic within the constructor makes the code clean, efficient, and more maintainable; use it
whenever object initialization depends upon runtime data.

Dynamic constructors in C++ are constructors that are dynamically allocated on the heap
using the new operator. This allows you to create objects at runtime, rather than at
compile time.

Why Use Dynamic Constructors?

 Flexibility: Dynamic constructors provide flexibility in object creation, allowing you

 Memory Management: You have more control over memory allocation and
deallocation, which can be crucial for performance-critical applications.

 Polymorphism: Dynamic constructors are essential for creating objects of derived

Creating Dynamic Objects

To create a dynamic object, you use the new operator followed by the class name. This
allocates memory on the heap for the object and returns a pointer to it.

Example:

#include <iostream>

using namespace std;

class MyClass {

public:

int data;

MyClass(int value) {

data = value;

}
};

int main() {

MyClass* obj = new MyClass(10);

cout << "Data: " << obj->data << endl;

delete obj;

return 0;

Output:

Data: 10

Deleting Dynamic Objects

When you're finished with a dynamic object, you must delete it using the delete operator
to free the memory allocated for it. Failure to do so can lead to memory leaks.

Array of Dynamic Objects

You can also create arrays of dynamic objects using the new operator.

Example:

#include <iostream>

using namespace std;

class MyClass {

public:
 int data;

MyClass(int value) {

data = value;

};

int main() {

MyClass* arr = new MyClass[5];

for (int i = 0; i < 5; i++) {

arr[i].data = i + 1;

for (int i = 0; i < 5; i++) {

cout << "Data: " << arr[i].data << endl;

delete[] arr;

return 0;

Output:

Data: 1

Data: 2

Data: 3

Data: 4

Data: 5
Key Points

 Dynamic constructors allow you to create objects at runtime using the

 You must delete dynamic objects using the delete operator to avoid memory leaks.

 You can create arrays of dynamic objects using the new operator.

What is Dynamic Constructor in C++?

The constructor which allocates a block of memory that can be accessed by the objects at
run time is known as Dynamic Constructor.

In simple terms, a Dynamic constructor is used to dynamically initialize the objects, that is
memory is allocated at run time.

To define a dynamic constructor in C++, the new keyword is used. New is a keyword in C++
that is used for the dynamic allocation of memory and is used for dynamically initializing
objects.

Example of Dynamic Constructor

Let us understand Dynamic constructors in C++ with the help of an example that consists
of class A.

We will dynamically allocate memory to the data members inside the default constructor
of class A as well as a parameterized constructor of class A and check the output.

#include <iostream>

using namespace std;

class A

int *value;

public:

A()//Default constructor

value = new int; //Memory allocation at run time

*value = 1729;

A(int p_value) //Parameterised constructor

value = new int; //Memory allocation at run time

*value= p_value+1;

void display()

cout<< *value <<endl;

~A()

delete value ;

};

int main()

A obj1, obj2(7225);

cout<<"The value of object obj1 is: ";

obj1.display();// Calling default constructor

cout<<"\nThe value of object 0bj2 is: ";

obj2.display();// calling parameterised constructor

return 0;

Output:

The value of object obj1 is: 1729

The value of object obj2 is: 7226

Explanation:

We created a dynamic memory within the constructor of a class by using the New
keyword.
This represents a Dynamic constructor in both the default as well as parameterized
constructor.

Here, the memory allocation is done at run time, that is the values are assigned as well as
the constructor is invoked at run time when the object is created.

Example Showing How a Dynamic Constructor Allocates Memory at Run Time

//C++ program to show dynamic constructor used in a class.

#include<iostream>

using namespace std;

class Blogs

const char* banner;

public:

// default constructor

Blogs()

// Using the 'New' keyword to dynamically allocate memory

banner = new char[15];

banner = "Welcome to Scaler Topics";

void display()

cout << banner;

};
int main()

Blogs obj1;

obj1.display();

Output:

Welcome to Scalar Topics

Explanation:

When we initialize the variable banner using New keyword, it invokes a dynamic
constructor thus allocating space in the memory at runtime.

Program to Create an Array of Objects Dynamically

Let us implement a program using C++ to create an array of objects dynamically.

#include <iostream>

using namespace std;

class scaler {

int* views_cnt;

public:

// default constructor

scaler()

// allocating memory at run time

// and initializing

views_cnt = new int[5]{ 1, 2, 3, 4, 5 };

for (int i = 0; i < 5; i++) {

cout << endl;

};

int main()

//creating an array of 5 objects

scaler* views_cnt = new scaler[5]; //dynamically allocating object

Output:

12345

12345

12345

12345

12345

Explanation:

We created an array of 5 objects that calls dynamic constructors individually and memory
is allocated for each object at run time.

Conclusion

 Dynamic Constructor is used to dynamically allocate memory to be accessed by

 Dynamic Constructor in C++ is declared using the keyword 'new'.

 Objects can also be dynamically initialized using the 'new' keyword.