Difference between New and Delete operator in C++

Introduction:

In C++ programming language, the new and delete operators are mainly utilized for dynamic memory allocation and deallocation. They enable us to dynamically allocate and free the memory, which means that we can create objects whose size and lifetime may be defined at runtime. However, there are some main distinctions between the two operators that we should be aware of. In this article, we will explore the differences between new and delete in C++.

Definition

The new operator is mainly utilized to allocate memory for an object or an array of objects. It returns a pointer to the allocated memory. On the other hand, the delete operator is mainly utilized to deallocate memory that was previously allocated with new. It frees the memory pointed to by the pointer and sets the pointer to null.

Syntax

The syntax for the new operator is:

The syntax for the delete operator is:

Allocation of memory:

The new operator allocates memory for the object or array of objects from the heap, which is a global pool of memory. The memory block size is determined by the object data type or array of objects. On the other hand, the delete operator frees the memory allocated by the new operator.

Initialization:

The new operator initializes the memory allocated for an object with the default constructor of the class. If there is no default constructor, we may utilize the placement new operator to call the appropriate constructor. The delete operator does not perform any initialization.

Allocation of array:

The new operator may be mainly utilized to allocate memory for an array of objects. The syntax for array allocation is:

On the other hand, the delete operator may be mainly utilized to deallocate an array of objects allocated with the new operator. The syntax for array deallocation is:

Exception Handling

The new operator may throw an exception if it fails to allocate memory. In this case, the program may catch the exception and take appropriate action. In contrast, the delete operator does not throw any exceptions.

Leaking of memory:

One of the most common issues that arise with dynamic memory allocation is memory leaking. Memory leak occurs when a block of memory that has been allocated by new is not deallocated with delete. It may result in our program running out of memory, causing crashes or other unpredictable behaviour. To avoid memory leaks, it's important to make sure that every block of memory allocated with new is eventually deallocated with delete.

Operator Overloading:

Both new and delete operators may be overloaded in C++. Operator overloading enables us to redefine the behaviour of these operators to suit the needs of our program. For example, we may overload the new operator to allocate memory from a custom memory pool, rather than the default heap. Similarly, we can overload the delete operator to perform additional clean up tasks before freeing the memory. However, we should use operator overloading with caution, as it may make our code less readable and more difficult to maintain.

Global Overload

In C++, we can also overload the global new and delete operators to customize the behaviour of memory allocation and deallocation across our entire program. The syntax for overloading the global new operator is:

Similarly, the syntax for overloading the global delete operator is:

By overloading these operators, we may customize the memory allocation and deallocation behaviour for our entire program, which may be very useful in certain scenarios, such as developing real-time systems or embedded systems.

Comparison of the differences between new and delete operators in C++ is given below:

Conclusion:

In conclusion, the new and delete operators are essential tools for dynamic memory allocation and deallocation in C++. While they have some similarities, such as their use of the heap memory and their role in memory management, they also have some significant differences, such as their syntax and initialization behaviour. By understanding these differences, we can use these operators more effectively in our C++ programs.