There is no “right” way. It really depends on the context. You can internally handle memory with a smart pointer and externally give references or raw pointers. After all, the user of your interface doesn’t need to know how you manage memory internally. In a synchronous context this is safe and efficient. In an asynchronous … Read more
So shared ptr and weak ptr are thread safe, in that if you have an instance of the object local to a given thread, and they share a common pointed-to object, you can interact with them in one thread and another and everything works. For this to work properly, you have to use them properly. … Read more
All of the make_* functions use value-initialization for the type if you don’t provide constructor parameters. Since the array-form of make_unique doesn’t take any parameters, it will zero-out the elements.
Unfortunately, they don’t know what delete to use therefore they use delete. That’s why for each smart pointer we have a smart array counterpart. std::shared_ptr uses delete std::shared_array uses delete[] So, your line std :: unique_ptr <int> x (new int [2]); actually causes undefined behavior. Incidentally, if you write std :: unique_ptr<int[]> p(new int[2]); ^^ … Read more
Don’t use raw pointers, use std::unique_ptr like this: std::vector<std::unique_ptr<Fruit>> m_fruits; And as you can’t copy construct a std::unique_ptr you must use emplace_back (although you can use push_back with std::move). m_fruits.emplace_back(new Pear()); m_fruits.emplace_back(new Tomato()); Edit: As it appears that using std::vector<std::unique_ptr<T>>::emplace_back and new can leak if the std::vector needs and fails to reallocate memory, my recommended … Read more
What about: auto deleter=[&](int* ptr){…}; std::unique_ptr<int[], decltype(deleter)> ptr4(new int[4], deleter);
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
It will call delete[] and hence the entire array will be reclaimed but I believe you need to indicate that you are using an array form of unique_ptrby: std::unique_ptr<int[]> my_array(new int[5]); This is called as Partial Specialization of the unique_ptr.
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