Exception safety with allocators in any

[EricWF]

static void clone (data_type const& source, data_type& data) {
    allocator_type alloc { };
    auto const& value = *static_cast<Type* const>(source);
    auto pointer = allocator_traits::allocate(alloc, 1);
    allocator_traits::construct(alloc, pointer, value);
    data = pointer;
  }

If the construction throws, the allocated memory is leaked. The best way (I've seen) to work around this issues is to store the allocated memory in a unique_ptr with a custom dtor that simply calls allocator::deallocate.

For reference here is how I solved this problem in my any implementation (Which is based off of libc++'s std::function).

storage_base* copy() const
{
    using NewAlloc = typename Alloc::template rebind<storage_type>::other;
    NewAlloc a(m_pair.second());
    using Dtor = allocator_destructor<NewAlloc>;
    std::unique_ptr<storage_type, Dtor> tmp(a.allocate(1), Dtor(a, 1));
    ::new ((void*)tmp.get()) storage_type(
        m_pair.first(), Alloc(a)
        );
    return tmp.release();
}

[tarqd]

Could also use a scope guard, no need to hit the heap for that (plus there's one in this library!). Basically the equivalent of:

static void clone (data_type const& source, data_type& data) {
    struct scope_guard { 
        allocator_type& m_alloc; 
        typename allocator_traits::pointer m_ptr;
        bool dismissed = false; 
         void dismiss() { dismissed = true; }
        ~scope_guard() { if (!dismissed) allocator_traits::deallocate(m_alloc, m_ptr); }
    };
    allocator_type alloc { };
    auto const& value = *static_cast<Type* const>(source);
    auto pointer = allocator_traits::allocate(alloc, 1);
    scope_guard guard { alloc, pointer };
    allocator_traits::construct(alloc, pointer, value);
    guard.dismiss(); // if an exception throws, the memory will be deallocated in the guard dtor
    data = pointer;
  }

[EricWF]

Seems like a very reasonable way to do it without having to add a new class. What do you by "no need to hit the heap"?

[tarqd]

Whoops for some reason I thought unique_ptr would be making a heap allocation but obviously it doesn't. It's been a long day haha. It does fit the use-case for scope_guard very nicely though (basically unique_ptr is acting like one).

Essentially both of our examples are doing the same thing, but with the scope_guard in this library (after it adds dismissal support) it'd be

static void clone (data_type const& source, data_type& data) {
    allocator_type alloc { };
    auto const& value = *static_cast<Type* const>(source);
    auto pointer = allocator_traits::allocate(alloc, 1);
    auto guard = make_scope_guard([&] { allocator_traits::deallocate(alloc, pointer); });
    allocator_traits::construct(alloc, pointer, value);
    guard.dismiss(); // if an exception throws, the memory will be deallocated in the guard dtor
    data = pointer;
  }