There is no way to get the runtime to tell you the number of elements in the array. All you can do is (as you know) use `delete[]` to call the appropriate number of destructors.

You can of course solve this problem "the hard way": instead of using `new[]`, you write a function that calls `operator new[]` with the appropriate size (including space for an extra size_t at the beginning, where the number of elements is stored), writes the size, uses placement new to initialize each element of the array, then returns a pointer to the first element. This is of course what `new[]` is doing anyway, and the standard library containers all do similar things (none of them use `new[]`), since they need to be able to precisely control when object lifetimes begin and end. Now the deleter knows exactly how to look up the size.

On Thu, Jul 25, 2019 at 9:05 AM Aleksey Demakov via Std-Discussion <> wrote:
Hi all,

With a custom allocator I can use user-defined placement new for
objects and arrays alike.

void *operator new (std::size_t size, Arena& arena) { return
arena.alloc(size); }
void *operator new[] (std::size_t size, Arena& arena) { return
arena.alloc(size); }

MyObj { ~MyObj() {} }

std::unique_ptr<MyObj, MyDeleter> ptr(new (arena) MyObj, MyDeleter(arena));
std::unique_ptr<MyObj[], MyArrayDeleter> arr(new (arena) MyObj[n],

Now I can easily provide a deleter for a single object.

struct MyDeleter {
 Arena& arena;
 MyDeleter(Arena& a) : arena(a) {}
 void operator()(MyObj *ptr) {

But I have a problem with providing a deleter for arrays.

As far as I understand the C++ runtime calls operator new[] with the
size argument that accommodates the array itself and its size. The
runtime stores the size and constructs the required number of items.
If the delete[] operator is applied to the array then the size is used
by the runtime to destruct the items one by one.

But this information seems to be totally inaccessible to user if there
is a need to destruct the array manually.

struct MyArrayDeleter {
  Arena& arena;
  MyArrayDeleter(Arena& a) : arena(a) {}
  void operator()(MyObj *arr) {
    // OOPS, lost here:  for (std::size_t i = 0; i < UNKNOWN_SIZE;
i++) arr[i].~MyObj();;

Obviously it's possible to explicitly store the array size one more
time in MyArrayDeleter.

struct MyArrayDeleter {
  Arena& arena;
  std::size_t size;
  MyArrayDeleter(Arena& a, std::size_t n) : arena(a), size(n) {}
  void operator()(MyObj *arr) {
    for (std::size_t i = 0; i < size; i++) arr[i].~MyObj();;

This is somewhat bug-prone however. There are two (runtime-managed and
user-managed) copies of the array size. One needs to be careful to
supply the same number to the new operator and to the deleter. Not to
mention it takes a few extra bytes of storage.

Is there a way to solve this issue in standard C++ without such deficiencies?

Std-Discussion mailing list

Brian Bi