Why is there no std::allocate_unique function in C++14?

Question

Why does shared_ptr have allocate_shared while unique_ptr does not have allocate_unique?
I would like to make a unique_ptr using my own alloc

Answer 1

do I have to allocate the buffer myself and then assign it to a unique_ptr?

Not just a buffer, a pointer to an object. But the object might need to be destroyed by the allocator, and the memory definitely needs to deallocated by the allocator, so you also need to pass the allocator the the unique_ptr. It doesn't know how to use an allocator, so you need to wrap it in a custom deleter, and that becomes part of the unique_ptr's type.

I think a generic solution would look something like this:

#include 

template
struct alloc_deleter
{
  alloc_deleter(const Alloc& a) : a(a) { }

  typedef typename std::allocator_traits::pointer pointer;

  void operator()(pointer p) const
  {
    Alloc aa(a);
    std::allocator_traits::destroy(aa, std::addressof(*p));
    std::allocator_traits::deallocate(aa, p, 1);
  }

private:
  Alloc a;
};

template
auto
allocate_unique(const Alloc& alloc, Args&&... args)
{
  using AT = std::allocator_traits;
  static_assert(std::is_same>{}(),
                "Allocator has the wrong value_type");

  Alloc a(alloc);
  auto p = AT::allocate(a, 1);
  try {
    AT::construct(a, std::addressof(*p), std::forward(args)...);
    using D = alloc_deleter;
    return std::unique_ptr(p, D(a));
  }
  catch (...)
  {
    AT::deallocate(a, p, 1);
    throw;
  }
}

int main()
{
  std::allocator a;
  auto p = allocate_unique(a, 0);
  return *p;
}