{"id":5108,"date":"2016-12-30T17:47:09","date_gmt":"2016-12-30T17:47:09","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/overloading-operator-new-and-delete\/"},"modified":"2023-06-26T12:29:18","modified_gmt":"2023-06-26T12:29:18","slug":"overloading-operator-new-and-delete","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/overloading-operator-new-and-delete\/","title":{"rendered":"Overloading Operator new and delete 1"},"content":{"rendered":"

It happens quite too often that a C++ application allocates memory but doesn’t deallocate it. This is the job of the operator to new and delete. Thanks to them both, you can explicitly manage the memory management of an application.<\/p>\n

<\/p>\n

 <\/p>\n

Occasionally, I had to verify that a customer’s application correctly releases its memory. In particular, programs running for an extended period and often allocating and deallocating memory are challenging from the memory management perspective. Of course, the automatic memory release during the program’s shutdown is not an option.<\/p>\n

The baseline<\/h2>\n

As a baseline of my analysis, I use a simple program that often allocates and deallocates memory. In production, the code is bigger. That does not affect my strategy.<\/p>\n

<\/p>\n

\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36<\/pre>\n<\/td>\n
\n
\/\/ overloadOperatorNewAndDelete.cpp<\/span>\r\n\r\n\/\/ #include \"myNew.hpp\"<\/span>\r\n\/\/ #include \"myNew2.hpp\"<\/span>\r\n\/\/ #include \"myNew3.hpp\"<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n\r\nclass<\/span> MyClass<\/span>{\r\n  float<\/span>* p= new<\/span> float<\/span>[100];\r\n};\r\n\r\nclass<\/span> MyClass2<\/span>{\r\n  int<\/span> five= 5;\r\n  std::string s= \"hello\"<\/span>;\r\n};\r\n\r\n\r\nint<\/span> main(){\r\n    \r\n    int<\/span>* myInt= new<\/span> int<\/span>(1998);\r\n    double<\/span>* myDouble= new<\/span> double<\/span>(3.14);\r\n    double<\/span>* myDoubleArray= new<\/span> double<\/span>[2]{1.1,1.2};\r\n    \r\n    MyClass* myClass= new<\/span> MyClass;\r\n    MyClass2* myClass2= new<\/span> MyClass2;\r\n    \r\n    delete<\/span> myDouble;\r\n    delete<\/span> [] myDoubleArray;\r\n    delete<\/span> myClass;\r\n    delete<\/span> myClass2;\r\n    \r\n\/\/  getInfo();<\/span>\r\n    \r\n}<\/span>\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
The key question is. Is there a corresponding delete<\/span> for each new<\/span> call?<\/p>\n<\/p>\n
Too careless<\/h2>\n
The question is quite simple to answer by overloading the global operator new and delete. I count for each operator, how often it was called.<\/p>\n
Operator new<\/h3>\n
C++ offers the operator new in four variations.<\/p>\n
<\/p>\n
\n
void<\/span>* operator<\/span> new  (std::size_t<\/span> count );\r\nvoid<\/span>* operator<\/span> new<\/span>[](std::size_t<\/span> count );\r\nvoid<\/span>* operator<\/span> new  (std::size_t<\/span> count, const<\/span> std::nothrow_t<\/span>& tag);\r\nvoid<\/span>* operator<\/span> new<\/span>[](std::size_t<\/span> count, const<\/span> std::nothrow_t<\/span>& tag);\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The first two variations will throw a std::bad_alloc<\/span> exception if they can not provide the memory. The last two variations return a null pointer. It’s quite convenient that is sufficient to overload only version 1 because versions 2 – 4 use the version 1: void* operator new(std::size_t count)<\/span>. This statement also holds for variants 2 and 4, designed for C arrays. You can read the details of the global operator new here: cppreference.com.<\/a><\/p>\n
The statements also hold for operator delete<\/span>.<\/span>
<\/span><\/p>\n
Operator delete<\/h3>\n
 C++ offers six variations for operator delete.<\/span><\/p>\n
<\/p>\n
\n
void<\/span> operator<\/span> delete  (void<\/span>* ptr); \t\r\nvoid<\/span> operator<\/span> delete<\/span>[](void<\/span>* ptr);\r\nvoid<\/span> operator<\/span> delete  (void<\/span>* ptr, const<\/span> std::nothrow_t<\/span>& tag);\r\nvoid<\/span> operator<\/span> delete<\/span>[](void<\/span>* ptr, const<\/span> std::nothrow_t<\/span>& tag);\r\nvoid<\/span> operator<\/span> delete  (void<\/span>* ptr, std::size_t<\/span> sz);\r\nvoid<\/span> operator<\/span> delete<\/span>[](void<\/span>* ptr, std::size_t<\/span> sz);\r\n<\/pre>\n<\/div>\n
 <\/p>\n
According to operator new<\/span>, it is sufficient to overload for operator delete<\/span> the first variant because the remaining five use void operator delete(void* ptr) <\/span>as a fallback. Only a word about the two last versions of operator delete.<\/span> You have in this version the length of the memory block in the variable sz<\/span>  to your disposal. Read the details here at cppreference.com<\/a>.<\/p>\n
This time I use the program overloadOperatorNewAndDelete.cpp<\/span> the header myNew.hpp<\/span> (line 3). The same holds for line 34. Here I invoke the function getInfo<\/span> to get information about my memory management.<\/p>\n
<\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33<\/pre>\n<\/td>\n
\n
\/\/ myNew.hpp<\/span>\r\n\r\n#ifndef MY_NEW<\/span>\r\n#define MY_NEW<\/span>\r\n\r\n#include <cstdlib><\/span>\r\n#include <iostream><\/span>\r\n#include <new><\/span>\r\n\r\nstatic<\/span> std::size_t<\/span> alloc{0};\r\nstatic<\/span> std::size_t<\/span> dealloc{0};\r\n\r\nvoid<\/span>* operator<\/span> new(std::size_t<\/span> sz){\r\n    alloc+= 1;\r\n    return<\/span> std::malloc(sz);\r\n}\r\n\r\nvoid<\/span> operator<\/span> delete<\/span>(void<\/span>* ptr) noexcept{\r\n    dealloc+= 1;\r\n    std::free(ptr);\r\n}\r\n\r\nvoid<\/span> getInfo(){\r\n    \r\n    std::cout << std::endl;\r\n \r\n    std::cout << \"Number of allocations: \"<\/span> << alloc << std::endl;\r\n    std::cout << \"Number of deallocations: \"<\/span> << dealloc << std::endl;\r\n    \r\n    std::cout << std::endl;\r\n}\r\n\r\n#endif <\/span>\/\/ MY_NEW<\/span>\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
I create in the file two static variables alloc<\/span> and dealloc<\/span> (lines 10 and 11). They keep track of how often I used the overloaded operator new<\/span> (line 13) and operator delete<\/span> (line 18). I delegate in the functions the memory allocation to std::malloc<\/span> and the memory deallocation to std::free<\/span>. The function getInfo<\/span> (lines 23 – 31) provides me with the numbers and displays them.<\/p>\n
The question is. Have I cleaned everything clean?<\/p>\n
 \"myNew\"<\/p>\n
Of course, not. That was the intention of this and the following post. Now I know that I have leaks. Maybe it helps to determine the addresses of the objects which I have forgotten to clean up.<\/p>\n
Addresses of the memory leaks.<\/h2>\n
So, I have to put more cleverness into the header myNew2.hpp.<\/span><\/p>\n
 <\/p>\n
<\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43<\/pre>\n<\/td>\n
\n
\/\/ myNew2.hpp<\/span>\r\n\r\n#ifndef MY_NEW2<\/span>\r\n#define MY_NEW2<\/span>\r\n\r\n#include <algorithm><\/span>\r\n#include <cstdlib><\/span>\r\n#include <iostream><\/span>\r\n#include <new><\/span>\r\n#include <string><\/span>\r\n#include <array><\/span>\r\n\r\nint<\/span> const<\/span> MY_SIZE= 10;\r\n\r\nstd::array<void<\/span>* ,MY_SIZE> myAlloc{nullptr,};\r\n    \r\nvoid<\/span>* operator<\/span> new(std::size_t<\/span> sz){\r\n    static<\/span> int<\/span> counter{};\r\n    void<\/span>* ptr= std::malloc(sz);\r\n    myAlloc.at(counter++)= ptr;\r\n    return<\/span> ptr;\r\n}\r\n\r\nvoid<\/span> operator<\/span> delete(void<\/span>* ptr) noexcept{\r\n    auto<\/span> ind= std::distance(myAlloc.begin(),std::find(myAlloc.begin(),myAlloc.end(),ptr));\r\n    myAlloc[ind]= nullptr;\r\n    std::free(ptr);\r\n}\r\n\r\nvoid<\/span> getInfo(){\r\n    \r\n    std::cout << std::endl;\r\n     \r\n    std::cout << \"Not deallocated: \"<\/span> << std::endl;\r\n    for<\/span> (auto<\/span> i: myAlloc){\r\n        if<\/span> (i != nullptr ) std::cout << \" \"<\/span> << i << std::endl;\r\n    }\r\n    \r\n    std::cout << std::endl;\r\n    \r\n}\r\n\r\n#endif <\/span>\/\/ MY_NEW2<\/span>\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
The key idea is to use the static array myAlloc<\/span> (line 15) to keep track of the addresses of all std::malloc<\/span> (line 19) and std::free<\/span> (line 19) invocations. Of course, I can not use the function operator new<\/span> container that needs dynamic memory. This container would invoke the operator new. A recursion that would cause my program to crash. Therefore, I use a std::array<\/span> in line 15 because std::array<\/span> gets its memory at compile time. Now it can happen that my std::array<\/span> becomes too small. Therefore, I invoke myAlloc.at(counter++) <\/span>to check the array boundaries.<\/span><\/p>\n
Which memory address have I forgotten to release? The output answers.<\/p>\n
\"myNew2\"<\/p>\n
A simple search for the object having the address is no good idea. Because it is quite probable that a new call of std::malloc<\/span> reuses an already-used address. That is ok if the objects have been deleted in the meantime.<\/p>\n
But why are the addresses part of the solution? I have only to compare the memory address of the created objects with those of the not deleted objects.<\/p>\n
Comparison of the memory addresses<\/h2>\n
In addition to the memory address, I have the reserved memory size at my disposal. I use this information in operator new.<\/span><\/p>\n
 <\/p>\n
<\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44<\/pre>\n<\/td>\n
\n
\/\/ myNew3.hpp<\/span>\r\n\r\n#ifndef MY_NEW3<\/span>\r\n#define MY_NEW3<\/span>\r\n\r\n#include <algorithm><\/span>\r\n#include <cstdlib><\/span>\r\n#include <iostream><\/span>\r\n#include <new><\/span>\r\n#include <string><\/span>\r\n#include <array><\/span>\r\n\r\nint<\/span> const<\/span> MY_SIZE= 10;\r\n\r\nstd::array<void<\/span>* ,MY_SIZE> myAlloc{nullptr,};\r\n    \r\nvoid<\/span>* operator<\/span> new(std::size_t<\/span> sz){\r\n    static<\/span> int<\/span> counter{};\r\n    void<\/span>* ptr= std::malloc(sz);\r\n    myAlloc.at(counter++)= ptr;\r\n    std::cerr << \"Addr.: \"<\/span> << ptr << \" size: \"<\/span> << sz << std::endl;\r\n    return<\/span> ptr;\r\n}\r\n\r\nvoid<\/span> operator<\/span> delete(void<\/span>* ptr) noexcept{\r\n    auto<\/span> ind= std::distance(myAlloc.begin(),std::find(myAlloc.begin(),myAlloc.end(),ptr));\r\n    myAlloc[ind]= nullptr;\r\n    std::free(ptr);\r\n}\r\n\r\nvoid<\/span> getInfo(){\r\n    \r\n    std::cout << std::endl;\r\n     \r\n    std::cout << \"Not deallocated: \"<\/span> << std::endl;\r\n    for<\/span> (auto<\/span> i: myAlloc){\r\n        if<\/span> (i != nullptr ) std::cout << \" \"<\/span> << i << std::endl;\r\n    }\r\n    \r\n    std::cout << std::endl;\r\n    \r\n}\r\n\r\n#endif <\/span>\/\/ MY_NEW3<\/span>\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
Now, the allocation and deallocation of the application are more transparent.<\/p>\n
\"myNew3\"<\/p>\n
A simple comparison shows. I forget to release an object with 4 bytes and an object with 400 bytes. In addition, the allocation sequence in the source code corresponds to the sequence of outputs in the program. Now, it should be quite easy to identify the missing memory releases.<\/p>\n
What’s next?<\/h2>\n
The program is not beautiful in two ways. First, I statically allocate the memory for std::array; second, I want to know which object was not released. In the next post, <\/a>I will solve both issues.   <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
It happens quite too often that a C++ application allocates memory but doesn’t deallocate it. This is the job of the operator to new and delete. Thanks to them both, you can explicitly manage the memory management of an application.<\/p>\n","protected":false},"author":21,"featured_media":5105,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[364],"tags":[498,493],"class_list":["post-5108","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-embedded","tag-memory","tag-new-delete"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5108","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=5108"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5108\/revisions"}],"predecessor-version":[{"id":6905,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5108\/revisions\/6905"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5105"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5108"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5108"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5108"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}