Is it valid to initialize a base class with placement new?

[Juha Nieminen]

Assume I have a class Base, and then this:

struct Derived: public Base
{
AnotherClass member;
};

Also assume that I'm allocating an object of type 'Derived' with a
custom allocator and that, for whatever reason, I don't want to call the
constructor of 'Derived', but instead I want to build the object by
first making a placement new for the 'Base' and then another for the
'member'. (Yes, I know this might sound like a bit of a silly thing to
want, but just humor me, please.) Is it valid to do that?

The code would be something like this:

Derived* ptr = allocator.alloc ate(1);
new (static_cast<Ba se*>(ptr)) Base(baseParame ters);
new (&ptr->member) AnotherClass(ot herParameters);

This compiles (and doesn't crash), but is it valid?

[peter koch]

On 3 Sep., 22:17, Juha Nieminen <nos...@thanks. invalidwrote:

* Assume I have a class Base, and then this:

struct Derived: public Base
{
* * AnotherClass member;

};

* Also assume that I'm allocating an object of type 'Derived' with a
custom allocator and that, for whatever reason, I don't want to call the
constructor of 'Derived', but instead I want to build the object by
first making a placement new for the 'Base' and then another for the
'member'. (Yes, I know this might sound like a bit of a silly thing to
want, but just humor me, please.) Is it valid to do that?

* The code would be something like this:

Derived* ptr = allocator.alloc ate(1);
new (static_cast<Ba se*>(ptr)) Base(baseParame ters);
new (&ptr->member) AnotherClass(ot herParameters);

* This compiles (and doesn't crash), but is it valid?

No. Not if member belongs to Derived.
In any case, you have not created a Derived object: To do this you
must call the contructor of derived. Perhaps it would make more sense
to describe what you are trying to accomplish?

/Peter

[Juha Nieminen]

peter koch wrote:

>Derived* ptr = allocator.alloc ate(1);
new (static_cast<Ba se*>(ptr)) Base(baseParame ters);
new (&ptr->member) AnotherClass(ot herParameters);

This compiles (and doesn't crash), but is it valid?

No. Not if member belongs to Derived.

How exactly are those lines I wrote above different from:

Derived* ptr = new Derived;

(assuming, of course, that the constructor of Derived passes the
'baseParameters ' to Base and the 'otherParameter s' to 'member', and that
'allocator' is the default allocator.)

In other words, does the 'new' do something that those three lines I
quoted above don't?

In any case, you have not created a Derived object: To do this you
must call the contructor of derived. Perhaps it would make more sense
to describe what you are trying to accomplish?

What I'm trying to accomplish is something which would be easily
solvable with variadic templates of C++0x, namely an easy way of
forwarding a bunch of values to the constructor of 'member' without
having to write a ton of constructors in the 'Derived' struct. (This
would be easy by putting a variadic template constructor in the
'Derived' struct, but until C++0x is ratified and implemented by
compilers, I have to resort to uglier tricks.)

Namely, I'm trying to pass a varied amount of parameters to the
constructor of 'member' (from within an outer template class), and with
placement new I can do that with a one-liner. With a proper construction
mechanism of 'Derived' I would have to write a big bunch of template
constructors for it, one for each possible amount of parameters. It
would of course be possible, but tedious.

(And no, calling the copy constructor or copy assignment of 'member'
is not an option in this case. If it would be, then that would be a
cleaner solution.)

[crube]

On Sep 4, 12:23*am, Juha Nieminen <nos...@thanks. invalidwrote:

* How exactly are those lines I wrote above different from:

Derived* ptr = new Derived;

(assuming, of course, that the constructor of Derived passes the
'baseParameters ' to Base and the 'otherParameter s' to 'member', and that
'allocator' is the default allocator.)

* In other words, does the 'new' do something that those three lines I
quoted above don't?

Yes, it does. It calls a Derived object constructor. Besides that,
before the conctructor it "initialize s" an object, i.e. sets up the
internal data such information about the base type (for dynamic_cast)
and vtable (in case you had virtual methods).

In your example you didn't created a Derived object at all so you've
got a Base type with all consequences of that. You only got memory
allocated.

Robert

[James Kanze]

On Sep 4, 12:23 am, Juha Nieminen <nos...@thanks. invalidwrote:

peter koch wrote:

Derived* ptr = allocator.alloc ate(1);
new (static_cast<Ba se*>(ptr)) Base(baseParame ters);
new (&ptr->member) AnotherClass(ot herParameters);

This compiles (and doesn't crash), but is it valid?

No. Not if member belongs to Derived.

How exactly are those lines I wrote above different from:

Derived* ptr = new Derived;

It calls the constructor of Derived.

(assuming, of course, that the constructor of Derived passes
the 'baseParameters ' to Base and the 'otherParameter s' to
'member', and that 'allocator' is the default allocator.)

In other words, does the 'new' do something that those three
lines I quoted above don't?

It calls the construtor of Derived. It does NOT call the
constructor of Base, nor does it call the constructor of member;
these are called by the constructor of Derived. (The
constructor of Derived may, and often does, other things as
well.)

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Juha Nieminen]

James Kanze wrote:

On Sep 4, 12:23 am, Juha Nieminen <nos...@thanks. invalidwrote:

>peter koch wrote:

>>>Derived* ptr = allocator.alloc ate(1);
new (static_cast<Ba se*>(ptr)) Base(baseParame ters);
new (&ptr->member) AnotherClass(ot herParameters);

>>> This compiles (and doesn't crash), but is it valid?

>>No. Not if member belongs to Derived.

>How exactly are those lines I wrote above different from:

>Derived* ptr = new Derived;

It calls the constructor of Derived.

>(assuming, of course, that the constructor of Derived passes
the 'baseParameters ' to Base and the 'otherParameter s' to
'member', and that 'allocator' is the default allocator.)

>In other words, does the 'new' do something that those three
lines I quoted above don't?

It calls the construtor of Derived. It does NOT call the
constructor of Base, nor does it call the constructor of member;
these are called by the constructor of Derived. (The
constructor of Derived may, and often does, other things as
well.)

I still fail to see how the end result is different from what I wrote.

'Derived' has no explicit constructor, and thus only the
compiler-generated one. Also, 'Derived' has no member functions, and the
object of type 'Derived' is never used for anything else than to access
the base class function and the function of 'Member'. The destructor of
'Derived' is never called either (because I never call it explicitly nor
implicitly).

So basically the situation is that I have allocated space for an
object of type 'Base', with space for an object of type 'AnotherClass'
appended to it, and then I construct that 'Base' object with placement
new, as well as the 'member' object. The 'Derived' struct is only a
placeholder for this allocated memory, and never used for anything else.

So what is it that makes it illegal to do so?

(Why not simply have an object of type Base and another of type
AnotherClass and construct them normally? Because if Base is an empty
class, the compiler cannot perform empty base optimization.)

[James Kanze]

On Sep 4, 3:44 pm, Juha Nieminen <nos...@thanks. invalidwrote:

James Kanze wrote:

On Sep 4, 12:23 am, Juha Nieminen <nos...@thanks. invalidwrote:

peter koch wrote:
Derived* ptr = allocator.alloc ate(1);
new (static_cast<Ba se*>(ptr)) Base(baseParame ters);
new (&ptr->member) AnotherClass(ot herParameters);

>> This compiles (and doesn't crash), but is it valid?

>No. Not if member belongs to Derived.

How exactly are those lines I wrote above different from:

Derived* ptr = new Derived;

It calls the constructor of Derived.

(assuming, of course, that the constructor of Derived passes
the 'baseParameters ' to Base and the 'otherParameter s' to
'member', and that 'allocator' is the default allocator.)

In other words, does the 'new' do something that those three
lines I quoted above don't?

It calls the construtor of Derived. It does NOT call the
constructor of Base, nor does it call the constructor of
member; these are called by the constructor of Derived.
(The constructor of Derived may, and often does, other
things as well.)

I still fail to see how the end result is different from what
I wrote.

Try it. Formally, it's undefined behavior, so the results may
vary. But suppose Base is a polymorphic class (otherwise, why
inherit). And suppose that you then assign your pointer to a
Base*, and use typeid on it. What do you get?

'Derived' has no explicit constructor, and thus only the
compiler-generated one.

And? The compiler generated one may still have something it
needs to do.

Also, 'Derived' has no member functions, and the object of
type 'Derived' is never used for anything else than to access
the base class function and the function of 'Member'. The
destructor of 'Derived' is never called either (because I
never call it explicitly nor implicitly).

So basically the situation is that I have allocated space for
an object of type 'Base', with space for an object of type
'AnotherClass' appended to it, and then I construct that
'Base' object with placement new, as well as the 'member'
object. The 'Derived' struct is only a placeholder for this
allocated memory, and never used for anything else.

In which case, there shouldn't be any problem, if they're only
place holders, and you never use the object as a Derived. But I
don't see any case where I'd want to do that; if I just wanted
to group objects, I'd use a struct.

So what is it that makes it illegal to do so?

The standard. And the way most compilers implement inheritence.

(Why not simply have an object of type Base and another of
type AnotherClass and construct them normally? Because if Base
is an empty class, the compiler cannot perform empty base
optimization.)

Which it might not do anyway?

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Juha Nieminen]

James Kanze wrote:

But I
don't see any case where I'd want to do that; if I just wanted
to group objects, I'd use a struct.

Except that if 'Base' is made a member variable of the struct, the
compiler won't be able to perform empty base class optimization (which
in this case is relevant).

[Thomas J. Gritzan]

Juha Nieminen schrieb:

James Kanze wrote:

>But I
don't see any case where I'd want to do that; if I just wanted
to group objects, I'd use a struct.

Except that if 'Base' is made a member variable of the struct, the
compiler won't be able to perform empty base class optimization (which
in this case is relevant).

There is no empty base class optimization. You create an object of type
Base and an object of type AnotherClass. Neither is a base class of the
other.
Base would be a base class of Derived, but there is no object of type
Derived, because you don't create one. How should the compiler handle
empty base class optimization, when there is no object of a type with an
empty base class?

However, why don't you simple do:
new (static_cast<vo id*>(ptr)) Derived(paramet ers);
?

--
Thomas

[tony_in_da_uk]

On Sep 4, 7:23 am, Juha Nieminen <nos...@thanks. invalidwrote:

peter koch wrote:

Derived* ptr = allocator.alloc ate(1);
new (static_cast<Ba se*>(ptr)) Base(baseParame ters);
new (&ptr->member) AnotherClass(ot herParameters);

In other words, does the 'new' do something that those three lines I
quoted above don't?

Might do - up to the compiler - but can't see any reason given the
obvious non-polymorphic requirement.

What I'm trying to accomplish is something which would be easily
solvable with variadic templates of C++0x, namely an easy way of
forwarding a bunch of values to the constructor of 'member' without
having to write a ton of constructors in the 'Derived' struct. (This
would be easy by putting a variadic template constructor in the
'Derived' struct, but until C++0x is ratified and implemented by
compilers, I have to resort to uglier tricks.)

Namely, I'm trying to pass a varied amount of parameters to the
constructor of 'member' (from within an outer template class), and with
placement new I can do that with a one-liner. With a proper construction
mechanism of 'Derived' I would have to write a big bunch of template
constructors for it, one for each possible amount of parameters. It
would of course be possible, but tedious.

(And no, calling the copy constructor or copy assignment of 'member'
is not an option in this case. If it would be, then that would be a
cleaner solution.)

You've really got that many arguments? And/or doing this in enough
classes for it to become tedious? Impressive.

Just use a preprocessor macro (assuming you're using a capable
compiler)...

Tony