Это безопасно? Я не использую никаких виртуальных функций в своей реальной реализации, но я склонен полагать, что даже если бы я был, это все равно было бы безопасно.
class Foo
{
Foo()
{
// initialize things
}
Foo( int )
{
new ( this ) Foo();
}
}
К моменту ввода открытой фигурной скобки конструктора Foo(int) все члены класса имеют свой конструктор. Если затем принудительно вызвать другой конструктор с новым местом размещения, вы переписываете текущее состояние класса. Это в основном означает, что все члены имеют свои конструкторы, которые называются дважды - если что-то делает new в своем конструкторе, вы пропускаете этот контент, и вы действительно действительно испортите вещи! Вы эффективно создаете два объекта, а деструкторы для членов первого объекта никогда не вызываются, поскольку второй объект перезаписывает память первого объекта.
Другими словами это БАД! Не делай этого!
Наиболее распространенным обходным решением является использование какой-либо функции инициализации и вызов этого из обоих конструкторов. Это не позволит вам инициализировать члены константы и другие, которые должны быть в списке инициализаторов.
Одно беспокойство, которое у меня есть, - если Foo использует множественное наследование, вам нужно будет приложить указатель this к самому базовому классу. В противном случае, если this смещается (иногда это происходит при множественном наследовании), он будет строиться с неправильным адресом.
Вы не были бы в безопасности, если бы вы расширили другой класс, и этот класс имел деструктор, например
class Foo
{
int* a;
public:
Foo():a(new int)
{
}
~Foo(){delete a;}
}
class Bar:public Foo
{
Bar()
{
// initialize things
}
Bar( int )
{
new ( this ) Foo();
}
}
Сначала Bar(int) вызывает Foo(), затем он вызывает Bar(), который также вызывает Foo(). Во второй раз Foo() вызывается, он перезаписывает указатель, настроенный первым вызовом на Foo(), и выделенная память просочилась.
Основная проблема заключается в том, что конструкторы являются особыми - когда вы пишете конструкцию, которая вызывает конструктор (например, используйте ключевое слово new для создания объекта), выполняется не только тело конструктора, а целая цепочка объектов построенный первым.
Поэтому, когда вы используете синтаксис размещения-нового для запуска другого конструктора, сначала С++ автоматически запускает все конструкторы объектов базового класса и все конструкторы переменных-членов, и только тогда вызывается другой объект-конструктор. Иногда вы будете в порядке, но много раз вы столкнетесь с неожиданным поведением.
Похоже, что лучшим решением этой проблемы является просто создание другой функции для инициализации:
class Foo
{
inline void nullify()
{
// initialize things
}
Foo()
{
nullify();
}
Foo( int )
{
nullify();
}
}
Как говорили другие, это плохая идея и как возможный деструктивный случай: что делать, если вы делаете
class Foo
{
Foo()
{
// initialize things
}
Foo( int bar )
{
new ( this ) Foo(bar);
}
}
не приветствуй землю бесконечной рекурсии.