shared-ptr - w3toppers.com

Conversion from boost::shared_ptr to std::shared_ptr?

Based on janm’s response at first I did this: template<class T> std::shared_ptr<T> to_std(const boost::shared_ptr<T> &p) { return std::shared_ptr<T>(p.get(), [p](…) mutable { p.reset(); }); } template<class T> boost::shared_ptr<T> to_boost(const std::shared_ptr<T> &p) { return boost::shared_ptr<T>(p.get(), [p](…) mutable { p.reset(); }); } But then I realized I could do this instead: namespace { template<class SharedPointer> struct Holder { … Read more

Problems using member function as custom deleter with std::shared_ptr

std::shared_ptr<SDL_Surface>(SDL_LoadBMP(….), [=](SDL_Surface* surface) { std::cout << “Deleting surface\n”; SDL_FreeSurface(surface); }); or void DeleteSurface(SDL_Surface* surface) { std::cout << “Deleting surface\n”; SDL_FreeSurface(surface); } std::shared_ptr<SDL_Surface>(SDL_LoadBMP(….), DeleteSurface); EDIT: Seeing your updated question, DeleteSurface should be a non-member function, otherwise you need to use std::bind or std::mem_fn or some other member function pointer adapter.

Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?

std::unique_ptr is the C++11 way to express exclusive ownership, but one of its most attractive features is that it easily and efficiently converts to a std::shared_ptr. This is a key part of why std::unique_ptr is so well suited as a factory function return type. Factory functions can’t know whether callers will want to use exclusive … Read more

Private constructor and make_shared

As mentioned, std::make_shared or its component parts don’t have access to private members. the call_once and once_flag are un-necessary. They are implicit in c++11 static initialisation, You normally would not want to expose the shared pointer. class MyClass { MyClass() {} public: static MyClass& GetInstance() { static auto instance = MyClass(); return instance; } … Read more

What is the cyclic dependency issue with shared_ptr?

The problem isn’t that complex. Let –> represent a shared pointer: The rest of the program –> object A –> object B ^ | \ | \ v object C So we’ve got ourselves a circular dependency with shared pointers. What’s the reference count of each object? A: 2 B: 1 C: 1 Now suppose … Read more

weak_ptr, make_shared and memory deallocation

Is my understanding correct? Yes. If your weak_ptrs significantly outlive the (large) object and you are tight on memory, it may be beneficial to avoid make_shared. However, “large” here is measured by sizeof, and many conceptually “large” objects (for example, most standard containers, except std::array) are quite small by that metric, because they allocate additional … Read more

Using shared_ptr in dll-interfaces

An answer to your first question: The virtual destructor in your dll is called – the information about its location is embedded in your object (in the vtable). In the case of memory deallocation it depends how disciplined the users of your IBase are. If they know they have to call Release() and consider that … Read more

shared_ptr: horrible speed

shared_ptr are the most complicated type of pointer ever: Ref counting takes time Multiple allocation (there are 3 parts: the object, the counter, the deleter) A number of virtual methods (in the counter and the deleter) for type erasure Works among multiple threads (thus synchronization) There are 2 ways to make them faster: use make_shared … Read more

Why does unique_ptr take two template parameters when shared_ptr only takes one?

If you provide the deleter as template argument (as in unique_ptr) it is part of the type and you don’t need to store anything additional in the objects of this type. If deleter is passed as constructor’s argument (as in shared_ptr) you need to store it in the object. This is the cost of additional … Read more

Example to use shared_ptr?

Using a vector of shared_ptr removes the possibility of leaking memory because you forgot to walk the vector and call delete on each element. Let’s walk through a slightly modified version of the example line-by-line. typedef boost::shared_ptr<gate> gate_ptr; Create an alias for the shared pointer type. This avoids the ugliness in the C++ language that … Read more