Я хочу выполнить "глубокие копии" контейнера STL указателей на полиморфные классы.

Я знаю об Опытном шаблоне разработки, реализованном посредством Виртуальной Идиомы Ctor, как объяснено в Облегченном FAQ C++, Объект 20.8.
Это просто и просто:

struct ABC // Abstract Base Class
{
    virtual ~ABC() {}
    virtual ABC * clone() = 0;
};
struct D1 : public ABC
{
    virtual D1 * clone() { return new D1( *this ); } // Covariant Return Type
};

Глубокая копия затем:

for( i = 0; i < oldVector.size(); ++i )
    newVector.push_back( oldVector[i]->clone() );

Недостатки

Поскольку Andrei Alexandrescu заявляет это:

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

Кроме того, клиенты ABC может возможно сделать что-то плохо. (Я имею в виду, ничто не предотвращает клиенты, чтобы сделать что-то плохо, таким образом, это произойдет.)

Лучший дизайн?

Мой вопрос: там другой путь состоит в том, чтобы сделать абстрактный базовый класс клонируемым, не требуя, чтобы производные классы написали связанный с клоном код? (Класс помощника? Шаблоны?)

Следующее является моим контекстом. Хотелось бы надеяться, это поможет пониманию моего вопроса.

Я разрабатываю иерархию классов для выполнения операций на классе Image:

struct ImgOp
{
    virtual ~ImgOp() {}
    bool run( Image & ) = 0;
};

Операции изображения являются пользовательскими: клиенты иерархии классов реализуют свои собственные классы, полученные из ImgOp:

struct CheckImageSize : public ImgOp
{
    std::size_t w, h;
    bool run( Image &i ) { return w==i.width() && h==i.height(); }
};
struct CheckImageResolution { ... };
struct RotateImage          { ... };
...

Несколько операций могут быть выполнены последовательно на изображении:

bool do_operations( vector< ImgOp* > v, Image &i )
{
    for_each( v.begin(), v.end(),
        /* bind2nd( mem_fun( &ImgOp::run ), i ... ) don't remember syntax */ );
}

Если существуют повторные изображения, набор может быть разделен и совместно использован по нескольким потокам. Для обеспечения "потокобезопасности" каждый поток должен иметь свою собственную копию всех объектов операции, содержавшихся в v -- v становится прототипом, который будет глубоко скопирован в каждом потоке.

Отредактированный: ориентированная на многопотоковое исполнение версия использует Опытный шаблон разработки для осуществления копии указанных объектов - не ptrs:

struct ImgOp
{
    virtual ~ImgOp() {}
    bool run( Image & ) = 0;
    virtual ImgOp * clone() = 0; // virtual ctor
};

struct CheckImageSize : public ImgOp       { /* no clone code */ };
struct CheckImageResolution : public ImgOp { /* no clone code */ };
struct RotateImage : public ImgOp          { /* no clone code */ };

bool do_operations( vector< ImgOp* > v, Image &i )
{
    // In another thread
    vector< ImgOp* > v2;
    transform( v.begin(), v.end(),                       // Copy pointed-to-
        back_inserter( v2 ), mem_fun( &ImgOp::clone ) ); // objects
    for_each( v.begin(), v.end(),
        /* bind2nd( mem_fun( &ImgOp::run ), i ... ) don't remember syntax */ );
}

Это имеет смысл, когда операционные классы изображения являются маленькими: не сериализируйте доступы к уникальным экземплярам ImgOps, скорее предоставьте каждому потоку их собственные копии.

Твердая часть должна избежать устройств записи новых ImgOp- производные классы для написания любого связанного с клоном кода. (Поскольку это - деталь реализации - это - то, почему я отклонил ответы Paul с Любопытно Повторяющимся Шаблоном.)