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: 
A `unique_ptr` must always store its deleter. Now, if the deleter is a class type with no state, then the `unique_ptr` can make use of [empty base optimization](http://en.cppreference.com/w/cpp/language/ebo) so that the deleter does not use any additional space.

How exactly this is done differs between implementations. For instance, both [libc++](http://llvm.org/svn/llvm-project/libcxx/trunk/include/memory) and MSVC store the managed pointer and the deleter in a [compressed pair](http://www.boost.org/doc/libs/release/libs/utility/doc/html/compressed_pair.html), which automatically gets you empty base optimization if one of the types involved is an empty class.

From the libc++ link above

```
template <class _Tp, class _Dp = default_delete<_Tp> >
class _LIBCPP_TYPE_VIS_ONLY unique_ptr
{
public:
    typedef _Tp element_type;
    typedef _Dp deleter_type;
    typedef typename __pointer_type<_Tp, deleter_type>::type pointer;
private:
    __compressed_pair<pointer, deleter_type> __ptr_;

```

libstdc++ [stores the two](https://github.com/gcc-mirror/gcc/blob/8ced49657ce78d11e6bb72780939245ee8105ae7/libstdc%2B%2B-v3/include/bits/unique_ptr.h#L155) in an `std::tuple` and some Google searching suggests their `tuple` implementation employs empty base optimization but I can't find any documentation stating so explicitly.

In any case, [this example](http://coliru.stacked-crooked.com/a/e86bdf01d34d12d3) demonstrates that both libc++ and libstdc++ use EBO to reduce the size of a `unique_ptr` with an empty deleter.
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.)