Re: Shallow\Deep copy
ManicQin wrote:
I have an data type that is wrapping a vector of pointers, currently I
have no control of the type that the vector holds and I need to be as
generic as I can (it's a part of a frame work).
naturally my vector is templated by the client.
I tried to think of a way to deep copy the vector into another
->without<- adding Clone function and such to the objects and I couldnt
think of one, I would be happy if anyone knows of a way...
Because I couldnt find a way to work without the Clone() AND I cant
force my clients to implement IClonable interface than I decided to
check If the object is descendant of IClonable and if it is than I
deep copy the object if not than I shallow copy the object
So, what are the guarantees of that operation? You claim that you make a
deep copy of the vector into another, but if you find you can't you fall
back to a shallow copy? I'd say that this is useless, exactly because it
doesn't give any guarantee at all about the results. You simply don't know
if the new vector owns the contained objects or just shares them, so you
also don't know if you can delete the objects, who owns them etc. Note that
a reference-counted smart pointer would help to at least make this safe
from the C++ side, though I still question if a half-deep copy fits the
application logic.
Interface* newItem = (*iter);
IClonable* testForClonable = dynamic_cast<IClonable*>(newItem);
if (testForClonable)
{
IClonable* tmpClone = testForClonable->Clone();
if (tmpClone)
{
newItem = dynamic_cast<Interface*>(tmpClone);
}
}
this->AddItem(newItem);
Actually, I'd do it differently:
1. If the type (not the object, i.e. don't check that on every iteration)
supports cloning, use the clone function.
2. If the type doesn't support cloning, it still has a copy-constructor.
However, in order to avoid slicing, make sure that
typeid(*original_ptr)==typeid(*clone_ptr)
still holds.
Note that case 2 will lead to compile-time errors if you can't access the
copy constructor (as is the case with many baseclasses) and at least yield
runtime errors if the type is just a baseclass and the object's type is
some unknown derived type.
However, and that is the important part, you either end up with a deep copy
or you will get an error.
Uli
--
Sator Laser GmbH
Gesch??ftsf??hrer: Thorsten F??cking, Amtsgericht Hamburg HR B62 932
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]