deep copying

[bob]

hi,

I have been tasked with transferring a rather complex, deeply nested
structure across dll's / memory spaces and effectively I need to deep
copy the structure in question. Its a C struct and it contains
pointers. I would have liked to think I could copy construct it, but I
can't. I need to follow the pointers.

Does anybody know if there's a quick and easy way to achieve this (as
opposed to manually following the pointers and fields which go 8-15
levels deep). I'm trying to see if boost can help me out but so far I
haven't seen anything.

Does anybody know whats the best approach to take here? I'm open to
all options.... i.e. anything but manually follow those 15
levels!! I'm fairly sure I'm reinventing the wheel, hence the
question. The struct in question is a C struct, used in a c++ app
(visual studio/borland, if its important).

thanks for any info.

Graham

 

[Victor Bazarov]

I have been tasked with transferring a rather complex, deeply nested
structure across dll's / memory spaces and effectively I need to deep
copy the structure in question. Its a C struct and it contains
pointers. I would have liked to think I could copy construct it, but I
can't. I need to follow the pointers.

Does anybody know if there's a quick and easy way to achieve this (as
opposed to manually following the pointers and fields which go 8-15
levels deep). I'm trying to see if boost can help me out but so far I
haven't seen anything.

Does anybody know whats the best approach to take here? I'm open to
all options.... i.e. anything but manually follow those 15
levels!! I'm fairly sure I'm reinventing the wheel, hence the
question. The struct in question is a C struct, used in a c++ app
(visual studio/borland, if its important).

Something in line with

// for members that are built-in or structs
template<class T> class deepcopy {
static void go(T& dest, T const& src) {
dest = src;
}
};

// for the members that are pointers
template<class T> class deepcopy<T*> {
static void go(T* dest, T const* src) {
return deepcopy<T>::go(*dest, *src);
}
};

// and you only need to implement a real 'deepcopy' for your
// top-level struct (everything else should just fall into place)
void deepcopy(mystruct& dest, mystruct const& src) {
deepcopy(dest.member_one, src.member_one);
...
}

V

 

[Mark P]

Something in line with

// for members that are built-in or structs
template<class T> class deepcopy {
static void go(T& dest, T const& src) {
dest = src;
}
};

// for the members that are pointers
template<class T> class deepcopy<T*> {
static void go(T* dest, T const* src) {
return deepcopy<T>::go(*dest, *src);
}
};

// and you only need to implement a real 'deepcopy' for your
// top-level struct (everything else should just fall into place)
void deepcopy(mystruct& dest, mystruct const& src) {
deepcopy(dest.member_one, src.member_one);
...
}

V

I don't understand this. Should the last line of code that you wrote
(the implementation of the deepcopy function) be:

deepcopy<member_type>::go( dest.member_one, src.member_one);

If so, I don't see how this can work in the following situation:

struct A
{
B b;
};

struct B
{
C* c;
};

struct C
{
int x;
};


According to your prescription, we implement deepcopy for the top-level
struct A as:

void deepcopy( A& dest, const A& src)
{
deepcopy<B>::go( dest.b, src.b);
}

The internal call to deepcopy leads to dest.b = src.b. But if B does
not have a deep copy assignment operator defined, we end up with a
shallow copy of C* c.

What am I missing here?

-Mark

 

[Victor Bazarov]

I don't understand this.

You actually understood much more than you give yourself credit for.

Should the last line of code that you wrote
(the implementation of the deepcopy function) be:

deepcopy<member_type>::go( dest.member_one, src.member_one);

Right.

I ought to define one more function:

template<class T> void deepcopy(T &t, T const& tt) {

If so, I don't see how this can work in the following situation:

struct A
{
B b;
};

struct B
{
C* c;
};

struct C
{
int x;
};


According to your prescription, we implement deepcopy for the
top-level struct A as:

void deepcopy( A& dest, const A& src)
{
deepcopy<B>::go( dest.b, src.b);
}

The internal call to deepcopy leads to dest.b = src.b. But if B does
not have a deep copy assignment operator defined, we end up with a
shallow copy of C* c.

What am I missing here?

Not too much. You're on the right track, AFAICT.

V