shared-ptr

I have an existing variable, e.g. int a = 3; How can I now create a boost::shared_ptr to a ? For example: boost::shared_ptr< int > a_ptr = &a; // this doesn't work although you should put the variable into a managed pointer on it's creation to do it from an existing pointer. int *a=new int; boost::shared_ptr<int> a_ptr(a); That said you most definitely do not want to be putting stack variables into shared_ptr BAD THINGS WILL HAPPEN If for some reason a function takes shared_ptr and you only have a stack varaible you are better off doing this: int a=9; boost::shared_ptr<int> a_ptr=boost::make

I'm trying to wrap my head around the new idioms for C++11. It seems that with shared_ptr at least, there is a substantive difference between using new T() and make_shared<T>() . But what of resetting a shared pointer to point to a new instance of something. Previously, I would typically use reset(new T()) member. However, doesn't this suffer from the same problem as not using make_shared() in the first place? (i.e. it doesn't allow make_shared to allocate the object, therefore it is forced to place the ref count in a separate allocation instead of in the same allocation as the T itself?) Is

I want to compare two std::weak_ptr's or one std::weak_ptr and one std::shared_ptr for equality. What I want to know is whether the object each of the weak_ptr's/shared_ptr's point to is the same. The comparison should yield negative results not just if the addresses don't match, but also if the underlying object was deleted and then reconstructed with the same address by chance. So basically, I want this assertion to hold even if the allocator reserves the same address: auto s1 = std::make_shared<int>(43); std::weak_ptr<int> w1(s1); s1.reset(); auto s2 = std::make_shared<int>(41); std::weak

I want to use boost::log at some point, but I cannot pass a std::shared_ptr as a parameter, because the compiler (VS2010) cannot convert it into a boost::shared_ptr . I don't really like the fact that they are aliens to one another. Is there a safe and transparent way to convert one into the another, so as they don't stumble over each other? I don't think it is duplicate of this question that states both are the same. You could do it like this: template<typename T> boost::shared_ptr<T> make_shared_ptr(std::shared_ptr<T>& ptr) { return boost::shared_ptr<T>(ptr.get(), [ptr](T*) mutable {ptr

In the book The C++ Standard Library at page 91 I have read this about shared_from_this() : The problem is that shared_ptr stores itself in a private member of Person ’s base class, enable_shared_from_this<> , at the end of the construction of the Person. The relevant code snippet from the book is: class Person : public std::enable_shared_from_this<Person> { ... }; I don't understand two things here: who is this shared_ptr which stores itself? how he can store itself anywhere at the end of the construction of Person ? I think construction of Person ends up with the last statement of its