C++ is all about memory ownership - aka **ownership semantics**.

It is the responsibility of the owner of a chunk of dynamically allocated memory to release that memory. So the question really becomes who owns the memory.

In C++ ownership is documented by the type a *raw* pointer is wrapped inside thus in a good (IMO) C++ program it is very rare (*rare*, not *never*) to see raw pointers passed around (as raw pointers have no inferred ownership thus we can not tell who owns the memory and thus without careful reading of the documentation you can&#39;t tell who is responsible for ownership).

Conversely, it is rare to see raw pointers stored in a class each raw pointer is stored within its own smart pointer wrapper. (**N.B.:** If you don&#39;t own an object you should not be storing it because you can not know when it will go out of scope and be destroyed.)

So the question:

- What type of ownership semantic have people come across?
- What standard classes are used to implement those semantics?
- In what situations do you find them useful?

Lets keep 1 type of semantic ownership per answer so they can be voted up and down individually.

## Summary:

Conceptually, smart pointers are simple and a naive implementation is easy. I have seen many attempted implementations, but invariably they are broken in some way that is not obvious to casual use and examples. Thus I recommend always using well tested smart pointers from a library rather than rolling your own. `std::auto_ptr` or one of the Boost smart pointers seem to cover all my needs.


### `std::auto_ptr&lt;T&gt;`:

  Single person owns the object. Transfer of ownership is allowed.

  Usage: This allows you to define interfaces that show the explicit transfer of ownership.

### `boost::scoped_ptr&lt;T&gt;`

  Single person owns the object. Transfer of ownership is NOT allowed.

  Usage: Used to show explicit ownership. Object will be destroyed by destructor or when explicitly reset.

### `boost::shared_ptr&lt;T&gt;` (`std::tr1::shared_ptr&lt;T&gt;`)

  Multiple ownership. This is a simple reference counted pointer. When the reference count reaches zero, the object is destroyed.

  Usage: When an object can have multiple owers with a lifetime that can not be determined at compile time.

### `boost::weak_ptr&lt;T&gt;`:

  Used with `shared_ptr&lt;T&gt;` in situations where a cycle of pointers may happen.

  Usage: Used to stop cycles from retaining objects when only the cycle is maintaining a shared refcount.


All Ownership Semantics Solutions on Gang of Coders

Total of 1 Ownership Semantics Solutions

Smart pointers: who owns the object?