4

CRTPを使用して、継承されたクラスにクローンメソッドを追加しています。次に例を示します。

class Base 
{
     virtual ~Base() {};
     virtual Base* clone() const = 0;
}; 

template<class Derived> class BaseCopyable : Base
{ 
public:
    virtual Base* clone() const
    {
        return new Derived(static_cast<Derived const&>(*this));
    }
};

class A : public BaseCopyable<A>;
class B : public BaseCopyable<B>;
etc...

しかし、Bから継承するクラスがある場合、たとえば次のようになります。

class differentB : public B;

次に、clone（）はdifferentB型のオブジェクトを返さず、Bを返します。differentBで新しいclone（）メソッドを作成する以外に、これを修正する方法はありますか？

読んでくれてありがとう！

4

2 に答える 2

4

これは、この質問に対する私の答えの作り直しです

階層内のすべての派生クラスに基本クラスからクローン可能性（ポリモーフィックコピー）を継承させることを目的としているため、各クラスにのオーバーライドを提供する必要はありませんがclone()、クラステンプレートを使用して試行したCRTPソリューション BaseCopyableはこのようにしてBase、そのような派生クラスから派生したクラスではなく、からすぐに派生したクラスにクローン可能性を付与します。

最上位の具象クラスで「一度だけ」クローン可能性を付与することによって、任意の深い階層のすぐ下にクローン可能性を伝播することは不可能だと思います。各具象クラスに明示的に付与する必要がありますが、階層内の親クラスから子にクローン可能性を中継するCRTPテンプレートを使用することにより、基本クラスを介して、繰り返しオーバーライドすることなくこれを行うことができます。clone()

明らかに、この法案に適合するCRTPテンプレートは、親タイプと子タイプの2つのBaseCopyableテンプレートパラメーター を必要とする点とは異なります。

C ++ 03ソリュ​​ーションは、次のプログラムで示されているとおりです。

#include <iostream>

// As base of D, this makes D inherit B and makes D cloneable to
// a polymorphic pointer to B
template<class B, class D>
struct cloner : virtual B
{
    virtual B *clone() const {
        return new D(dynamic_cast<D const&>(*this));
    }
    virtual ~cloner() {}       
};

struct Base 
{
    virtual ~Base() {
         std::cout << "I was a Base" << std::endl;
    };
    virtual Base* clone() const = 0;
}; 

struct A : cloner<Base,A> // A inherits Base
{
    virtual ~A() {
         std::cout << "I was an A" << std::endl;
    };
};

struct B : cloner<Base,B> // B inherits Base
{
    virtual ~B() {
         std::cout << "I was a B" << std::endl;
    };
};

struct DB : cloner<B,DB> // DB inherits B, Base
{
    virtual ~DB() {
         std::cout << "I was a DB" << std::endl;
    };
};

int main()
{
    Base * pBaseA = new A;
    Base * pBaseB = new B;
    Base * pBaseDB = new DB;
    Base * pBaseCloneOfA = pBaseA->clone();
    Base * pBaseCloneOfB = pBaseB->clone();
    Base *pBaseCloneOfDB = pBaseDB->clone();
    B * pBCloneOfDB = dynamic_cast<B*>(pBaseDB->clone());
    std::cout << "deleting pBaseA" << std::endl; 
    delete pBaseA;
    std::cout << "deleting pBaseB" << std::endl;
    delete pBaseB;
    std::cout << "deleting pBaseDB" << std::endl;
    delete pBaseDB;
    std::cout << "deleting pBaseCloneOfA" << std::endl;
    delete pBaseCloneOfA;
    std::cout << "deleting pBaseCloneOfB" << std::endl; 
    delete pBaseCloneOfB;
    std::cout << "deleting pBaseCloneOfDB" << std::endl;    
    delete pBaseCloneOfDB;
    std::cout << "deleting pBCloneOfDB" << std::endl;   
    delete pBCloneOfDB;
    return 0;
}

出力は次のとおりです。

deleting pBaseA
I was an A
I was a Base
deleting pBaseB
I was a B
I was a Base
deleting pBaseDB
I was a DB
I was a B
I was a Base
deleting pBaseCloneOfA
I was an A
I was a Base
deleting pBaseCloneOfB
I was a B
I was a Base
deleting pBaseCloneOfDB
I was a DB
I was a B
I was a Base
deleting pBCloneOfDB
I was a DB
I was a B
I was a Base

関連するすべてのクラスがデフォルトで構築可能である場合、の仮想ベースでB ある必要はなく、 からキーワードを削除できます。それ以外の場合は、のコンストラクターがデフォルト以外のコンストラクターを呼び出すことができるように、仮想ベースである必要がありますが、の直接ベースではありません。cloner<B,D>virtualstruct cloner : virtual BBBDBD

