c++ - clone() を使用しない C++ 仮想コンストラクター

Question

ポリモーフィッククラスへのポインタの STL コンテナの「ディープコピー」を実行したいと考えています。

C++ FAQ Lite の項目 20.8 で説明されているように、 Virtual Ctor Idiomによって実装されたPrototypeデザインパターンについて知っています。それは単純明快です：

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は、各スレッドでディープコピーされるプロトタイプになります。

編集済み:スレッドセーフバージョンでは、Prototype デザインパターンを使用して、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 */ );
}

これは、イメージ操作クラスが小さい場合に意味があります。の一意のインスタンスへのアクセスをシリアル化せずImgOp、各スレッドに独自のコピーを提供します。

難しいのは、新しいImgOp派生クラスの作成者がクローン関連のコードを作成しないようにすることです。(これは実装の詳細であるためです。これが、興味深い繰り返しパターンでポールの回答を却下した理由です。)

score 7 · Accepted Answer

奇妙な再帰パターンを使用できますが、コードが読みにくくなる可能性があります。コピーコンストラクターは引き続き必要です。次のように動作します。

struct ABC // Abstract Base Class
{
    virtual ~ABC() {}
    virtual ABC * clone() const = 0;
};



template <class TCopyableClass>
struct ClonableABC : public ABC
{
    virtual ABC* clone() const {
       return new TCopyableClass( *(TCopyableClass*)this );
    } 
};


struct SomeABCImpl : public ClonableABC<SomeABCImpl>
{};

score 2 · Accepted Answer

ディープコピーは次のとおりです。 [for ループ]

クライアントにベクターを明示的に複製させます。これがあなたの質問に答えるかどうかはわかりませんが、クローン作成が自動的に行われるように、スマートポインターのベクトルをお勧めします。

std::vector<cloning_pointer<Base> > vec;
vec.push_back(cloning_pointer<Base>(new Derived()));

// objects are automatically cloned:
std::vector<cloning_pointer<Base> > vec2 = vec;

もちろん、ベクトルなどのサイズを変更するときにこれらの暗黙のコピーが発生するのは望ましくないため、コピーと移動を区別できる必要があります。cloning_pointerこれは、ニーズに合わせて調整する必要があるかもしれない私の C++0x おもちゃの実装です。

#include <algorithm>

template<class T>
class cloning_pointer
{
    T* p;

public:

    explicit cloning_pointer(T* p)
    {
        this->p = p;
    }

    ~cloning_pointer()
    {
        delete p;
    }

    cloning_pointer(const cloning_pointer& that)
    {
        p = that->clone();
    }

    cloning_pointer(cloning_pointer&& that)
    {
        p = that.p;
        that.p = 0;
    }

    cloning_pointer& operator=(const cloning_pointer& that)
    {
        T* q = that->clone();
        delete p;
        p = q;
        return *this;
    }

    cloning_pointer& operator=(cloning_pointer&& that)
    {
        std::swap(p, that.p);
        return *this;
    }

    T* operator->() const
    {
        return p;
    }

    T& operator*() const
    {
        return *p;
    }
};

Julien:&&は「ref の ref」ではなく、変更可能な右辺値にのみバインドする右辺値参照です。右辺値参照の概要とその仕組みについては、こちらの優れた (残念ながら少し時代遅れの)チュートリアルとビデオを参照してください。

score 2 · Accepted Answer

参考までに、これが私が出したデザインです。ご意見をお寄せいただきありがとうございます。（そして、あなたのコメントのためのMartin York。）

ステップ #1、テンプレートを使用したコンパイル時のポリモーフィズム

ポリモーフィズムは、テンプレートとImplicit-interfacesを使用してコンパイル時に実行されます。

