Вызвать деструктор, а затем конструктор (сброс объекта)

Не ведитесь на тролля FQA. Он, как обычно, ошибается в фактах.

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

«Обычное» новое/удаление немного упрощает это, связывая выделение памяти и создание объекта вместе, а выделение стека упрощает его еще больше, делая и то, и другое за вас.

Однако совершенно законно следующее:

int foo() {
    CBar bar;
    (&bar)->~CBar();
    new (&bar) CBar(42);
 }

Оба объекта уничтожаются, а память стека также автоматически перерабатывается. однако, в отличие от утверждений FQA, первому вызову деструктора не предшествует размещение new.

Почему бы не реализовать метод Clear(), который делает все, что делает код в теле деструктора? Затем деструктор просто вызывает Clear(), а вы вызываете Clear() непосредственно для объекта, чтобы "сбросить его".

Другой вариант, если ваш класс правильно поддерживает назначение:

MyClass a;
...
a = MyClass();

Я использую этот шаблон для сброса экземпляров std::stack, поскольку адаптер стека не предоставляет четкую функцию.

С технической точки зрения явный вызов конструкторов или деструкторов является плохой практикой.

Ключевое слово удаления вызывает их, когда вы его используете. То же самое касается new с конструкторами.

Извините, но этот код заставляет меня рвать на себе волосы. Вы должны делать это так:

Выделить новый экземпляр объекта

AnObject* anObject = new AnObject();

Удалить экземпляр объекта

delete anObject;

НИКОГДА не делайте этого:

anObject->~AnObject(); // My step 1.
free(anObject)

Если вы должны «сбросить» объект, либо создайте метод, который очищает все переменные экземпляра внутри, либо я бы порекомендовал вам удалить объект и выделить себе новый.

"Это ядро ​​языка?"

Это ничего не значит. В Perl есть около шести способов написания цикла for. Тот факт, что вы МОЖЕТЕ делать что-то на языке, потому что он поддерживается, означает, что вы должны его использовать. Черт возьми, я мог бы написать весь свой код, используя операторы for switch, потому что «ядро» языка поддерживает их. Не делает это хорошей идеей.

Почему вы используете malloc, когда вам это явно не нужно. Malloc - это метод C.

Создать и удалить — ваши друзья в C++

«Сброс» объекта

myObject.Reset();

Ну вот. Таким образом, вы избавляетесь от ненужного выделения и освобождения памяти опасным образом. Напишите свой метод Reset(), чтобы очистить значение всех объектов внутри вашего класса.

Вы не можете вызвать конструктор указанным вами способом. Вместо этого вы можете сделать это, используя новое размещение (как также указывает ваш код):

new (anObject) AnObject();

Этот код гарантированно будет хорошо определен, если ячейка памяти все еще доступна — как и должно быть в вашем случае.

(Я удалил часть о том, является ли этот код дискуссионным или нет — он четко определен. Точка.)

Кстати, Брок прав: то, как реализация delete не исправлена ​​— это не то же самое, что и вызов деструктора, за которым следует free. Всегда соединяйте вызовы new и delete, никогда не смешивайте один с другим: это не определено.

Обратите внимание, что используются не malloc и free, а operator new и operator delete. Кроме того, в отличие от вашего кода, используя new, вы гарантируете безопасность исключений. Почти эквивалентный код будет следующим.

AnObject* anObject = ::operator new(sizeof(AnObject));
try
{
    anObject = new (anObject) AnObject();
}
catch (...)
{
    ::operator delete(anObject);
    throw;
}

anObject->~AnObject();
::operator delete(anObject)

Предлагаемая вами перезагрузка действительна, но не идиоматична. Это трудно понять правильно, и поэтому это обычно не одобряется и не одобряется.

Да, то, что вы делаете, действительно в большинстве случаев. [basic.life]p8 говорит:

Если после того, как время жизни объекта закончилось и до того, как хранилище, которое занимал объект, было повторно использовано или освобождено, новый объект создается в месте хранения, которое занимал исходный объект, указатель, указывающий на исходный объект, ссылка, которая относится к исходному объекту, или имя исходного объекта будет автоматически ссылаться на новый объект и, как только начнется время жизни нового объекта, может использоваться для управления новым объектом, если:

• хранилище для нового объекта точно перекрывает место хранения, которое занимал исходный объект, и

• новый объект имеет тот же тип, что и исходный объект (игнорируя cv-квалификаторы верхнего уровня), и

• тип исходного объекта не является константным, и, если тип класса, не содержит нестатических элементов данных, чей тип является константным или ссылочным типом, и

• ни исходный объект, ни новый объект не являются потенциально перекрывающимися подобъектами ([intro.object]).

Так что законно, если у вас нет const или ссылочного члена.

Если у вас нет этой гарантии, вам нужно использовать std::launder или использовать указатель, возвращаемый размещением new (как вы все равно делаете), если вы хотите использовать новый объект:

// no const/ref members
anObject->~AnObject(); // destroy object
new (anObject) AnObject(); // create new object in same storage, ok

anObject->f(); // ok

// const/ref members
anObject->~AnObject();
auto newObject = new (anObject) AnObject();

anObject->f(); // UB
newObject->f(); // ok
std::launder(anObject)->f(); // ok

Вы не можете вызвать конструктор таким образом, но нет ничего плохого в повторном использовании памяти и вызове нового размещения, если вы не удаляете память (освобождаете). Я должен сказать, что сброс объекта, подобного этому, немного схематичен. Я бы написал объект, который можно явно сбрасывать, или написал бы метод подкачки и использовал его для его сброса.

E.g.

anObject.swap( AnObject() ); // swap with "clean" object

Почему бы не сбросить с помощью оператора = ()? Это не подлежит обсуждению и гораздо более читабельно.

A a;
//do something that changes the state of a
a = A(); // reset the thing

Если ваш объект имеет разумную семантику присваивания (и правильный оператор =), тогда *anObject = AnObject() имеет больше смысла и его легче понять.

Гораздо лучше просто добавить что-то вроде метода Reset() к вашему объекту, а не играть с размещением new.

Вы используете новую функцию размещения, которая предназначена для того, чтобы позволить вам контролировать, где размещается объект. Обычно это проблема только в том случае, если ваше оборудование имеет «специальную» память, например флэш-чип. ЕСЛИ вы хотите поместить какие-либо объекты во флэш-чип, вы можете использовать эту технику. Причина, по которой он позволяет вам явно вызывать деструктор, заключается в том, что ВЫ теперь контролируете память, поэтому компилятор C++ не знает, как выполнить часть освобождения при удалении.

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