Re: deep copying

From:

"Victor Bazarov" <v.Abazarov@comAcast.net>

Newsgroups:

comp.lang.c++

Date:

Wed, 3 Oct 2007 20:41:03 -0400

Message-ID:

<fe1cqu$4kv$1@news.datemas.de>

Mark P wrote:

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.

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) {
        return deepcopy<T>::go(t, 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
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask