In theory, you should use unique_ptr for all pointers unless you know you want to share it, in which case you should use shared_ptr. The reason is that unique_ptr has less overhead since it doesn’t count references. However, a unique_ptr is movable but not copyable, so using one as a member variable can require you … Read more
The proposal makes it pretty clear that it’s just for self-documentation: This paper proposes observer_ptr, a (not very) smart pointer type that takes no ownership responsibility for its pointees, i.e., for the objects it observes. As such, it is intended as a near drop-in replacement for raw pointer types, with the advantage that, as a … Read more
A feasible workaround for google mock framework’s problems with non (const) copyable function arguments and retun values is to use proxy mock methods. Suppose you have the following interface definition (if it’s good style to use std::unique_ptr in this way seems to be more or less a philosophical question, I personally like it to enforce … Read more
In addition to Mark Ransom’s answer, a unique_ptr<X, D> might not even store an X*. If the deleter defines the type D::pointer then that’s what is stored, and that might not be a real pointer, it only needs to meet the NullablePointer requirements and (if unique_ptr<X,D>::get() is called) have an operator* that returns X&, but … Read more
UPDATE 2: This bug has been fixed in Clang in r191150. GCC rejects the code with a proper error message. UPDATE: I have submitted a bug report. The following code on my machine with clang++ 3.4 (trunk 191037) #include <iostream> #include <memory> int main() { std::unique_ptr<int> u_ptr(new int(42)); std::cout << ” u_ptr.get() = ” << … Read more
The question is a bit old, but I figured I would take the time to link to my smart pointer library for GNU compilers (GCC, Clang, ICC, MinGW, …). This implementation relies on the cleanup variable attribute, a GNU extension, to automatically free the memory when going out of scope, and as such, is not … Read more
You have two options to retrieve a reference to the object pointed to by a shared_ptr. Suppose you have a shared_ptr variable named ptr. You can get the reference either by using *ptr or *ptr.get(). These two should be equivalent, but the first would be preferred. The reason for this is that you’re really attempting … 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.
Personally, this is how I (more or less) do it: unique_ptrs are for sole ownership raw pointers mean whoever gave me the raw pointer guarantees the lifetime of that object to match or exceed my lifetime. shared_ptrs are for shared ownership weak_ptrs are for when a system wants to check if the object still exists … Read more
Use the get() method: boost::shared_ptr<foo> foo_ptr(new foo()); foo *raw_foo = foo_ptr.get(); c_library_function(raw_foo); Make sure that your shared_ptr doesn’t go out of scope before the library function is done with it — otherwise badness could result, since the library may try to do something with the pointer after it’s been deleted. Be especially careful if the … Read more