On Wed, Jan 22, 2020 at 11:04 PM Christian Mazakas via Boost <boost@lists.boost.org> wrote:
`boost::allocate_unique` is a significantly tougher class to beat because it boasts many of the same features: a dynamic allocation done using the supplied Allocator supporting `noinit` construction and
Correct so far.
array objects with a size (stored in the Deleter of the returned `std::unique_ptr`).
Wrong. The D in the unique_ptr<T, D> returned by allocate_unique() only stores the Allocator. The size for allocate_unique<T[]>() is stored in D::pointer. i.e. D::pointer is a pointer-like type (detail::alloc_ptr) that stores A::pointer and size. But for T[N] there's no need to store the size. D::pointer is a type that just stores A::pointer. Same for non-array T, there's no size stored. D::pointer is a type that just stores Only A::pointer Which means for arrays of sizes known at compile-time,: * dynamic_array<T, A> x(a, N); will store that extra size * auto x = allocate_unique<T[N]>(a); will not In addition to that, boost::allocate_unique() gives you almost everything else dynamic_array gives you: * Allocator aware * Supports construction from a value * Supports default-initialization (noinit) * Supports arrays of arrays
And while it is true that `boost::allocate_unique` enables all of this, it still lacks a few key semantics. Namely, `dynamic_array` is copyable. It's also copy assignable and move assignable,
Yes, this is the only difference. The question is if anyone needs this. i.e. When they reach for something lighter than vector<T, A> do they also want that type to be deep copyable/movable. If they do, such an adaptor over unique_ptr<T, D> could be useful sense. But if they just want to 'copy or move elements from the result of allocate_unique() that's also not difficult. Glen