Question: I am reading "Effective Modern C++". In the item related to `std::unique_ptr` it's stated that if the custom deleter is a stateless object, then no size fees occur, but if it's a function pointer or `std::function` size fee occurs. Could you explain why?

Let's say that we have the following code:

```
auto deleter_ = [](int *p) { doSth(p); delete p; };
std::unique_ptr<int, decltype(deleter_)> up(new int, deleter_);

```

To my understanding, the `unique_ptr` should have an object of type `decltype(deleter_)` and assign `deleter_` to that internal object. But obviously that's not what's happening. Could you explain the mechanism behind this using smallest possible code example?

Answer: 
If the deleter is stateless there's no space required to store it. If the deleter is not stateless then the state needs to be stored in the `unique_ptr` itself.  

`std::function` and function pointers have information that is only available at runtime and so that must be stored in the object alongside the pointer the object itself. This in turn requires allocating (in the `unique_ptr` itself) space to store that extra state.

Perhaps understanding the [Empty Base Optimization](http://en.cppreference.com/w/cpp/language/ebo) will help you understand how this could be implemented in practice.  

The [`std::is_empty`](http://en.cppreference.com/w/cpp/types/is_empty) type trait is another possibility of how this could be implemented.

How exactly library writers implement this is obviously up to them and what the standard allows.
In fact there *will* be a size penalty for lambdas that are not stateless, i.e., lambdas that capture one or more values.

But for non-capturing lambdas, there are two key facts to notice:

* The type of the lambda is *unique* and known only to the compiler.
* Non-capturing lambdas are stateless.

Therefore, the compiler is able to invoke the lambda purely based on its *type*, which is recorded as part of the type of the `unique_ptr`; no extra *runtime* information is required.

This is in fact why non-capturing lambdas are stateless. In terms of the size penalty question, there is of course nothing special about non-capturing lambdas compared to any other stateless deletion functor type.

Note that `std::function` is *not* stateless, which is why the same reasoning does *not* apply to it.

Finally, note that although stateless objects are typically required to have nonzero size in order to ensure that they have unique addresses, stateless base classes are *not* required to add to the total size of the derived type; this is called the empty base optimization. Thus `unique_ptr` can be implemented (as in Bo Perrson's answer) as a type that derives from the deleter type, which, if it's stateless, will not contribute a size penalty. (This may in fact be the *only* way to correctly implement `unique_ptr` without a size penalty for stateless deleters, but I'm not sure.)