shared-ptr

I have read through many questions on SO on custom deleter for shared_ptr and unique_ptr , and the difference between the two. But, I still haven't found any clear answer to this question: How can one best go about creating a type that acts as a shared_ptr with a custom deleter, similar to how unique_ptr has the deleter as part of the type definition? For unique_ptr usage, I use a deleter class, that handles deletion of individual types (limiting it to just two types, for brevity): struct SDL_Deleter { void operator()( SDL_Surface* ptr ) { if (ptr) SDL_FreeSurface( ptr );} void operator()( SDL

In C++, I can write something like: shared_ptr<A> a_sp = someFunctionReturningSharedPtr(); if (a_sp) { cout << a_sp->someData << endl; } else { cout << "Shared Pointer is NULL << endl; } Why does if (a_sp) check work correctly? a_sp is not a boolean, but how is it checked for true or false? How does the if condition know to check the result of a_sp.get() function? Or if it does not, how is the NULL ity of the a_sp checked? Is there some function in shared_ptr defined that converts it to boolean value? shared_ptr has an operator unspecified-bool-type() const that allows it to be used in boolean

Are there any differences between boost::shared_ptr , std::tr1::shared_ptr and the upcoming (in C++0x ) std::shared_ptr ? Will porting from one to another have any overhead or are they basically the same? According to the Boost website, the boost::shared_ptr ... ...conforms to the TR1 specification, with the only exception that it resides in namespace boost instead of std::tr1 . According to the Wikipedia C++0x page The TR1 implementation lacked certain pointer features such as aliasing and pointer arithmetic, but the C++0x version will add these. If your code works with the TR1/Boost version,

I'm using a std::shared_ptr<void> in my application to make a smart pointer which can point to many different types of data structures like structs, vectors, matrices... basically anything. What I'm trying to do is map some names to their data structures. I'm performing the mapping using a hashtable: std::unordered_map<std::string, std::shared_ptr<void>> Can I cast the std::shared_ptr<void> returned by find() back to std::shared_ptr<my_type> ? If so, how? More importantly, is this good practice? Will this increase the complexity too much as the application scales? Or, is there some other

Recently I discovered that shared_ptr does not have pointer to member operator ->* . I created simple example: template <typename Pointer, typename Function, typename... Args> auto invoke1(Pointer p, Function f, Args... args) -> decltype((p->*f)(args...)) { return (p->*f)(args...); } struct A { void g() { std::cout << "A::g()\n"; } }; int main() { A a; invoke1(&a, &A::g); // works!! std::shared_ptr<A> sa = std::make_shared<A>(); invoke1(sa, &A::g); // compile error!! } Q1: Why is so? Why shared_ptr does not have this operator? I added such operator for shared_ptr and the example started to

This question already has an answer here: shared_ptr magic :) 3 answers Why when using std::shared_ptr deallocation calls destructors from both base and derived classes when second example calls only destructor from base class? class Base { public: ~Base() { std::cout << "Base destructor" << std::endl; } }; class Derived : public Base { public: ~Derived() { std::cout << "Derived destructor" << std::endl; } }; void virtual_destructor() { { std::cout << "--------------------" << std::endl; std::shared_ptr<Base> sharedA(new Derived); } std::cout << "--------------------" << std::endl; Base * a =

I am currently having some troubles when using boost shared_from_this and multiple inheritance. The scenario can be described as follows: Class A implements some functionality and should inherit from shared_from_this Class B implements another functionality and should inherit from shared_from_this Class D inherits functionalities from A and B ( class D : public A, public B {} ) When using some class B functionality from class D I got an exception ( weak_ptr ) To inherit shared_from_this from class D is not an option for me I am not sure about how to solve this. Oh, I am using Visual C++ 2010.