Dynamic Memory Allocation In C++ Explained In Detail (With Examples)

0 min read

In C++, dynamic memory allocation enables your programs to request and release memory at runtime—a powerful feature when working with unknown or large data sizes. Unlike fixed-size (stack or static) memory, dynamic memory allocation in C++ programming is managed manually using the new and delete operators (or smart pointers in modern C++).

Mastering these techniques is essential not only for writing efficient, flexible C++ code but also for avoiding issues like memory leaks, fragmentation, and undefined behavior. In this article, we will discuss what dynamic memory allocation is, when, why, and how to allocate and free memory correctly in C++, and more.

What is Memory Allocation in C++ & Why Do We Need It?

Memory allocation refers to reserving a portion (partial or entire part) of the computer’s/system memory space to store variables or data structures during program execution. The process of memory allocation and dellocation end-to-end is referred to as memory management.

C++ offers two types of memory allocation: static memory and dynamic memory.

1. Static / Automatic (Stack) Allocation

• Compiler-managed at compile time (i.e., memory is allotted and deallocated by the compiler on its very own.)
• Stores local variables and fixed-size data within function scopes.
• Fast, but limited: size must be known ahead of time, and memory is automatically released when the scope ends.
• Stack is miles of permanent space allotted through the operating system, which speeds up the time of execution of a program.

2. Dynamic (Heap) Allocation

• Manually managed using new/delete (or malloc/free in C). In other words, the allocation and deallocation of memory happen at runtime.
• Useful for:
• Data whose size isn’t known until runtime (e.g., user input).
• Long-lived data that must outlive the function that created it.
• Large objects or arrays that could exceed stack space.
• Requires explicit memory management—forgetting to free memory can lead to memory leaks; freeing it too early can cause crashes.

Memory Structure in C++ (Simplified)

A typical C++ program’s memory is split into:

• Code/Text segment– Stores executable instructions.
• Data segment– Holds global/static variables.
• Heap (Free Store)– Used for dynamic memory via new/delete.
• Stack– Used for local variables and function calls.

Understanding how the heap and stack grow in opposite directions helps explain issues like fragmentation, stack overflow, and why newly allocated data stays valid beyond its function scope.

Want a detailed view of each section, memory addresses, and real-world diagrams? Read: Memory Layout in C.

How Does Dynamic Memory Allocation Work?

Dynamic memory allocation in C++ follows a predictable flow:

1. Request space using new or new[]:

int* p = new int(5);
int* arr = new int[10];

2. Use the memory via the pointer (*p, arr[i]).

3. Release memory using the matching delete:

delete p;
delete[] arr;      

4. Handle failure: By default, new throws std::bad_alloc. Consider using new (std::nothrow) to get a nullptr on failure instead.

Why Use Dynamic Memory Allocation?

• Flexibility: Handle dynamic or arbitrary data sizes (e.g., lists, trees, graphs, multimedia).
• Longevity: Maintain data beyond the local scope where it was created.
• Manage large data: Avoid stack overflow; heap can allocate much larger blocks.

In essence, dynamic memory gives you control and adaptability, at the cost of more responsibility. That’s where smart techniques (like RAII and smart pointers) come in, which we’ll cover later.

Difference Between Dynamic Allocation & Memory Allocated to Normal Variables?

In the case of static memory allocation for variables and arrays, the syntax is as follows:

int r;
double arr[10];
char name[20];

In this kind of memory allocation, the operating system automatically allocates the memory at compile time and deallocates it when the program, block, or function finishes.

In comparison, in the case of dynamic memory allocation in cpp, the programmer must first create the dynamic space in the heap memory. Here, heap memory refers to the unused memory space available for dynamic allocation for a program at runtime. They then allocate and deallocate the memory. This is how the memory is dynamically allocated in C++, for variables and arrays, and an example of this is-

int* ptr = new int;
int* arr = new int[6];

Dynamically allocated memory will continue to be in use until the whole code or program terminates. So, a programmer needs to deallocate the memory when it is no longer required. The need for this arises because memory leaks can occur when a programmer fails to deallocate dynamically allocated memory.

Also read- History Of C++ | Detailed Explanation (With Timeline Infographic)

