delete() and new() on elements of an array created by new[]()

[[rob desbois]]

This may be a very dumb question, but brain can't seem to find
anything to confirm/deny suspicion.

I have an array created with:
FooClass* foo = new FooClass[numberOfFooObjects];

I want to be able to replace an element of that array at will with a
new FooClass.
Am I right in thinking that to delete foo[3], say, and replace with a
new FooClass, would require placement new? Would this be wise?

It seems that if I want to be able to replace elements at will with
newly constructed elements (rather than using the assignment
operator), that it would be better to do this:
FooClass** foo = new FooClass*[numberOfFooObjects];
Then create each object on the heap and store the pointers instead.
Replacing elements is easy and obvious then...

I feel I'm being really stupid here, can someone enlighten a poor
confuzzled coder please?
TIA
--rob

 

[Michael DOUBEZ]

[rob desbois] a écrit :

I have an array created with:
FooClass* foo = new FooClass[numberOfFooObjects];

I want to be able to replace an element of that array at will with a
new FooClass.
Am I right in thinking that to delete foo[3], say, and replace with a
new FooClass, would require placement new?

If indeed you can destroy the object
(foo+3)->~FooClass();
And then
new(foo+3) FooClass();

Would this be wise?

Of course not.
It doesn't matter when you do it in raw memory but if you cannot
recreate the object (if it throws), then you have a big problem with how
to deal with your array when you want to destroy it.
(foo+3)->~FooClass();
try
{
new(foo+3) FooClass();
}
catch(...)
{
//
}
delete[] foo; //UB when destroying foo[3]

It seems that if I want to be able to replace elements at will with
newly constructed elements (rather than using the assignment
operator), that it would be better to do this:
FooClass** foo = new FooClass*[numberOfFooObjects];
Then create each object on the heap and store the pointers instead.
Replacing elements is easy and obvious then...

That or defining a void FooClass::swap(FooClass&)throw() method that
swap the two object.

Michael

 

[[rob desbois]]

[rob desbois] a écrit :

I have an array created with:
FooClass* foo = new FooClass[numberOfFooObjects];

I want to be able to replace an element of that array at will with a
new FooClass.
Am I right in thinking that to delete foo[3], say, and replace with a
new FooClass, would require placement new?

If indeed you can destroy the object
(foo+3)->~FooClass();
And then
new(foo+3) FooClass();

Would this be wise?

Of course not.
It doesn't matter when you do it in raw memory but if you cannot
recreate the object (if it throws), then you have a big problem with how
to deal with your array when you want to destroy it.
(foo+3)->~FooClass();
try
{
new(foo+3) FooClass();}

catch(...)
{
//}

delete[] foo; //UB when destroying foo[3]

Ah yes, didn't think of that...

It seems that if I want to be able to replace elements at will with
newly constructed elements (rather than using the assignment
operator), that it would be better to do this:
FooClass** foo = new FooClass*[numberOfFooObjects];
Then create each object on the heap and store the pointers instead.
Replacing elements is easy and obvious then...

That or defining a void FooClass::swap(FooClass&)throw() method that
swap the two object.

Michael

Great, thanks very much Michael