shared-ptr

I have a few containers in a class, for example, vector or map which contain shared_ptr's to objects living on the heap. For example template <typename T> class MyExample { public: private: vector<shared_ptr<T> > vec_; map<shared_ptr<T>, int> map_; }; I want to have a public interface of this class that sometimes returns shared_ptrs to const objects (via shared_ptr<const T> ) and sometimes shared_ptr<T> where I allow the caller to mutate the objects. I want logical const correctness, so if I mark a method as const, it cannot change the objects on the heap. Questions: 1) I am confused by the

Since C++11, because of several reasons, developers tend to use smart pointer classes for dynamic lifetime objects. And with those new smart pointer classes, standards, even suggest to not use operators like new instead they suggest to use make_shared or make_unique to avoid some error prone. If we like to use a smart pointer class, like shared_ptr , we can construct one like, shared_ptr<int> p(new int(12)); Also we would like to pass a custom deleter to smart pointer classes, shared_ptr<int> p(new int(12), deleter); On the other hand, if we like to use make_shared to allocate, for ex. int ,

I am writing intrusive shared pointer and I am using C++11 <atomic> facilities for reference counter. Here are the relevant fragments of my code: //... mutable std::atomic<unsigned> count; //... void SharedObject::addReference() const { std::atomic_fetch_add_explicit (&count, 1u, std::memory_order_consume); } void SharedObject::removeReference() const { bool destroy; destroy = std::atomic_fetch_sub_explicit (&count, 1u, std::memory_order_consume) == 1; if (destroy) delete this; } I have started with memory_order_acquire and memory_order_release first but then I convinced myself that memory

I'm working on a section of code that has many possible failure points which cause it to exit the function early. The libraries I'm interacting with require that C-style arrays be passed to the functions. So, instead of calling delete on the arrays at every exit point, I'm doing this: void SomeFunction(int arrayLength) { shared_ptr<char> raiiArray(new char[arrayLength]); pArray = raiiArray.get(); if(SomeFunctionThatRequiresCArray(pArray) == FAILED) { return; } //etc. } I wanted to use unique_ptr , but my current compiler doesn't support it and the reference count overhead doesn't really matter

Consider: struct SomethingThatsABase { virtual bool IsChildOne() const { return false; } virtual bool IsChildTwo() const { return false; } }; struct ChildOne : public SomethingThatsABase { virtual bool IsChildOne() const { return true; } }; struct ChildTwo : public SomethingThatsABase { virtual bool IsChildTwo() const { return true; } }; void SomeClientExpectingAChildOne(std::shared_ptr<ChildOne> const& ptrOne) { //Does stuff } void SomeClient(std::shared_ptr<SomethingThatsABase> const& ptr) { if (ptr->IsChildOne()) { SomeClientExpectingAChildOne(ptr); //Oops. //Hmm.. can't static_cast here,

In my current project I am using boost::shared_ptr quite extensively. Recently my fellow team mates have also started using weak_ptr . I don't know which one to use and when. Apart from this, what should I do if I want to convert weak_ptr to shared_ptr . Does putting a lock on weak_ptr to create a shared_ptr affect my code in other thread? Narfanator In general and summary, Strong pointers guarantee their own validity. Use them, for example, when: You own the object being pointed at; you create it and destroy it You do not have defined behavior if the object doesn't exist You need to enforce