Victor Bazarov wrote:

bob@blah.com wrote:

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

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?