The new Operator in C++

The new operator is a unary operator used to dynamically allocate a block of memory and keep its address in a pointer variable at some point during the execution of a program. In other words, this operator is like a request for memory allocation on the heap memory (or the free store). And if sufficient memory is available, the dynamic space is initialized to the newly created variable or pointer.

Syntax to use the new operator for dynamic memory allocation in C++:

pointer_variable = new data_type;

Here, pointer_variable indicates the pointer of type data_type. The new operator thus allocates a block of memory to type data_type. Note that the data_type here could either be any built-in data type (like an array) or a user-defined data type (like class, or structure).

Let's take a look at an example C++ program illustrating the use of the new operator for allocation of memory to a variable at runtime. 

Code Example:

            #include
using namespace std;

int main(){

int* Var;
Var = new int;
*Var = 50;

cout<<*Var;
}
          

I2luY2x1ZGU8aW9zdHJlYW0+CnVzaW5nIG5hbWVzcGFjZSBzdGQ7CgppbnQgbWFpbigpewoKaW50KiBWYXI7ClZhciA9IG5ldyBpbnQ7CipWYXIgPSA1MDsKCmNvdXQ8PCpWYXI7Cn0=

Output:

50

Explanation

Here we have dynamically allocated a block of memory using the new operator for the int variable. Within this, we have allocated the memory in the heap by using the Var pointer. The new operator returns the address of the memory location.

In the case of an array, the new operator returns the address of the first element of the array. From the above example, we can see the syntax for using the new operator.

What happens when there isn't enough space for the allocation of memory? 

The new keyword in C++ will throw an exception of type std::bad_alloc when there is insufficient memory available for dynamic memory allocation. The program segment won't receive a valid pointer to the requested memory block, and as a result, the block of memory fails to allocate, as indicated by this signal. In this case, the program should be terminated, or the user should see an error message if developers notice this exception and handle the failure event appropriately.

You might also be interested in reading- Strings In C++ | Functions, How To Convert & More (With Examples)

The delete Operator in C++

What happens once we do not need the variable that we've declared dynamically? Well, we must deallocate the space in memory occupied by means of the variable.

For this, we use the delete operator and deallocate the block of memory that was dynamically allocated with the use of the new operator. In view of that, a programmer must de-allocate a block of memory as soon as it is no longer required within the program or code, or it will lead to memory leaks. So, we need to use the delete operator to avoid memory leaks.

Syntax to apply the delete operator:

delete pointer_variable;

So every time you want to use the delet operator to say deallocate memory allocated to a variable by the name Var, then you must use the following line of code:

delete Var;

Code Example:

            #include
using namespace std;

int main(){

int* Var;
Var = new int;

*Var = 50;
cout<<*Var;

delete Var;
}
          

I2luY2x1ZGU8aW9zdHJlYW0+CnVzaW5nIG5hbWVzcGFjZSBzdGQ7CgppbnQgbWFpbigpewoKaW50KiBWYXI7ClZhciA9IG5ldyBpbnQ7CgoqVmFyID0gNTA7CmNvdXQ8PCpWYXI7CgpkZWxldGUgVmFyOwp9

Explanation:

As you can see in the code above, we have dynamically allocated the memory for the int variable by using the Var pointer. So, after printing the contents of Var, we free the memory with the delete operator.

Dynamic Memory Allocation in C++ | Arrays

Generally, we aren't sure of the exact size/ length of an array till runtime. And this is where dynamic memory allocation makes memory management extra efficient. Say you want to allocate memory for an array of integers, that is, an array of n integers. The syntax and example for getting this done are given below:

Syntax:

pointer_variable = new data_type[size];

Example:

str = new int[n]

This was the syntax for normal arrays, now let's look at the syntax for multidimensional arrays. Note that in the syntax and example, we use the square brackets after the data_type to indicate that we are dynamically allocating for an array.

Syntax for a multidimensional array of length m x n:

pointer_variable = new data_type[size][size];

Example

var = new int [m][n];

While the syntax to allocate the memory is different for a single element/ single dimension array and a multi-dimensional array, it remains the same for the deallocation process.

Syntax:

delete []pointer_variable ;

