Search⌘ K
Home
Courses
C++ Fundamentals for Professionals

Overloading new and delete

Understand how to overload the global new and delete operators in C++ to explicitly manage memory allocation and deallocation. Explore techniques to track memory usage, identify leaks through address comparison, and improve application memory transparency. This lesson helps you gain critical skills to avoid memory issues in C++ programs that run over extended periods.

We'll cover the following...

Quite often, a C++ application allocates memory but does not deallocate it. This is a job for the operator new and operator delete. Thanks to both of them, we can explicitly manage the memory of an application.

From time to time, we have to verify that an application correctly releases its memory. In particular, for programs running for long periods of time, it is a challenge to allocate and deallocate memory from a memory management perspective. Of course, the automatic release of memory during program shutdown is not an option.

The baseline #

As a baseline for our analysis, we use a simple program that frequently allocates and deallocates memory.

C++
// #include "myNew.hpp"
// #include "myNew2.hpp"
// #include "myNew3.hpp"
#include <iostream>
#include <string>
class MyClass{
  float* p= new float[100];
};
class MyClass2{
  int five= 5;
  std::string s= "hello";
};
int main(){
    
    int* myInt= new int(1998);
    double* myDouble= new double(3.14);
    double* myDoubleArray= new double[2]{1.1,1.2};
    
    MyClass* myClass= new MyClass;
    MyClass2* myClass2= new MyClass2;
    
    delete myDouble;
    delete [] myDoubleArray;
    delete myClass;
    delete myClass2;
    
//  getInfo();
    
}

The key question is, does there need to be a corresponding delete for each new call?

The question can be simply answered by overloading the global operators, new and delete. For each operator, I count how often it was called.

new operator

C++ offers the new operator in four variations:

void* operator new  (std::size_t count );
void* operator new[](std::size_t count );
void* operator new  (std::size_t count, const std::nothrow_t&
...