Предположим, я написал свой operator new/new[] с тегом-параметром, который выделяет память так, как мне надо

struct SInterthreadAllocTag {};
static SInterthreadAllocTag InterthreadAllocTag;

inline void *operator new(size_t size, SInterthreadAllocTag)
{
    return malloc(size);
}

inline void *operator new[](size_t size, SInterthreadAllocTag)
{
    return malloc(size);
}

Так же я написал operator delete:

inline void operator delete(void *p, SInterthreadAllocTag)
{
    free(p);
}

inline void operator delete[](void *p, SInterthreadAllocTag)
{
    free(p);
}

теперь я могу написать так:

class MyClass 
{
};

...
{
    MyClass *p_my_class = new(InterthreadAllocTag) MyClass;
}

как мне теперь вызвать delete?

Вот так не компилируется

delete(InterthreadAllocTag) p_my_class;

Вот так не вызывается деструктор:

operator delete(p_my_class, InterthreadAllocTag);

Я написал шаблонную функцию, которая заместо operator delete вызывает деструктор:

template <class T>
void InterthreadFree(T *p)
{
    p->~T();
    operator delete(p, InterthreadAllocTag);
}

С ее помощью я могу удалить то, что было выделено по new.
Но как мне удалять то, что было выделено по new[]? Я же не знаю, сколько деструкторов вызвать. Как же в С++ не учли такой простой вещи, вызов своего operator delete[] ?

Здравствуйте, _Winnie, Вы писали:

Никак. Тебе придётся отказаться от идеи параметризовать new[]/delete[].
Почему не учли в стандарте этот случай -- ответ тоже известен. Слишком сильно были увлечены внедрением STL в стандарт, на все остальные "мелочи" времени не хватило.

Копай Нео, копай -- летать научишься. © Matrix. Парадоксы

Здравствуйте, _Winnie, Вы писали:

Оператор delete с такой сигнатурой будет вызван неявно, если после выделения памяти парным ему оператором new при конструировании массива объектов возникнет исключение.
А тебе, действительно, остается либо самому разрушать объекты и писать прямой вызов operator delete(ptr, some_arg), либо перегрузить оператор operator delete[](void *) что тоже фигово, так как тогда он уже и в других случаях вызовется да еще и перегрузки operator new[](std::size_t) потребует.

А вот с операторами-членами класса такой проблемы не будет

L_L>А тебе, действительно, остается либо самому разрушать объекты и писать прямой вызов operator delete(ptr, some_arg), либо перегрузить оператор operator delete[](void *) что тоже фигово, так как тогда он уже и в других случаях вызовется да еще и перегрузки operator new[](std::size_t) потребует.
L_L>А вот с операторами-членами класса такой проблемы не будет

Заранее говорю, не знаю, что я этими предложениями сказать хотел (удалить не могу, какие-то проблемы с ТОРмозиллой)

Эээ... я думаю СТЛ тут ваще не при делах. А вот какая-то идиотская ассиметрия мне видится.

> Предположим, я написал свой operator new/new[] с тегом-параметром, который выделяет память так, как мне надо
>
> [c]
> struct SInterthreadAllocTag {};
> static SInterthreadAllocTag InterthreadAllocTag;
>
А зачем SInterthreadAllocTag передавать в operator delete, разве нужен он вам для удаления объекта , на его месте по стандарду должен быть int (size_t).