Example:

delete []var; // Delete array pointed to by means of var

Let's take a look at a C++ program illustrating the use of the new operator to create and initialize dynamically allocated arrays.

Code Example:

            #include 
using namespace std;

int main(void) {
int num;

int *array{ new int[6]{ 1,2,3,4,5,6} };
cout << "Array elements: " << endl;

for (num = 0; num < 6; num++) {
cout << array[num] << endl;
}

return 0;
}
          

I2luY2x1ZGUgPGlvc3RyZWFtPgp1c2luZyBuYW1lc3BhY2Ugc3RkOwoKaW50IG1haW4odm9pZCkgewppbnQgbnVtOwoKaW50ICphcnJheXsgbmV3IGludFs2XXsgMSwyLDMsNCw1LDZ9IH07CmNvdXQgPDwgIkFycmF5IGVsZW1lbnRzOiAiIDw8IGVuZGw7Cgpmb3IgKG51bSA9IDA7IG51bSA8IDY7IG51bSsrKSB7CmNvdXQgPDwgYXJyYXlbbnVtXSA8PCBlbmRsOwp9CgpyZXR1cm4gMDsKfQ==

Output:

Array elements:
1
2
3
4
5
6

Explanation:

1. We first include the iostream header file in our program.
2. Include the std namespace in our program so you can use its classes without calling it.
3. Call the main() function. The program logic should be added to the function body.
4. Declare an integer variable named x.
5. Declare a dynamic array with an array name using an initializer list. This integer array will contain 5 integer elements. Note that we didn't use the "=" operator between the field length and the initializer list.
6. Print some text to the console. Endl is a C++ keyword that means the end of the line and it brings the cursor to the next sentence.
7. Use a for loop to iterate over the elements of an array.
8. Print the contents of the field named field to the console.
9. End of the for loop.
10. The program must return a value.
11. End of the main() function body.

Now let's look at an example that shows how to deallocate memory to arrays in C++.

Code Example:

            #include 
using namespace std;

int main() {

int length;
cin >> length;

int * array= new int[length];

for (int i = 0; i < length; i++) {
array[i] = (i + 1) * 10;
}

for (int i = 0; i < length; i++) {
cout << array[i] << " " << endl;
}

delete[] array;
return 0;
}
          

I2luY2x1ZGUgPGlvc3RyZWFtPgp1c2luZyBuYW1lc3BhY2Ugc3RkOwoKaW50IG1haW4oKSB7CgppbnQgbGVuZ3RoOwpjaW4gPj4gbGVuZ3RoOwoKaW50ICogYXJyYXk9IG5ldyBpbnRbbGVuZ3RoXTsKCmZvciAoaW50IGkgPSAwOyBpIDwgbGVuZ3RoOyBpKyspIHsKYXJyYXlbaV0gPSAoaSArIDEpICogMTA7Cn0KCmZvciAoaW50IGkgPSAwOyBpIDwgbGVuZ3RoOyBpKyspIHsKY291dCA8PCBhcnJheVtpXSA8PCAiICIgPDwgZW5kbDsKfQoKZGVsZXRlW10gYXJyYXk7CnJldHVybiAwOwp9

Output:

3
10
20
30

Explanation:

An array of integers is created by this C++ program, and each element is printed out. Prior to creating the array, we use the new operator and assign the array pointer to a variable. It first reads the length of the array from standard input. The array is then filled with values that are multiples of 10, rising by 10 for each entry starting at 10. Finally, we use the pointer notation and for loop to print out each element of the array. Then the delete[] operator is used to deallocate the memory that the array was occupying.

Check this out- Boosting Career Opportunities For Engineers Through E-School Competitions

Did You Know: Companies That Ask About Dynamic Memory Allocation

Many tech firms use questions on dynamic memory allocation to assess both your technical knowledge and practical understanding of memory management. Here are some examples:

• Wipro (Project Engineer & Software Developer roles) frequently asks:

  “Explain static vs dynamic allocation, and compare malloc, calloc, and free.”

• Infosys tests candidates on memory types:

  “Can you differentiate between static, stack, and heap memory in C++?”

