Re: Is it legal to directly call a constructor?
On Apr 28, 2:25 pm, "Alf P. Steinbach" <al...@start.no> wrote:
* goodbye...@gmail.com:
class A {
void f() { this->A::A(); }
};
Let's just put away the logic of the program for a moment.
I'm just wondering whether this syntax is legal in standard
C++ or not.
The above is not valid syntax in standard C++.
But regarding your question which you inconveniently put only
in the subject line, "Is it legal to directly call a
constructor", yes of course it is (regarding a constructor of
a most derived class the only indirect way is via the 'new'
operator), and that's what you do every time you call a
constructor.
It really hinges on what you mean by "direct". There is no
syntax in C++ which "calls a constructor"; every *syntax* which
results in a constructor call also allocates memory. Formally,
at least---placement new can be used to make the memory
allocation a no-op, of course. (But using placement new isn't
really what I'd call "direct". On the other hand, naming a base
class in a initialization list sure looks like a direct call to
the constructor to me.)
Anyway, his example made it more or less clear: he wants to call
the constructor like you'd call any other member function.
Which doesn't work, of course. Logically, since to call any
other member function (including the destructor), you need an
object, and the only way to get an object is to call the
constructor.
[...]
The C++ syntax for calling a constructor on existing storage is the basic
placement new, like, for emulating what you're trying to do above,
#include <new>
...
this->A::~A(); // Must first be destroyed.
Technically, only if it has a non-trivial destructor. (Also,
this->A::~A() is probably not a good idea, since the qualified
id prevents virtual function resolution. Although just about
anywhere virtual function resolution would make a difference,
explicit destruction will probably cause other problems as
well.)
::new( this ) A(); // Resurrect.
This is extremely dangerous when you don't know what you're
doing, which you don't when you're enquiring about the syntax.
It's even extremely dangerous when you do think you know what
you're doing, or perhaps especially then! There's very seldom
any reason to do it; if or when you feel that that the above
could be a solution to something, ask about solutions to the
something (they will exist, and they will not include the
above).
Even if you know perfectly what you're doing, it's dangerous,
because the person who ends up maintaining your code may not
realize you're doing it, and make some modification which breaks
it (e.g. by adding something to A::A() which might throw).
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34