Completely rewriting this answer because I totally misunderstood. This is a tricky thing to get right! The usual implementation of std::weak_ptr and std::shared_ptr that is consistent with the standard is to have two heap objects: the managed object, and a control block. Each shared pointer that refers to the same object contains a pointer to … Read more
As others have pointed out, you’ve got it figured out correctly regarding your original 3 questions. But the ending part of your edit Calling reset() in thread IV will delete previous instance of A class created in first thread and replace it with new instance? Moreover after calling reset() in IV thread other threads will … Read more
With C++17, shared_ptr can be used to manage a dynamically allocated array. The shared_ptr template argument in this case must be T[N] or T[]. So you may write shared_ptr<int[]> sp(new int[10]); From n4659, [util.smartptr.shared.const] template<class Y> explicit shared_ptr(Y* p); Requires: Y shall be a complete type. The expression delete[] p, when T is an array … Read more
The shared state co-owned by shared pointers also contains a deleter, a function like object that is fed the managed object at the end of its lifetime in order to release it. We can even specify our own deleter by using the appropriate constructor. How the deleter is stored, as well as any type erasure … Read more
std::make_shared is just a simple template function that creates the objects, passing all arguments to the constructor : template<class T, class… Args> shared_ptr<T> make_shared(Args&&… args) { return shared_ptr<T>( new T( std::forward<Args>( args )… ) ); } In your particular case : std::shared_ptr<Event> o = std::make_shared<Event>(*e); the object is copied. If your code is such : … Read more
Consider the following code: // global variable std::shared_ptr<int> s = std::make_shared<int>(); // thread 1 if (s && s.unique()) { // modify *s } // thread 2 auto s2 = s; Here we have a classic race condition: s2 may (or may not) be created as a copy of s in thread 2 while thread 1 … Read more
This is a result of holding p as a shared_ptr, using InSequence and the order in which you have declared your expectations. When you call EXPECT_CALL(*c, myMethod(Eq(p))); you increase the use_count of p. In order for the leak detection to pass, p must be destroyed at (or before) the end of TEST. The problem here … Read more
There should be no problem with using boost::shared_ptr as long as you initialize your shared pointers correctly and use the same memory management context for all your shared object libraries. In your case you are trying to use an uninitialized shared pointer. boost::shared_ptr<Obj> obj; obj->Something(); // assertion failed boost::shared_ptr<Obj> obj(new Obj); obj->Something(); // ok I … Read more
Your question isn’t clear. If you’ve allocated a shared_ptr dynamically then you’re certainly allowed to delete it whenever you want. But if you’re asking whether you’re allowed to delete whatever object is being managed by the shared_ptr, then the answer is … it depends. If shared_ptr::unique returns true, then calling shared_ptr::reset will delete the managed … Read more
Your code is quite correct (it works), but you can use the initialization list, like this: C::C() : mA(new A), mB(new B(mA.get()) { } Which is even more correct and as safe. If, for whatever reason, new A or new B throws, you’ll have no leak. If new A throws, then no memory is allocated, … Read more