• Roles in embedded systems (e.g. Bosch, RTOS teams) often dive deeper:

  “Can you implement a basic dynamic allocator (malloc) and discuss fragmentation, thread safety, or using memory pools?”

• On C++ developer interviews, questions like “When do you check new failure?”, “What is fragmentation?”, and “What patterns/ tools do you use to detect leaks?” are common

Dynamic Memory Allocation in C++ | Objects

It is also possible to dynamically allocate memory to objects. To begin with, the default constructor function initializes the object of class. And once the job is done, a default destructor function which is also a class member function deallocates the memory.  Let us look at an example wherein we are going to use an array of objects to make the concept clear.

Code Example:

            # include
using namespace std;

class tests {
public:
tests() {
cout<<"hello"<<endl;
}

~tests(){
cout<<"hey"<<endl;
}
};

int main() {
tests*t = new tests[3];

delete [] t;
return 0;
}
          

IyBpbmNsdWRlPGlvc3RyZWFtPgp1c2luZyBuYW1lc3BhY2Ugc3RkOwoKY2xhc3MgdGVzdHMgewpwdWJsaWM6CnRlc3RzKCkgewpjb3V0PDwiaGVsbG8iPDxlbmRsOwp9Cgp+dGVzdHMoKXsKY291dDw8ImhleSI8PGVuZGw7Cn0KfTsKCmludCBtYWluKCkgewp0ZXN0cyp0ID0gbmV3IHRlc3RzWzNdOwoKZGVsZXRlIFtdIHQ7CnJldHVybiAwOwp9

Output:

hello
hello
hello
hey
hey
hey

Explanation:

Observe that given that we allotted an array of three test objects, the default constructor is called on thrice. In addition, while freeing these objects, the destructor is also called on three times.

Deallocation of Dynamic Memory in C++

Deallocation of memory may be carried out with the use of delete operators. The delete operator is used to deallocate, that is, it releases the memory which is turned into allotted through the new operator via its pointer ptr. The memory is then released in order that it can be used by a few different objects and no memory leak can arise.

Syntax

delete pointer_variable;

Code Example:

            #include
using namespace std;

int main(){
int* Var;

Var = new int;
*Var = 50;
cout<<*Var;

delete Var;
}
          

I2luY2x1ZGU8aW9zdHJlYW0+CnVzaW5nIG5hbWVzcGFjZSBzdGQ7CgppbnQgbWFpbigpewppbnQqIFZhcjsKClZhciA9IG5ldyBpbnQ7CipWYXIgPSA1MDsKY291dDw8KlZhcjsKCmRlbGV0ZSBWYXI7Cn0=

Explanation:

Here we use the Var pointer for the dynamic allocation of memory blocks, for the int variable. Then after printing the contents of Var, we free/ de-allocate memory blocks with the delete operator. 

malloc(), calloc(), and free() Functions in C/C++

In C and C++, dynamic memory allocation can also be handled using C standard library functions: malloc(), calloc(), and free(). These functions are defined in the <cstdlib> or <stdlib.h> header.

Why prefer new and delete in C++?

Applications of Dynamic Memory Allocation in C++

Using dynamically allocated memory is to allocate memory of variable length, which is not possible with compiler-allocated memory besides for variable-duration arrays.

1. The amount of freedom and liberty programmers get with a dynamic allocation is one of the important uses. It makes it possible for users to allocate and deallocate memory as and when they need to.
2. Dynamic memory allocation in C++ is also possible with the help of C standard library functions malloc() and calloc(), and deallocation with functions loose() and unfastened(). This can have its own benefits. 
3. Since dynamic memory allocation happens at runtime, it makes it possible to efficiently allocate memory even when we don't know the variable size in advance. This also allows for allocation to varying sizes without any issues.
4. The use of dynamic memory allocation is especially beneficial in special cases like trees, hyperlink-listing, and many others.

Conclusion

In C++, there are important ways to dynamically allocate memory i.e. with the use of the new operator and the delete operator. A memory block is allocated using the new operator and de-allocated using the delete operator. And for C-style functions malloc and free functions are used. We also saw examples of how dynamic memory allocation is done for arrays and objects.  Dynamic memory allocation in C++ is an essential concept in the discipline of data systems which includes related lists, stacks, queues, trees, etc.

Frequently Asked Questions

Q. What is dynamic memory allocation in CPP?

Dynamic memory allocation in C++ is a manner to allocate memory at some stage in program execution, instead of at compile time. It permits this system to request memory from the running device at runtime, after which it releases that memory when it is not in use. Dynamic memory allocation is typically used when the exact size of the data to be stored is not known at compile time, or when the size may change during program execution.

Using new and delete, you can allocate and deallocate memory for single objects or arrays of objects, while malloc and free can be used to allocate and deallocate blocks of memory of a particular length. 

It is critical to note that with dynamic memory allocation, it is the programmer's responsibility to control the memory efficiently. In this, it is critical to deallocate memory to avoid the possibility of memory leaks. This may be achieved by calling delete or free on the pointer returned with the aid of the memory allocation function, once the memory is not wanted.

Q. How many types of dynamic memory allocation are there in C++?

Dynamic memory allocation is a critical idea in C++ programming, as it allows developers to allocate memory at runtime, rather than during the compile time. In C++, there are two fundamental forms of dynamic memory allocation: using the "new" keyword and the usage of the "malloc" function.

The usage of the "new" keyword

The "new" keyword is used to allocate memory dynamically in the course of runtime. It is used to allocate a single item or an array of items on the heap memory. The syntax for using the "new" is as follows:

data_type *pointer_name = new data_type;

This syntax pronounces a pointer variable of the specified facts type and allocates memory on the heap to store the object of that data type. The "new" keyword returns a pointer to the allocated memory block, which is then assigned to the pointer variable.

Example:

            #include 
using namespace std;

int main() {

int *q; // declare a pointer variable
q = new int; // allocate memory for a single integer on the heap

*q = 2; // store a value in the allocated memory block
cout << *q << endl; // output the value stored in the memory block

delete q; // release the memory back to the operating system
return 0;
}
          

I2luY2x1ZGUgPGlvc3RyZWFtPgp1c2luZyBuYW1lc3BhY2Ugc3RkOwoKaW50IG1haW4oKSB7CgppbnQgKnE7IC8vIGRlY2xhcmUgYSBwb2ludGVyIHZhcmlhYmxlCnEgPSBuZXcgaW50OyAvLyBhbGxvY2F0ZSBtZW1vcnkgZm9yIGEgc2luZ2xlIGludGVnZXIgb24gdGhlIGhlYXAKCipxID0gMjsgLy8gc3RvcmUgYSB2YWx1ZSBpbiB0aGUgYWxsb2NhdGVkIG1lbW9yeSBibG9jawpjb3V0IDw8ICpxIDw8IGVuZGw7IC8vIG91dHB1dCB0aGUgdmFsdWUgc3RvcmVkIGluIHRoZSBtZW1vcnkgYmxvY2sKCmRlbGV0ZSBxOyAvLyByZWxlYXNlIHRoZSBtZW1vcnkgYmFjayB0byB0aGUgb3BlcmF0aW5nIHN5c3RlbQpyZXR1cm4gMDsKfQ==

The usage of the "malloc()" function

The "malloc" feature is borrowed from C programming and is used to allocate memory dynamically for the duration of runtime. It is used to allocate a block of memory of a unique length on the heap. The syntax for using the "malloc" function is as follows:

pointer_name = (data_type*) malloc(num_bytes);

This syntax proclaims a pointer variable of the specified datatype and allocates a block of memory on the heap of "num_bytes” size. The "malloc" function returns a pointer to the primary bytes of memory (allocated memory block), which is then assigned to the pointer variable. Observe that we need to cast the pointer to the right datatype.

Example:

            #include
#include 
using namespace std;

int main() {

int *q; // declare a pointer variable
q = (int*) malloc(sizeof(int)); // allocate memory for a single integer on the heap

*q = 2; // store a value in the allocated memory block
cout << *q << endl; // output the value stored in the memory block

free(q); // release the memory back to the operating system
return 0;
}
          

