{"id":474,"date":"2014-05-25T18:26:57","date_gmt":"2014-05-25T16:26:57","guid":{"rendered":"http:\/\/www.martyndavis.com\/?p=474"},"modified":"2016-07-15T10:14:57","modified_gmt":"2016-07-15T08:14:57","slug":"c-custom-deleters-unique_ptr-vs-shared_ptr","status":"publish","type":"post","link":"https:\/\/www.martyndavis.com\/?p=474","title":{"rendered":"C++ Custom Deleters: unique_ptr vs shared_ptr"},"content":{"rendered":"

C++11 gives us two useful<\/del> indispensable smart pointers, std::unique_ptr<\/code> and std::shared_ptr<\/code>. So much has been written about these that there’s no point me re-hashing anything other than to re-iterate that if you are using “naked” owning <\/em> pointers in your code these days, you are simply doing it wrong.<\/p>\n

I wanted to mention briefly the use of custom deleters<\/strong> with smart pointers. If you haven’t looked at this aspect of smart pointers before, it basically gives us a way to specify what<\/em> should happen when the smart pointer goes out of scope.
\n
\nBy default, when your smart pointer goes out of scope, delete<\/code> (or delete[]<\/code>, as appropriate) is called on the resource, ensuring that it is cleaned up. Having the ability to specify how<\/em> the resource is deallocated means we can use these smart pointers for other tasks, e.g. emulating C#’s “using” keyword. Another example might be for using a smart pointer for storing a FILE*<\/code> pointer from fopen()<\/code> and calling fclose()<\/code> from the custom deleter.<\/p>\n

A further example: I’ve recently been doing some work with the SDL library. There’s a library function IMG_Load()<\/code> which takes an image filename as a parameter. It loads the image, and returns a pointer to an SDL_Surface<\/code> (which represents a bitmap). To free the memory pointed to by the pointer, one needs to call SDL_FreeSurface()<\/code> with the SDL_Surface<\/code> pointer as its parameter. One can neither directly delete<\/code> nor free<\/code> an SDL_Surface<\/code> pointer because it’s a pointer to a struct, which presumably contains a pointer to some allocated memory within it. So how to use RAII with this construct? Enter custom deleters – we can specifically tell our smart pointer to call SDL_FreeSurface<\/code> when our smart pointer goes out of scope.<\/p>\n

I don’t specifically want to get into SDL specifics any more than I have, so here’s a completely self-contained program to replicate what I’ve been talking about. Note the class “OldThing” which pretends to be an old, non-smart resource-allocating API call. <\/p>\n

This code also shows the difference between using custom deleters with unique_ptr and shared_ptr which was the original intention of this post. I’ll explain more about the difference after the listing.<\/p>\n

\r\n#include <iostream>\r\n#include <memory>\r\n\r\nclass OldThing {\r\n  public:\r\n    ~OldThing() \r\n    {\r\n      if (allocated_) {\r\n        std::cout << "MEMORY LEAK!" << std::endl;\r\n      }\r\n    }\r\n    void Deallocate()\r\n    {\r\n      std::cout << "Deallocate called." << std::endl;\r\n      allocated_ = false;\r\n    }\r\n  private:\r\n    bool allocated_{ true };\r\n};\r\n\r\nint main() {\r\n  {\r\n    OldThing oldThing;\r\n    \/\/ oldThing going out of scope causes a "memory leak"\r\n  }\r\n\r\n  {\r\n    \/\/ so let's use a smart pointer with a custom "deleter":\r\n    std::shared_ptr<OldThing> p(new OldThing, \r\n      [] (OldThing* ot) {\r\n        ot->Deallocate();\r\n        delete ot;\r\n      }\r\n    );\r\n  }\r\n\r\n  {\r\n    \/\/ So that works OK. But what if we want\r\n    \/\/ to use unique_ptr instead?\r\n        \r\n    \/\/ 1. Don't try this unless you like \r\n    \/\/ seeing loads of template errors:\r\n    \/*\r\n    std::unique_ptr<OldThing> p(new OldThing, \r\n      [] (OldThing* ot) {\r\n        ot->Deallocate();\r\n        delete ot;\r\n      }\r\n    );\r\n    *\/\r\n\r\n    \/\/ 2. So we need to include the   \r\n    \/\/ deleter's type in the template parameters:\r\n    std::unique_ptr<OldThing, void(*)(OldThing*)> p(new OldThing, \r\n      [] (OldThing* ot) {\r\n         ot->Deallocate();\r\n         delete ot;\r\n      }\r\n    );\r\n  }\r\n\r\n  return 0;\r\n}\r\n<\/pre>\n
So to compile this with g++, use g++ -std=c++11 -o foo foo.cpp<\/code> (assuming you’ve called the source foo.cpp). If you run .\/foo<\/code>, you should see the following output, each line corresponding to one of the three scope blocks in main():
\n
\nMEMORY LEAK!
\nDeallocate called.
\nDeallocate called.
\n<\/code><\/p>\n
Essentially we’re seeing a fake “memory leak” when the non-smart OldThing<\/code> object goes out of scope, then two calls to Deallocate()<\/code> from the two smart pointers. No real memory allocation going on, just calls to the “deallocation” method.<\/p>\n
Note the difference between specifying a deleter for a shared_ptr<\/code> and a unique_ptr<\/code>. This is the reason for this post… initially I (without really thinking it through) had some shared_ptr<\/code>s with custom deleters and figured they should really be unique_ptr<\/code>s, so I basically had code like the commented out section marked “1”. This generates a spew of template errors and it can be difficult to figure out what’s going wrong (try it and see).<\/p>\n
But to make sense of why we need to specify the deleter differently for a unique_ptr<\/code>, let’s think about how the two smart pointers are implemented. A shared_ptr<\/code> actually sets up a structure in memory which allows for reference counting, weak pointers, etc. It’s only when reference counts drop to zero can the resource be deallocated. Its constructor takes a function object as its second parameter to allow us to specify a deleter.<\/p>\n
If we don’t need to share this smart pointer, using a shared_ptr<\/code> is an overhead we don’t need. A unique_ptr<\/code> is a simpler templated class. If you don’t specify the deleter’s function signature as the second template parameter, the default_deleter<\/code> is used. So as you can see in the section marked “2” we provide the correct template parameter, a function pointer to a void function that takes an OldThing<\/code> pointer, which makes it work as expected.<\/p>\n
Edit:<\/strong> I reviewed this post recently to remind myself about one aspect and realise the way I declare the unique_ptr with a deleter can be simplified to avoid function pointer declarations (which were never very self-explanatory). It just consists of creating the lambda first, then simply using decltype to add the lambda as the template parameter:<\/p>\n
\r\nauto dt = []( Foo *f ) {\r\n  delete f;\r\n  std::cout << "Deleter called\\n";\r\n  };\r\nstd::unique_ptr<Foo, decltype(dt)> p( new Foo, dt );\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
C++11 gives us two useful indispensable smart pointers, std::unique_ptr and std::shared_ptr. So much has been written about these that there’s no point me re-hashing anything other than to re-iterate that if you are using “naked” owning pointers in your code these days, you are simply doing it wrong. I wanted to mention briefly the use … <\/p>\n
Continue reading “C++ Custom Deleters: unique_ptr vs shared_ptr”<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[17],"tags":[],"_links":{"self":[{"href":"https:\/\/www.martyndavis.com\/index.php?rest_route=\/wp\/v2\/posts\/474"}],"collection":[{"href":"https:\/\/www.martyndavis.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.martyndavis.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.martyndavis.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.martyndavis.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=474"}],"version-history":[{"count":27,"href":"https:\/\/www.martyndavis.com\/index.php?rest_route=\/wp\/v2\/posts\/474\/revisions"}],"predecessor-version":[{"id":574,"href":"https:\/\/www.martyndavis.com\/index.php?rest_route=\/wp\/v2\/posts\/474\/revisions\/574"}],"wp:attachment":[{"href":"https:\/\/www.martyndavis.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=474"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.martyndavis.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=474"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.martyndavis.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=474"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}