Memory Leaks in C++ and How to Avoid Them
In the C++ programming language, a memory leak occurs when dynamically allocated program memory types in a C++ program are not deallocated in the proper order. This causes the current program to lose its memory track, and the memory allocation in the program remains unchanged, typically until the current program terminates. This results in the current program not being able to properly utilize the memory, and over time, the program’s memory may become exhausted. This can persist in programs or software applications that run for a long time under certain conditions.
Example of a memory leak in C++ programming.
#include <iostream>
int main() {
int* ptr = new int(17); // Here, memory is dynamically allocated for integer data types variables.
// Here, we have not used any delete statements, resulting in a memory leak.
return 0;
}
Explanation of a memory leak in C++ programming.
- In the above example, the new operator allocates integer memory for an int data type. However, the program does not use a delete operator to free the existing memory. As a result, the allocated variable parameter memory is “leaked” from the program.
Causes of C++ Programming Memory Leaks.
Memory leaks in a C++ program typically arise due to one of the following main reasons:
Failure to deallocate allocated memory in a C++ program.
Sometimes, we forget to deallocate allocated parameter variable memory in a C++ program after it is no longer needed.
Overwriting pointers in a C++ program.
If a C++ user assigns a new value to such a pointer in an existing program. Which previously indicated dynamically allocated memory in a program. The reference to the memory allocated at that location is automatically lost, and the C++ user can no longer delete or free it in the current program.
int* ptr = new int(8);
ptr = new int(19); // Here, the memory previously allocated in the `ptr` variable is lost.
// And the original variable memory defined in it is leaked into the program.
C++ Program Memory Exception.
If a C++ user-defined program displays an exception after memory is allocated but before it is freed, then the memory cannot be deallocated in the current program under this condition.
void test() {
int* ptr = new int(11);
throw std::runtime_error(“A memory exception error displayed”); // Memory is never freed in this situation
}
Not freeing dynamically allocated arrays in a C++ program.
Not using the delete[] array method for array data type memory allocated with a new[] square bracket block in a C++ array program can lead to a memory leak.
int* array = new int[19]; // Here we have allocated memory for an array variable named integer.
// Missing the delete[] array method in this condition can lead to a memory leak.
How to avoid memory leaks in C++ programming.
Manually free program memory when necessary.
First, ensure that a corresponding delete or delete[] method is invoked with every new or new[] array block in your program.
For freeing a single memory object.
int* ptr = new int(13);
// Here the ptr variable is used to allocate memory
delete ptr; // Here the delete keyword is used to free the allocated memory
To free memory for the sequence array data type.
int* array = new int[27];
// Here the integer array is used to allocate a 27 array memory block
delete[] array; // This uses the existing array to free the 27 array allocated memory
C++ Programs Use Smart Pointers.
Smart pointers defined in C++ programs are wrappers around raw pointers that automatically manage memory in a program and deallocate it when no longer needed in the current program.
The C++ Standard Library provides several types of smart pointers to its users.
std::unique_ptr – In C++ programs, this is a smart pointer variable that provides complete ownership and control of a program memory resource and automatically deallocates the memory of the declared smart pointer variable when it goes out of scope. It cannot be copied within the program, but it can be moved if necessary.
#include <memory>
void test() {
std::unique_ptr<int> ptr = std::make_unique<int>(13);
// There is no need to manually delete ptr in this program; it is a smart pointer and will be deleted automatically.
}
std::shared_ptr – This is a reference-counted smart pointer variable in a C++ program. Multiple shared_ptr instances can share ownership of the same program object. When the last shared_ptr variable goes out of scope or is reset, the ptr memory allocated to this program is automatically deallocated.
#include <memory>
void test() {
std::shared_ptr<int> ptrone = std::make_shared<int>(19);
std::shared_ptr<int> ptrtwo = ptrone; // This is an example of shared ptr ownership.
// You don’t need to delete the ptr here; the memory allocated to it is automatically freed when both ptrone and ptrtwo exit their scope.
}
std::weak_ptr – In a C++ program, a non-owning reference to a program object managed by a shared_ptr is used to avoid circular references between shared_ptrs.
std::shared_ptr<int> shared = std::make_shared<int>(21);
std::easy_ptr<int> easy= shared; // Here, the user-defined easy_ptr does not prevent memory deallocation.
Use RAII (Resource Acquisition Is Initialization) in C++.
RAII is a design pattern in C++ programs where system resources (such as variable memory) are tied to the lifetime of the object. When an object goes out of scope in the current program, its destructor method is called, and the system cleans up its memory resources.
Example with RAII in a C++ program.
class System_data {
public:
System_data() { ptr = new int(27); }
~System_data() { delete ptr; } // Here we use the destructor method to free its memory
private:
int* ptr;
};
void test() {
System_data s; // Here the memory allocated in the constructor is automatically freed in the destructor method
}
Explanation with RAII in a C++ program.
- In this example, when the System_data object goes out of scope, the memory allocated in the system is automatically freed, thanks to the destructor method defined in the current program.
