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

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

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

Предлагаемый сброс действителен, но не идиоматичен. Трудно получить право, и, как правило, на него нахмурились и обескуражены.

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

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

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

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

AnObject* anObject = new AnObject();

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

delete anObject;

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

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

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

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

Это ничего не значит. Perl имеет около шести способов записи цикла for. Просто потому, что вы можете делать что-то на языке, потому что они поддерживаются, значит, вы должны их использовать. Черт, я мог бы написать весь мой код, используя для операторов switch, потому что «Core» языка поддерживает их. Не делает это хорошей идеей.

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

Новые и Удалить ваши друзья в C ++

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

myObject.Reset();

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

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

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

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

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

new (anObject) AnObject();

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

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

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

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

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

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

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

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

• хранилище для нового объекта точно накладывает место хранения, которое было занято исходным объектом, и
• новый объект имеет тот же тип, что и исходный объект (игнорируя cv-квалификаторы верхнего уровня), а
• тип исходного объекта не является константным, а если тип класса, не содержит какого-либо нестатического элемента данных, тип которого является const-qualit или ссылочным типом, и
• ни исходный объект, ни новый ob ject является потенциально перекрывающимся подобъектом ([intro.object]).

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

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

// 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

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

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

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

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