классы копирования связаны между собой

Question

У меня есть несколько различных типов классов, которые связаны друг с другом (они содержат указатели друг на друга - некоторые из них - векторы указателей), и я очень доволен этим дизайном. Но теперь наступает момент, когда я хотел бы сделать копию всей моей структуры и очень сложно исправить все ссылки каждого экземпляра новых классов. У меня уже есть класс контейнера для всей структуры, но все же попытки, которые я сделал для написания метода clone(), оказались в очень грязном коде, и я не удовлетворен ими.

Я хотел бы знать, есть ли какой-то шаблон дизайна, который мог бы помочь решить эту проблему.

Answer 1

Одно из решений, которые могли бы помочь вам (если я правильно понял из вашего довольно расплывчатого описания):

1. создать клон всех ваши объектов (в настоящее время, просто скопировать все указатели на новые объекты по-прежнему указывая на исходные объекты)
2. при этом отслеживать, какой объект является клоном того или иного объекта в каком-то словаре (что-то вроде std::map<void*,void*> должно выполнять эту работу, но, может быть, вы можете придумать что-то лучшее, чем уродливое void*)
3. пройти все новые объекты и перенаправить все указатели по значениям, хранящимся в словаре

Answer 2

Обычный подход заключается в том, чтобы сохранить какую-то форму отображения от старых к новым указателям - перед созданием копии проконсультируйтесь с картой, чтобы узнать, был ли объект уже скопирован, и если это, вернуть существующую копию, иначе, call clone().

Что-то вроде этого:

#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

Это может быть немного чище, если вы можете наложить иерархию (ребенок-родительские отношения) вместе со ссылками. Затем вы можете обратиться к процессу клонирования рекурсивно - пусть каждый из родителей клонирует всех своих детей, клонируя и обновляя ссылки.

Если у вас есть отношения на одном уровне (скажем, объекты, являющиеся сверстниками и перекрестные ссылки друг на друга по кругу), вы можете искусственно добавить родителя, который будет клонировать всех детей, обновлять свои собственные ссылки и затем обновлять их с помощью новые ссылки.

Это позволит масштабировать/добавлять новые компоненты без изменения большей части кода.