可変個引数テンプレートがあるC++11では、任意のコンストラクター引数をからにcloner<B,D>転送できる「汎用」テンプレートコンストラクターを提供することで、仮想継承なしで完全に実行できます。これがその実例です：DB

#include <iostream>

template<class B, class D>
struct cloner : B
{
    B *clone() const override {
        return new D(dynamic_cast<D const&>(*this));
    }
    ~cloner() override {}
    // "All purpose constructor"
    template<typename... Args>
    explicit cloner(Args... args)
    : B(args...){}  
};

struct Base 
{
    explicit Base(int i)
    : _i(i){}   
    virtual ~Base() {
         std::cout << "I was a Base storing " << _i << std::endl;
    };
    virtual Base* clone() const = 0;
protected:
    int _i;
}; 

struct A : cloner<Base,A>
{
    explicit A(int i)
    : cloner<Base,A>(i){}
    ~A() override {
         std::cout << "I was an A storing " << _i << std::endl;
    };
};

struct B : cloner<Base,B>
{
    explicit B(int i)
    : cloner<Base,B>(i){}
    ~B() override {
         std::cout << "I was a B storing " << _i << std::endl;
    };
};

struct DB : cloner<B,DB>
{
    explicit DB(int i)
    : cloner<B,DB>(i){}
    ~DB() override {
         std::cout << "I was a DB storing " << _i << std::endl;
    };
};

int main()
{
    Base * pBaseA = new A(1);
    Base * pBaseB = new B(2);
    Base * pBaseDB = new DB(3);
    Base * pBaseCloneOfA = pBaseA->clone();
    Base * pBaseCloneOfB = pBaseB->clone();
    Base * pBaseCloneOfDB = pBaseDB->clone();
    B * pBCloneOfDB = dynamic_cast<B*>(pBaseDB->clone());
    std::cout << "deleting pA" << std::endl; 
    delete pBaseA;
    std::cout << "deleting pB" << std::endl;
    delete pBaseB;
    std::cout << "deleting pDB" << std::endl;
    delete pBaseDB;
    std::cout << "deleting pBaseCloneOfA" << std::endl;
    delete pBaseCloneOfA;
    std::cout << "deleting pBaseCloneOfB" << std::endl; 
    delete pBaseCloneOfB;
    std::cout << "deleting pBaseCloneOfDB" << std::endl;    
    delete pBaseCloneOfDB;
    std::cout << "deleting pBCloneOfDB" << std::endl;   
    delete pBCloneOfDB;
    return 0;
}

そして、出力は次のとおりです。

deleting pA
I was an A storing 1
I was a Base storing 1
deleting pB
I was a B storing 2
I was a Base storing 2
deleting pDB
I was a DB storing 3
I was a B storing 3
I was a Base storing 3
deleting pBaseCloneOfA
I was an A storing 1
I was a Base storing 1
deleting pBaseCloneOfB
I was a B storing 2
I was a Base storing 2
deleting pBaseCloneOfDB
I was a DB storing 3
I was a B storing 3
I was a Base storing 3
deleting pBCloneOfDB
I was a DB storing 3
I was a B storing 3
I was a Base storing 3
于 2013-05-17T08:49:09.850 に答える
0

あなたができることは、継承階層全体にベースを伝播することですが、これが特に役立つとは思いません。それ以降のすべての派生クラスでは、まったく新しい階層が得られ、すべてのポリモーフィズムは無駄になります。

#include <iostream>

class Base 
{
public:
     virtual ~Base() {};
     virtual Base* clone() const = 0;
}; 

template<class Derived> class BaseCopyable : Base
{ 
public:
    virtual Base* clone() const
    {
        return new Derived(static_cast<Derived const&>(*this));
    }
};

struct Default;

template<typename Self, typename Arg>
struct SelfOrArg {
  typedef Arg type;
};

template<typename Self>
struct SelfOrArg<Self, Default> {
  typedef Self type;
};

template<typename Derived = Default>
class A : public BaseCopyable< typename SelfOrArg<A<Derived>, Derived>::type >
{

};

class derivedA : A<derivedA> {

};

これには、のリターンタイプが壊れているという欠点がありますが BaseCopyable。古典的なvirtual constructorイディオムを使用すると、次のようなことを言うことができます。

void func(Derived& d) {
  // thanks to covariant return types Derived::clone returns a Derived*
  Derived* d2 = d.clone();
  delete d2;
}

これはあなたのスキームでは不可能ですが、でリターンタイプを調整することで簡単に可能BaseCopyableです。

ボイラープレートを取り除くためにマクロを書くだけです:)

于 2012-02-23T23:34:57.433 に答える