template< typename T >
class ImgOp
{
    T m_t; // Not a ptr: when ImgOp is copied, copy ctor and
           // assignement operator perform a *real* copy of object
    ImageOp ( const ImageOp &other ) : m_t( other .m_t ) {}
    ImageOp & operator=( const ImageOp & );
public:
    ImageOp ( const T &p_t ) : m_t( p_t ) {}
    ImageOp<T> * clone() const { return new ImageOp<T>( *this ); }
    bool run( Image &i ) const { return m_t.run( i); }
};

// Image operations need not to derive from a base class: they must provide
// a compatible interface
class CheckImageSize       { bool run( Image &i ) const {...} };
class CheckImageResolution { bool run( Image &i ) const {...} };
class RotateImage          { bool run( Image &i ) const {...} };

現在、クローン関連のコードはすべて固有のクラス内にあります。ImgOpただし、異なる操作で s のコンテナをテンプレート化することは現在不可能です。

vector< ImgOp > v;           // Compile error, ImgOp is not a type
vector< ImgOp< ImgOp1 > > v; // Only one type of operation :/

ステップ #2、抽象化のレベルを追加する

インターフェイスとして機能する非テンプレートベースを追加します。

class AbstractImgOp
{
    ImageOp<T> * clone() const = 0;
    bool run( Image &i ) const = 0;
};

template< typename T >
class ImgOp : public AbstractImgOp
{
    // No modification, especially on the clone() method thanks to
    // the Covariant Return Type mechanism
};

これで、次のように記述できます。

vector< AbstractImgOp* > v;

しかし、画像操作オブジェクトを操作するのは難しくなります:

AbstractImgOp *op1 = new AbstractImgOp;
    op1->w = ...; // Compile error, AbstractImgOp does not have
    op2->h = ...; // member named 'w' or 'h'

CheckImageSize *op1 = new CheckImageSize;
    op1->w = ...; // Fine
    op1->h = ...;
AbstractImgOp *op1Ptr = op1; // Compile error, CheckImageSize does not derive
                             // from AbstractImgOp? Confusing

CheckImageSize op1;
    op1.w = ...; // Fine
    op1.h = ...;
CheckImageResolution op2;
    // ...
v.push_back( new ImgOp< CheckImageSize >( op1 ) );       // Confusing!
v.push_back( new ImgOp< CheckImageResolution >( op2 ) ); // Argh

ステップ #3、「クローンポインター」クラスを追加する

FredOverflow のソリューションに基づいて、フレームワークを使いやすくするためのクローンポインターを作成します。
ただし、このポインターは 1 種類の ptr のみを保持するように設計されているため、テンプレート化する必要はありません。テンプレート化する必要があるのは ctor だけです。

class ImgOpCloner
{
    AbstractImgOp *ptr; // Ptr is mandatory to achieve polymorphic behavior
    ImgOpCloner & operator=( const ImgOpCloner & );
public:
    template< typename T >
    ImgOpCloner( const T &t ) : ptr( new ImgOp< T >( t ) ) {}
    ImgOpCloner( const AbstractImgOp &other ) : ptr( other.ptr->clone() ) {}
    ~ImgOpCloner() { delete ptr; }
    AbstractImgOp * operator->() { return ptr; }
    AbstractImgOp & operator*() { return *ptr; }
};

これで、次のように記述できます。

CheckImageSize op1;
    op1.w = ...; // Fine
    op1.h = ...;
CheckImageResolution op2;
    // ...
vector< ImgOpCloner > v;
v.push_back( ImgOpCloner( op1 ) ); // This looks like a smart-ptr, this is not
v.push_back( ImgOpCloner( op2 ) ); // confusing anymore -- and intent is clear

c++ - clone() を使用しない C++ 仮想コンストラクター

欠点

より良いデザイン？

3 に答える 3

ステップ #1、テンプレートを使用したコンパイル時のポリモーフィズム

ステップ #2、抽象化のレベルを追加する

ステップ #3、「クローン ポインター」クラスを追加する

Related

Reference

ステップ #3、「クローンポインター」クラスを追加する