{"id":5110,"date":"2017-01-01T06:47:28","date_gmt":"2017-01-01T06:47:28","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/overloading-operator-new-and-delete-2\/"},"modified":"2023-06-26T12:29:04","modified_gmt":"2023-06-26T12:29:04","slug":"overloading-operator-new-and-delete-2","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/overloading-operator-new-and-delete-2\/","title":{"rendered":"Overloading Operator new and delete 2"},"content":{"rendered":"

I overloaded in the last post <\/a>operator new <\/span>and delete<\/span>. Therefore, finding memory leaks and getting the first hint of the bad guys. My solution had two not-so-nice properties. With this post, I will overcome them.<\/p>\n

<\/p>\n

What were the not-so-nice properties of my last post? At first, I got only a hint that my memory was lost; second, I had to prepare the whole bookkeeping of memory management at compile time. Those who want to know the details of these shortcomings should read the last post. But now the ugliness will go.<\/p>\n

Who is the bad guy?<\/h2>\n

Particular tasks ask for special forces. So I have to use a small macro for debugging purposes.<\/p>\n

I want to stress this point. I’m not a friend of macros.<\/b><\/p>\n

Let’s have a look at the macro. #define new new(__FILE__, __LINE__)<\/span><\/p>\n

The macro causes each new<\/span> call will be mapped to the overloaded new <\/span>call. This overloaded new <\/span>call adds the name of the file and the line number, respectively. That’s exactly the information I need.<\/p>\n

But what will happen if I use the macro in line 6?<\/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<\/pre>\n<\/td>\n
\n
\/\/ overloadOperatorNewAndDelete2.cpp<\/span>\r\n\r\n#include \"myNew4.hpp\"<\/span>\r\n\/\/ #include \"myNew5.hpp\"<\/span>\r\n\r\n#define new new(__FILE__, __LINE__)<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <new><\/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\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    dummyFunction();\r\n    \r\n    getInfo();\r\n    \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
The preprocessor substitutes all new <\/span>calls. That shows precisely the modified main <\/span>function.<\/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<\/pre>\n<\/td>\n
\n
class<\/span> MyClass<\/span>{\r\n  float<\/span>* p= new<\/span>(\"overloadNewAndDelete.cpp\"<\/span>, 14) 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\nint<\/span> main(){\r\n\r\n    int<\/span>* myInt= new<\/span>(\"overloadNewAndDelete.cpp\"<\/span>, 24) int<\/span>(1998);\r\n    double<\/span>* myDouble= new<\/span>(\"overloadNewAndDelete.cpp\"<\/span>, 25) double<\/span>(3.14);\r\n    double<\/span>* myDoubleArray= new<\/span>(\"overloadNewAndDelete.cpp\"<\/span>, 26) double<\/span>[2]{1.1,1.2};\r\n\r\n    MyClass* myClass= new<\/span>(\"overloadNewAndDelete.cpp\"<\/span>, 28) MyClass;\r\n    MyClass2* myClass2= new<\/span>(\"overloadNewAndDelete.cpp\"<\/span>, 29) 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    dummyFunction();\r\n\r\n    getInfo();\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
Lines 2 and 12 show that the preprocessor substitutes the constants __FILE__<\/span> and __LINE__<\/span> in the macro. But how does the magic work? The header myNew4<\/span>.<\/span>hpp <\/span>solves the riddle. <\/span><\/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\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54\r\n55\r\n56\r\n57\r\n58<\/pre>\n<\/td>\n
\n
\/\/ myNew4.hpp<\/span>\r\n\r\n#ifndef MY_NEW4<\/span>\r\n#define MY_NEW4<\/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 <array><\/span>\r\n\r\nint<\/span> const<\/span> MY_SIZE= 10;\r\n\r\nint<\/span> counter= 0;\r\n\r\nstd::array<void<\/span>* ,MY_SIZE> myAlloc{nullptr,};\r\n\r\nvoid<\/span>* newImpl(std::size_t<\/span> sz,char<\/span> const<\/span>* file, int<\/span> line){\r\n    void<\/span>* ptr= std::malloc(sz);\r\n    std::cerr << file << \": \"<\/span> << line << \" \"<\/span> <<  ptr << std::endl;\r\n    myAlloc.at(counter++)= ptr;\r\n    return<\/span> ptr;\r\n}\r\n\r\nvoid<\/span>* operator<\/span> new(std::size_t<\/span> sz,char<\/span> const<\/span>* file, int<\/span> line){  \r\n    return<\/span> newImpl(sz,file,line);\r\n}\r\n<\/span>\r\nvoid<\/span>* operator<\/span> new<\/span> [](std::size_t<\/span> sz,char<\/span> const<\/span>* file, int<\/span> line){  \r\n    return<\/span> newImpl(sz,file,line);\r\n}\r\n\r\nvoid<\/span> operator<\/span> delete<\/span>(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\n#define new new(__FILE__, __LINE__)<\/span>\r\n\r\nvoid<\/span> dummyFunction(){\r\n    int<\/span>* dummy= new<\/span> int<\/span>;\r\n}\r\n\r\nvoid<\/span> getInfo(){\r\n    \r\n    std::cout << std::endl;\r\n     \r\n    std::cout << \"Allocation: \"<\/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_NEW4<\/span>\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
I implement in line 25 and 29 the special operators new <\/span>and new[] <\/span>that delegates their functionality to the helper function newImpl <\/span>(lines 18 – 23). The function does two important jobs. At first, it displays to each new <\/span>call the name of the source file and the line number (line 20); second, it keeps in the static array myAlloc <\/span>track of each used memory address (line 21). This fits the behavior of the overloaded operator delete <\/span>that sets all memory addresses to the null pointer nullptr<\/span> (line 35). The memory addresses stand for the deallocated memory areas. In the end, the function getInfo <\/span>displays the memory addresses that were not deallocated. You can directly see them together with the file name and line number.<\/p>\n<\/p>\n
Of course, I can directly apply the macro in the file myNew4.hpp<\/span>. That was a lot of theory. What’s the output of the program?<\/p>\n
\"overloadNewAndDelete\" <\/p>\n
The memory areas to the memory address 0x8c3010, 0x8c3090, and 0x8c3230 were not deallocated. The bad guys are the new <\/span>calls in line 24 and line 14 <\/span>(overloadNewAndDelete.hpp<\/span>) and the new <\/span>call in line 42 <\/span>(myNew4.hpp<\/span>).<\/p>\n
Impressed? I assume, yes. But the presented technique has two drawbacks. One minor and one major.<\/p>\n
    \n
  1. I have to overload the simple operator new<\/span> and the operator new []<\/span> for arrays. This, because of overloaded operator new,  is not a fallback for the three remaining operators new. <\/span><\/a><\/li>\n
  2. I can not use the particular operator new<\/span> that returns in the error case a null pointer. Because it will be explicitly called by the operator new <\/span>with the argument std::nothrow<\/span>: int* myInt= new (std::nothrow) int(1998);<\/span><\/li>\n<\/ol>\n
    Now, I have to solve the first issue. I want to use for the array myAlloc, <\/span>a data structure that manages its memory at run time. Therefore, it is not necessary anymore to eagerly allocate the memory at compile time.<\/p>\n
    All at run time<\/h2>\n
    What was the reason that I couldn’t allocate memory in the operator new<\/span>? The operator new <\/span>was globally overloaded. Therefore, a call of new <\/span>would end in a never-ending recursion. That will happen exactly if I use a container like std::vector <\/span>that dynamically allocates its memory.<\/p>\n
    This restriction holds not anymore because I didn’t overload the global operator new. <\/span>That is a fallback to the three remaining new <\/span>operators. Thanks to the macro, my variant of operator new <\/span>is used. Therefore, I can use std::<\/span>vector <\/span>in my operator new. <\/span><\/p>\n
    Exactly that can you see in my program.<\/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\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54\r\n55\r\n56<\/pre>\n<\/td>\n
    		\n
    \/\/ myNew5.hpp<\/span>\r\n\r\n#ifndef MY_NEW5<\/span>\r\n#define MY_NEW5<\/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 <vector><\/span>\r\n\r\nstd::vector<void<\/span>*> myAlloc;\r\n\r\nvoid<\/span>* newImpl(std::size_t<\/span> sz,char<\/span> const<\/span>* file, int<\/span> line){\r\n    static<\/span> int<\/span> counter{};\r\n    void<\/span>* ptr= std::malloc(sz);\r\n    std::cerr << file << \": \"<\/span> << line << \" \"<\/span> <<  ptr << std::endl;\r\n    myAlloc.push_back(ptr);\r\n    return<\/span> ptr;\r\n}\r\n\r\nvoid<\/span>* operator<\/span> new(std::size_t<\/span> sz,char<\/span> const<\/span>* file, int<\/span> line){  \r\n    return<\/span> newImpl(sz,file,line);\r\n}\r\n\r\nvoid<\/span>* operator<\/span> new<\/span> [](std::size_t<\/span> sz,char<\/span> const<\/span>* file, int<\/span> line){  \r\n    return<\/span> newImpl(sz,file,line);\r\n}\r\n\r\nvoid<\/span> operator<\/span> delete<\/span>(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\n#define new new(__FILE__, __LINE__)<\/span>\r\n\r\nvoid<\/span> dummyFunction(){\r\n    int<\/span>* dummy= new<\/span> int<\/span>;\r\n}\r\n\r\nvoid<\/span> getInfo(){\r\n    \r\n    std::cout << std::endl;\r\n     \r\n    std::cout << \"Allocation: \"<\/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_NEW5<\/span>\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
     <\/p>\n
    I use in lines 13, 19, and 33 std<\/span>::vector. <\/span><\/p>\n
    What’s next?<\/h2>\n
    In the next post, <\/a>I will have a closer look at std<\/span>::allocator<\/span>. In particular, I’m interested how memory requests can be mapped to particular memory areas.<\/p>\n
    <\/span><\/p>\n
     <\/p>\n
     <\/p>\n
     <\/p>\n
     <\/p>\n","protected":false},"excerpt":{"rendered":"
    I overloaded in the last post operator new and delete. Therefore, finding memory leaks and getting the first hint of the bad guys. My solution had two not-so-nice properties. With this post, I will overcome them.<\/p>\n","protected":false},"author":21,"featured_media":5109,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[364],"tags":[498,493],"class_list":["post-5110","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\/5110","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=5110"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5110\/revisions"}],"predecessor-version":[{"id":6904,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5110\/revisions\/6904"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5109"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5110"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5110"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5110"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}