Boost logo

Boost :

Subject: Re: [boost] How to create a shallow copy without callingaconstructor?
From: Vicente Botet Escriba (vicente.botet_at_[hidden])
Date: 2010-01-08 05:52:15

Stefan Strasser-2 wrote:
> Am Monday 04 January 2010 10:12:03 schrieb Vicente Botet Escriba:
>> Stefan Strasser-2 wrote:
>> > unfortunately there is no such concept of a "deep copy" in c++ either,
>> so
>> > my
>> > approach is to use Boost.Serialization for cloning objects (or a
>> > user-supplied function).
>> > Using serialization you can decide on a case to case basis if the
>> object
>> > behind a pointer should be copied. (depending on if the type is
>> > transactional, in your case).
>> > of course, that'd introduce the Serializable requirement and I don't
>> know
>> > how
>> > well that fits into your design.
>> Non , serialization don't fits my requirements as I need to use the
>> object
>> when deferred updating policy is used.
> I didn't mean using the serialized stream, you can create deep copies
> using
> Boost.Serialization: serialize the object to memory and then deserialize
> it.
> if you keep the object that was used for serialization you have a clone,
> that
> is a deep copy by definition because boost.serialization is designed to
> reconstruct the exact same object graph that was used for serialization.
> by writing your own serialization archive you could make pointers to
> transactional objects shared among the clones.
Definitely I will not use Boost.Serialization for STM.

Stefan Strasser-2 wrote:
>> Stefan Strasser-2 wrote:
>> > this may be different in your case though because of the requirement to
>> > derive
>> > from *_transaction_object, that could be used to detect which types
>> ought
>> > to
>> > provide a special copy constructor.
>> Sorry, I don't understand how the fact the type must derive from
>> base_transaction_object can help to define the
>> has_shallow_copy_constructor.
> no, the user does have to express in some detectable way that he has a
> implemented a special copy constructor (if it is optional).
> this could be a type trait, or a special base class instead of
> transaction_object, that can be checked for using a standard type trait.
> (that's what I meant above).
> or you could use inline friend functions like I do, because I wanted to
> avoid
> a user-defined trait:
> template<class T>
> T *clone(T const &original){
> //default implementation
> }
> class user_type{
> friend user_type *clone(user_type const &original){
> //user-supplied implementation
> }
> };
> int main(){
> user_type t1;
> other_user_type t2;
> clone(t1); //calls user-supplied implementation
> clone(t2); //calls default implementation
> }

Thanks for the friend to the free function hint, I will use the free
function when the class is know statically. Obviously this can not be used
when it is know at run-time so in this case I will use the virtual function.
Both functions will be needed, but the virtual function can be defined by a
mixin that call the static function.


View this message in context:
Sent from the Boost - Dev mailing list archive at

Boost list run by bdawes at, gregod at, cpdaniel at, john at