Are there real use cases for smart pointers?

Question

I was reading about smart pointers in C++ and I am surprised that more than 99% of the given examples are in fact fairly bad examples because in those cases dynamic allocation could be avoided. I would agree to use smart pointers only in the context that STL containers wouldn't work. For instance in dynamic arrays (std::vector) performance matters so it is perhaps better to have well-tested code without any use of smart pointers.

Here what I consider a bad example because in this case unique_ptr isn't the solution, but stack allocation would be the proper way.

MyObject* ptr = new MyObject(); 
ptr->DoSomething(); 
delete ptr; 

So what could be good examples or uses for Smart Pointers in C++?

Said differently what design pattern would require to transfer the ownership of a pointer to another object?

Answer 1

I am surprised that more than 99% of the given examples are in fact fairly bad examples because in those cases dynamic allocation could be avoided

This is probably because the examples are intended to be super-simple.

So what could be good examples or uses for Smart Pointers in C++?

Never mind "goodness", but consider the following examples of cases where they're relevant:

1. When you can't hold on to the stack

template <typename T>
std::unique_ptr<T[]> print_and_allocate(std::size_t n)
{
    std::cout << "Allocating " << n << " elements of size " << sizeof(T) << '\n';
    return std::make_unique<T[]>(n);
}

you can't perform the allocation on the stack, because you're returning before your allocated element is used. Also, you can't just return a single constructed or an std::array, because the number of elements to allocate is not known in advance.

2. A need to refer to one of several possible subclasses

class A;
class B : public A { /* ... */ };
class C : public A { /* ... */ };

// ...

auto my_a = std::unique_ptr<A>(condition ? (A*) new B : (A*) new C);
my_a.some_virtual_method();

3. Complex de-allocation logic

A pointer doesn't tell you when/how it needs to be freed/deallocated. You can make a simple assumption ("I need to free the pointer I get from this function"), but this already suggests expressing your assumption in a wrapper class. If the conditions for de-allocation are more complex, and especially if the pointer recipient isn't aware of them, it becomes critical that they be communicated somehow. An std::shared_ptr or std::weak_ptr are two ways to do so; and another is an std::unique_ptr with a custom deleter.

4. When future usability not guaranteed

When the provider of the pointer can't guarantee it will continue to be valid, but expects that it likely will be - you need some kind of wrapper class to reflect that fact and to make sure you don't try to dereference the pointer when you actually can't. This is where std::weak_ptr() comes into play.

---

More generally: If you needed to allocate memory and hold a pointer before, for some reason, and couldn't make do without it - you most-probably want to switch to using a smart pointer instead. See also:

What is a smart pointer and when should I use one (answer).

Answer 2

So what could be good examples or uses for Smart Pointers in C++?

Any situation where you need to have a ressource on the heap.

You are right that most smart pointer examples would be written with a stack allocation in a real world scenario. But they are just that - simple examples to demonstrate the use/advantages of smart pointers.

In reality however, you can't place everything on the stack. And once you need dynamic memory allocation on the heap a smart pointer is almost always a better choice than a raw pointer with new/delete.

Answer 3

In real use cases you actually don't want to care about memory management. You don't want memory leaks because you forget one delete somewhere. Thats where smart pointers come in handy, since they lift the responsibility to clean up from you.