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

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

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

[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

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

On Apr 15, 1:50 pm, Michael DOUBEZ <michael.dou...@free.fr> wrote:
> [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 :-)