复制链接在一起的类

Question

I have few different types of classes which are cross linked (they contain pointers to each other - some of them vectors of pointers) and I am pretty happy with this design. But now it come a point where I would like to make a copy of all my structure and its very hard to correct all the links of every instance of the new classes. I already have a container class for all the structure but still the attempts I made to write a clone() method ended up in very dirty code and I am not satisfied with them.

I would like to know if there is a kind of design pattern that could help to solve this problem.

Answer 1

One solution that might help you (if I understood correctly from your rather vague description):

1. create a clone of all your objects (by now, just copy all pointers to the new objects still pointing to the original objects)
2. while doing so, keep track of which object is the clone of which object in some sort of dictionary (something like std::map<void*,void*> should do the job, but maybe you can come up with something better than the ugly void* )
3. go through all the new objects and redirect all pointers by the values stored in the dictionary

Answer 2

The usual approach is to keep some sort of a mapping form old to new pointers - before making a copy, consult the map to see if the object was already copied and if it is, return the existing copy, otherwise, call clone().

Something like this:

#include <unordered_map>
#include <vector>

typedef std::unordered_map<void *, void *> map_type;

template<typename T>
T *clone (T *ptr, map_type &m)
{
  auto p = m.find (ptr);
  if (p != m.end ())
    return static_cast<T *> (p->second);
  else
    return ptr->clone (m);
}

struct S
{
  int x;
  std::vector<S *> v;

  S *clone (map_type &m)
  {
    S *p = new S;

    // this is important to happen before calling clone() on subobjects
    m [this] = p;

    p->x = x;   
    for (auto q: v)
      p->v.push_back (::clone (q, m));

    return p;
  }
};

int
main ()
{
  S *p = new S ();
  p->x = 1;

  S *q = new S ();
  q->x = 2;

  S *r = new S ();
  r->x = 3;

  p->v.push_back (p);
  p->v.push_back (p);
  p->v.push_back (q);

  q->v.push_back (p);
  q->v.push_back (r);

  r->v.push_back (p);

  map_type m;

  S *x;
  x = clone (p, m);
}

Answer 3

It might be a bit cleaner if you can impose hierarchy (child-parent relationship) together with the links. Then you may approach cloning process recursively - let each of the parents clone all of all its children while being cloned and updating references.

In case you have relationship on the same level (say, objects being peers and cross-referencing each other in circle), you can artificially add parent that would clone all children, update its own references, and then update children with new references.

This would allow scaling/adding new components without modifying much of the code.