I2luY2x1ZGU8aW9zdHJlYW0+CiNpbmNsdWRlIDxjc3RkbGliPgp1c2luZyBuYW1lc3BhY2Ugc3RkOwoKaW50IG1haW4oKSB7CgppbnQgKnE7IC8vIGRlY2xhcmUgYSBwb2ludGVyIHZhcmlhYmxlCnEgPSAoaW50KikgbWFsbG9jKHNpemVvZihpbnQpKTsgLy8gYWxsb2NhdGUgbWVtb3J5IGZvciBhIHNpbmdsZSBpbnRlZ2VyIG9uIHRoZSBoZWFwCgoqcSA9IDI7IC8vIHN0b3JlIGEgdmFsdWUgaW4gdGhlIGFsbG9jYXRlZCBtZW1vcnkgYmxvY2sKY291dCA8PCAqcSA8PCBlbmRsOyAvLyBvdXRwdXQgdGhlIHZhbHVlIHN0b3JlZCBpbiB0aGUgbWVtb3J5IGJsb2NrCgpmcmVlKHEpOyAvLyByZWxlYXNlIHRoZSBtZW1vcnkgYmFjayB0byB0aGUgb3BlcmF0aW5nIHN5c3RlbQpyZXR1cm4gMDsKfQ==

Q. What is the syntax to allocate memory in C++?

In C++, you can dynamically allocate memory using the "new" keyword, which returns a pointer to the new memory. The syntax for dynamically allocating memory in C++ is as follows:

datatype * pointer = new datatype;

Where "datatype" is the data type variable to allocate memory and "pointer" is the name of the pointer to which the new memory is allocated. The above syntax allocates memory for a variable of type "data type".

If you want to allocate memory for a different array, you can use the following syntax:

datatype * pointer = new datatype[num_elements];

where "element_num" is the number of elements in the array. The above syntax allocates memory for the variable array 'num_elements' of type 'datatype'.

When you have finished using the dynamically allocated memory, you must free it using the "delete" keyword as follows:

delete pointer;

or

delete[] pointer;

Or the variable array allocates memory. This frees up memory and frees it for other uses.

Q. What is dynamic RAM with an example?

Dynamic Random Access Memory (DRAM) is a type of computer memory that is commonly used in modern devices like pc, mobile, and gaming consoles. DRAM is risky, which means that it requires a constant delivery of power to preserve the stored records.

DRAM is made up of cells that consist of memory, each of which stores a bit of data as an electrical charge on a capacitor. The charge on the capacitor is refreshed regularly by a circuit within the DRAM chip to maintain the data's integrity.

An instance of DRAM in a computer gadget is the primary memory or RAM that stores records briefly at the same time as the computer is strolling. When you open a utility or file on your pc, the record is loaded from the hard drive or solid-state drive (SSD) into the DRAM, wherein it can be accessed quickly by means of the CPU. The more DRAM a system has, the more information it can store in memory, which ultimately enhances the system's average overall performance.

Q. Can you use smart pointers to dynamically allocate memory?

Yes, smart pointers are a C++ language feature that can be used to dynamically allocate memory on the heap. Smart pointers are a form of RAII (Resource Acquisition Is Initialization) item that robotically manages the life of the dynamically allocated memory. This allows you to save memory leaks and dangling pointers that may occur when memory isn't well managed.

There are three types of smart pointers in C++:

1. unique_ptr: This smart pointer gives extraordinary possession of the dynamically allocated memory. One unique_ptr can only point to a given object at a time, and whilst the unique_ptr is destroyed, it routinely releases the memory it owns.
2. shared_ptr: This smart pointer allows more than one pointer to share ownership of the dynamically allocated memory. The memory is robotically released when the last shared_ptr pointing to its miles is destroyed.
3. weak_ptr: This smart pointer is used in conjunction with shared_ptr to break circular references. It provides a non-owning reference to the shared_ptr object and can be used to check if the object still exists.

Test Your Skills: Quiz Time

You might also be interested in reading the following:

1. Difference Between C And C++| Features | Application & More!
2. C++ Interview Questions- The Basics, Uses, And More!
3. Find In Strings C++ | Examples To Find Substrings, Character & More!
4. Ways To Find String Length In C++ Simplified (With Examples)
5. Typedef In C++ | Syntax, Application & How To Use It (With Examples)