Ручно имитирует влияние оператора delete на C++ формально незаконным?

Question

Я понимаю, что это опрометчиво, и я не предлагаю, чтобы сделать это, но мне интересно, является ли следующее фактически формально незаконны:

#include <iostream> 

struct X 
{ 
    ~X() 
    { 
     std::cout << "~X()\n"; 
    } 
}; 

int main() 
{ 
    X *x = new X; 
    //delete x; 
    x->~X(); 
    ::operator delete(x); 
    return 0; 
} 

Это мое понимание того, что delete x; эквивалентно вызывая деструктор, а затем вызывая ::operator delete(x);, но разве это законно для меня делать это вручную в соответствии со стандартом? Я знаю, что это правильная вещь при использовании нового места размещения, но как насчет случая без места размещения? Моя догадка в том, что это может быть незаконно, потому что delete (а не operator delete) должно выполняться для каждого new, но мне было бы интересно узнать наверняка.

Answer 1

Я уверен, что это не соответствует стандарту. Нигде в стандарте (что я знаю) это говорит о том, что операнд delete p; передается непосредственно функции дезактивации, а для delete [] он почти наверняка не прошел без изменений.

Однако это, вероятно, будет работать на всех практических реализациях.

Наверняка, вы не должны называть глобальную функцию освобождения памяти явно. Это хорошо в вашем примере, который не имеет определяемых пользователем функций распределения и освобождения, но не в общем случае (на самом деле, есть ли какой-либо синтаксис для вызова функции освобождения класса, если она существует, а глобальная - в противном случае?).

Кроме того, в общем случае указатель, переданный функции освобождения, определенно не является операндом удаления. Рассмотрим:

struct A 
{ 
    virtual ~A() {} 
}; 

struct B1 : virtual A {}; 

struct B2 : virtual A {}; 

struct B3 : virtual A {}; 

struct D : virtual B1, virtual B2, virtual B3 {}; 

struct E : virtual B1, virtual D {}; 

int main(void) 
{ 
    B3* p = new D(); 
    p->~B3(); // should be ok, calling virtually 
    operator delete(p); // definitely NOT OK 

    return 0; 
} 

Answer 2

Я считаю, что вы не вызываете неопределенное поведение, если вы вызываете деструктор и освобождаете память.

Answer 3

Я думал, что

::operator delete(x); 

такой же, как

delete x; 

если метод delete не переопределен X?

Answer 4

Если вы собираетесь этот путь, вы должны заменить

X *x = new X; 

по

X* x = static_cast<X*>(::operator new(sizeof(X))); 

try { new(x) X; } 
catch (...) { ::operator delete(x); throw; } 

который должен быть (пожалуйста, поправьте меня, если я ошибаюсь) последовательны с вашим разрушение, и почти эквивалент по функциональности new.

Answer 5

@StuartGolodetz

Ответ, и ответ на комментарий

Там также может быть какой-то шаблон метапрограммированием можно сделать, чтобы убедиться, что глобальный называется иначе, но я не эксперт по этому вопросу. Вероятно, это что-то вроде SFINAE, если можно, я думаю.

 
struct B { 
    virtual ~B(); 
}; 

struct D : B { 
    operator new (size_t); 
    operator delete (void*); 
}; 

B *p = new D; 

decltype(typeid(*p))::operator delete (...); // hypothetical C++++ 

Meta это!