Why shared ptr

When the last "reference" to the object is destroyed, the object is deleted. Reference counted pointers are very useful when the lifetime of your object is much more complicated, and is not tied directly to a particular section of code or to another object. There is one drawback to reference counted pointers — the possibility of creating a dangling reference:. A smart pointer is a pointer-like type with some additional functionality, e. This helps avoiding memory leaks and is easy to use to implement RAII.

Josuttis , chapter Chapter Smart Pointers. Some topics covered:. Definitions provided by Chris, Sergdev and Llyod are correct. Which means that your object semantically looks like a pointer but you can make it do way cooler things, including reference counting, automatic destruction etc.

Objects that must be allocated with new, but that you'd like to have the same lifetime as something on that stack. Data members of classes, so that when the object is deleted all the owned data is deleted as well, without any special code in the destructor you will need to be sure the destructor is virtual, which is almost always a good thing to do. A smart pointer is an object that acts like a pointer, but additionally provides control on construction, destruction, copying, moving and dereferencing.

One can implement one's own smart pointer, but many libraries also provide smart pointer implementations each with different advantages and drawbacks. For example, Boost provides the following smart pointer implementations:.

These are just one linear descriptions of each and can be used as per need, for further detail and examples one can look at the documentation of Boost. Most kinds of smart pointers handle disposing of the pointer-to object for you. It's very handy because you don't have to think about disposing of objects manually anymore. A smart pointer is an object that acts, looks and feels like a normal pointer but offers more functionality.

They have a number of advantages over regular pointers. They are guaranteed to be initialized as either null pointers or pointers to a heap object. Indirection through a null pointer is checked. No delete is ever necessary. Objects are automatically freed when the last pointer to them has gone away. One significant problem with these smart pointers is that unlike regular pointers, they don't respect inheritance. Smart pointers are unattractive for polymorphic code. Given below is an example for the implementation of smart pointers.

This class implement a smart pointer to an object of type X. The object itself is located on the heap. Here is how to use it:. In computer science, a smart pointer is an abstract data type that simulates a pointer while providing additional features, such as automatic garbage collection or bounds checking. These additional features are intended to reduce bugs caused by the misuse of pointers while retaining efficiency.

Smart pointers typically keep track of the objects that point to them for the purpose of memory management. The misuse of pointers is a major source of bugs: the constant allocation, deallocation and referencing that must be performed by a program written using pointers makes it very likely that some memory leaks will occur.

Smart pointers try to prevent memory leaks by making the resource deallocation automatic: when the pointer to an object or the last in a series of pointers is destroyed, for example because it goes out of scope, the pointed object is destroyed too. They hold a memory address to a location in memory. Use with caution , as programs become complex hard to keep track. Pointer to a data type T which is a const. Meaning you cannot change the data type using the pointer.

But you can move the pointer. Read backwards : pointer to type T which is const. A const pointer to a data type T. Meaning you cannot move the pointer but you can change the value pointed to by the pointer. Read backwards : const pointer to a type T.

A const pointer to a const data type T. Meaning you cannot either move the pointer nor can you change the data type pointer to be the pointer. The inheritance example above is rather contrived. Nevertheless, the destructor should be declared virtual in the classes that are meant to be used polymorphically. For instance:. The in-depth treatment of aliasing constructor deserves its own space. There is more discussion about the managed object pointer in the 'Deleter' section below when we talk about the type erasure.

We mentioned above that the control block could either contain a pointer to the managed object or the object itself. The control block is dynamically allocated. Constructing the managed object in-place within the control block can avoid the two separate memory allocations for the object and the control block, resulting in an uncomplicated control block and better performance. The managed object is disposed of when the reference count reaches zero. Whereas, the move assignment operator decreases the reference count of the destination LHS but does not change the reference count of the source RHS.

As you go through the code, refer the following figure for the different stages:. Pass the underlying pointer or a reference to the underlying object. This enables the callee to use the object, but doesn't enable it to share ownership or extend the lifetime. An "owner" is an object or function that can keep the underlying resource alive for as long as it needs it.

If the caller has to guarantee that the callee can extend the life of the pointer beyond its the function's lifetime, use the first option. If you don't care whether the callee extends the lifetime, then pass by reference and let the callee copy it or not. If you have to give a helper function access to the underlying pointer, and you know that the helper function will just use the pointer and return before the calling function returns, then that function doesn't have to share ownership of the underlying pointer.

Passing this way provides a small performance benefit, and may also help you express your programming intent.

Feedback will be sent to Microsoft: By pressing the submit button, your feedback will be used to improve Microsoft products and services.