C++11 provides smart pointer types that manage dynamic objects. A smart pointer acts like a regular pointer with an exception that it automatically deletes the object to which it points when it is appropriate to do so.
- shared_ptr – allows multiple pointers to refer to the same object.
- unique_ptr – “owns” the object to which it points.
- weak_ptr – a weak reference to an object managed by shared_ptr. (will not be discussed here)
If you don’t initialize a smart pointer, it will be default initialized with a “nullptr”:
shared_ptr<T> sp; // Null shared_ptr that can point to objects unique_ptr<T> up; // of type T.
Dereferencing a smart pointer, reveals the value of the smart pointer:
int val = *p;
When using a smart pointer in a condition, it is “true” if it points to an object and false otherwise:
if (p)
// use p
else
// p does not point to an object.
The safest way to allocate and use dynamic memory is to use a library function named “make_shared”, it constructs an object of type T and wraps it in a “shared_ptr”. It uses the arguments passed to it as the parameters for the constructor of T:
// shared_ptr<T> make_shared( Args&&... args ); // p points to a dynamically allocated 'int' // holding the value 42 auto p = make_shared<int>(42);
When there are no more pointers referring to an object the use count becomes 0 and the object will be deleted and the memory will be freed:
{
// p1 points to a dynamically allocated int
// holding value 0. The use count is 1.
auto p1 = make_shared<int>();
} // p1 goes out of scope. The memory to which p1 points
// is automatically freed.
The use count is incremented when we copy a shared_ptr. For example:
The associated counter is incremented when we use a shared_ptr to initialize another shared_ptr, when we use it as the right hand operand of an assignment, or when we pass it to – or return it from a function by value.
The counter is decremented when we assign a new value to the shared_ptr and when the shared_ptr itself is destroyed, such as when a local shared_ptr goes out of scope. Once the shared_ptr’s counter goes to zero, the shared_ptr automatically frees the object it manages:
auto p = make_shared<int>(42); auto q = make_shared<int>(); // assigning to q, making it point to a different address q = p; // increase the use count for the object to which p points. // decrease the use count for the object to which q had pointed. // the object that r had pointed to has no users, that object is // automatically freed.
The memory will not be freed if there are other shared_ptr’s pointing to it:
shared_ptr<int> func(int val)
{
auto p = make_shared<int>(val);
return p; // reference count is incremented when we return p.
} // function goes out of scope, the memory to which p points is not
// freed.
A unique_ptr “owns” the object to which it points. Unlike shared_ptr, only one unique_ptr at a time can point to a given object. The object to which the unique_ptr points is destroyed when the unique_ptr itself is destroyed.
Operations on unique_ptr:
// 'u1' uses 'delete' to free it's pointer. unique_ptr<T> u1; // 'u2' uses a callable object of type 'D' // to free it's pointer. unique_ptr<T, D> u2; // 'u3' is a null unique_ptr that can // point to an object of type 'T' // and uses 'u' which must be of // type 'D' to free the pointer // in place of 'delete' unique_ptr<T, D> u3(u); // deletes the object to which 'u' // points, makes 'u' null: u = nullptr; // releases control of the pointer // 'u' had held. Returns the pointer // 'u' had held and makes it null. u.release(); // deletes the object to which 'u' points. u.reset(); // if the built-in pointer 'q' is // supplied. Makes 'u' point to // that object. Otherwise, 'nullptr' u.reset(u); u.reset(nullptr);
In C++14, there is a library function comparable to make_shared which works for unique_ptr’s.
‘make_unique’ works like ‘make_shared’. Before C++14, you had to bind the unique_ptr to a pointer returned by ‘new’:
// before c++14: unique_ptr<int> p1(new int(42)); // with make_unique: unique_ptr<int> p1 = make_unique<int>(42); // with auto: auto p1 = make_unique<int>(42);
Also to mention, the smart pointer constructor that take pointers, are explicit. Therefore, we can’t implicitly convert a built-in pointer to a smart pointer. We must use direct initialization:
// error; must use direct initialization
shared_ptr<int> p1 = new int(42);
// OK: uses direct initialization
shared_ptr<int> p2(new int(42));
Since unique_ptr owns the object to which it points, it does not support copy or assignment:
unique_ptr p1(new string("Dinosaur"));
unique_ptr p2(p1); // error
unique_ptr p3 = p1;// error
Although we can’t copy or assign we can transfer ownership:
unique_ptr<int> p1(new int(42)); // transfers ownership from p1 to p2 // makes p1 null. unique_ptr<int> p2(p1.release());
unique_ptr<int> p1(new int(42));
unique_ptr<int> p2(new int(1));
unique_ptr<int> p3(new int(5));
// transfers ownership from p3
// to p2. makes p3 null.
// p2.reset() deletes memory
// to which p2 had pointed.
p2.reset(p3.release());
If we don’t use another smart pointer to hold the result from .release(), our program will take over responsibility for freeing that resource:
// Wrong, p1 won't free the memory // and we've lost the pointer. p1.release(); // Ok, but we must remember to // delete p2. auto p2 = p1.release();
C++ Blog 