Dynamic Memory

Dynamic Memory Allocation for Arrays

Just like variables, we can also allocate memory for arrays dynamically using the below syntax. 

To create and allocate an array

Syntax 

int* pointer_variable=new int[size]; 

To de-allocate and remove the array

Syntax 

delete [] pointer_variable;

Example

#include <bits/stdc++.h>
using namespace std;

int main () {

  int* x  = new int[5]; // allocate memory with size as 5
  for(int i=1;i<=5;i++){
      x[i-1]=i; // intialize
  }
    for(int i=0;i<5;i++){
      cout<<x[i]<<" "; // use
  }
  delete [] x;         // free up the memory.
  return 0;
}

Output

1 2 3 4 5 

Explanation

In the above example, we have first dynamically allocated memory for 5 integers continuously, and then we have returned a pointer to the first element of the sequence, which is assigned to x. 

The major difference between declaring an array normally and declaring an array dynamically is that normal arrays are de-allocated by the compiler automatically, usually when the function containing the array returns or completes. Whereas the dynamically allocated array remains there until they are de-allocated by the programmer or program terminates.

Dynamic Memory Allocation for Objects

Objects are the same as variables of simple data types. We can dynamically create and allocate memory for objects in C++ using the ‘new’ operator, and similarly, we can de-allocate the memory of the objects using ‘delete’ operator.

Example

#include <bits/stdc++.h>
using namespace std;

class Plane {
  public:
      Plane() { 
        cout << "Constructor called" <<endl; 
      }
      ~Plane() { 
        cout << "Destructor called" <<endl; 
      }
};
int main() {
  Plane* obj = new Plane[2];
  delete [] obj; // Delete array

  return 0;
}

Output

Constructor called
Constructor called
Destructor called
Destructor called

Explanation

In the above example, first created we created an object array of size 2 using the new operator, as a result of which the constructor of the class is called 2 times, and similarly, when we de-allocate the memory occupied by the object, it calls the destructor 2 times too.

Must Read Dynamic Binding in C++

Frequently Asked Questions

Ques: What is the difference between malloc() and new operator?

Ans: Few of the differences between malloc() and new operator which are used to allocate dynamic memory are as follows:

• The new operator calls the constructor, whereas malloc() doesn't.
• In the case of the new operator, the compiler calculates the required size of memory, whereas, in the case of malloc(), the programmer has to manually calculate the size of memory.
• The new operator returns the exact data type, whereas malloc() returns void.

Ques: What is the difference between free() and delete operator?

Ans: The main difference between free() and delete operator is that free() only de-allocates the memory without calling the destructor of the class, whereas the delete operator not only de-allocates the memory but also calls the destructor of the class.

Ques: Which memory is used when we dynamically store a variable/array/object in C++?

Ans: The heap memory is used when we dynamically store a variable/array/object in C++.

Key Takeaways

In this blog, we have covered the following things:

• First, we discussed what dynamic memory allocation in C++ is.
• Then we discussed how we could dynamically allocate memory for variables, arrays, and objects in C++ with examples.

In C++, we use a new and delete operator to perform dynamic memory allocation, similarly, we have malloc() and free() functions too in C++. To study about it more, refer to this. In dynamic memory allocation, we use pointers and use the concepts of references to understand and read about it more refer this.