Why does the use of ' new ' cause memory leaks?

In programming languages like C++, the new keyword is used to dynamically allocate memory on the heap. Using new allows us to allocate memory at runtime as needed, which is a powerful feature. However, improper use of new can lead to memory leaks, which can occur for several reasons:

1. Mismatched delete: In C++, after allocating memory with new, you must use delete to free it. If you forget to release the memory, or if delete is not executed due to exceptions or early exits in the program, the allocated memory won't be reclaimed, resulting in memory leaks.

   Example:

   cpp
   int* allocateArray(int size) {
       int* array = new int[size];
       return array; // This causes a memory leak if not deleted outside the function
   }

2. Early Exit Due to Exceptions: If an exception is thrown during the execution of code following new, and the memory release code appears after the exception, the release code will not be executed.

   Example:

   cpp
   void process() {
       int* data = new int[100];
       if (!initialize(data)) {
           throw std::runtime_error("Initialization failed.");
           // The delete below will not be executed if this exception is thrown
       }
       // Process data
       delete[] data;
   }

3. Copying Pointers: If you copy a pointer to memory allocated with new to another pointer, and the original pointer is deleted, the copy may still reference deallocated memory, potentially causing program errors or further memory leak risks.

   Example:

   cpp
   int* original = new int[10];
   int* copy = original;
   delete[] original;
   // Now copy is a dangling pointer; accessing it further results in undefined behavior

To avoid these issues, it is recommended to use smart pointers (such as std::unique_ptr and std::shared_ptr), which automatically manage memory by invoking delete to minimize memory leak risks and provide safer usage.