0

インターフェイスを使用して実装の詳細を隠すというアイデアが気に入っています。また、以前に作成したクラスを基に構築する方法として継承を使用することも非常に楽しんでいます。これらの両方の利点を共存させるにはどうすればよいですか? これが私の問題の例です：

object.h

class object {
    protected:
        //stuff that should be available to derived classes
        virtual void    derivedHelper    () = 0;

    public:
        //stuff that should be available to the client
        virtual object* create           () = 0;
        virtual void    mainTask         () = 0;
}

object.cpp

class objectPriv : public object {
    private:
        //implementation specific details and members
    protected:
        void derivedHelper () {
             //some stuff
        }
    public:
        objectPriv() { }

        object* create () {
            return(new objectPriv());
        }
        void mainTask () {
            //more stuff
        }
}

superObject.h

class superObject : public object {             //problem #1
    public:
        //stuff that should be available to the client
        virtual superObject* create  () = 0;
}

superObject.cpp

class superObjectPriv : public superObject {    //problem #2
    private:
        //the magic behind super object

    public:
        superObjectPriv() { }

        superObject* create () {
            return(new superObjectPriv());
        }

        void mainTask () {
            object::mainTask();                 //problem #3
            object::derivedHelper();            //problem #4
            //super extra stuff
        }
}

したがって、これがコンパイルされないことがわかります。

superObject のオブジェクトの純粋な仮想を実装することはできますが、それはオブジェクトから派生するという目的を無効にします。実装を複製したくありません。その上に構築したいのです。

superObject を objectPriv から派生するように変更することもできますが、実装の詳細を公開することになります。objectPriv に固有のすべてをすべての人から隠したいと思います。

これを達成する方法は考えられません。私はそれが不可能かもしれないという悪い予感を持っていますが、皆さんが私のためにいくつかの巧妙なトリックを持っていることを願っています :)

ありがとうレス

4

1 に答える 1

0

ミックスインのパターンを考慮しましたか? 複数のクラスに共有実装を追加する方法です。引数から派生するテンプレート クラスを定義します。ObjectPriv と SuperObjectPriv の共通の動作でそれを行うことができます。

template <typename ParentT>
class CommonFunctionalityMixin
: public ParentT   // this is the magic line that makes it a mixin
{
    public:
        typedef ParentT parent_type;

        virtual void mainTask()      { /* implementation */ }
        virtual void derivedHelper() { /* implementation */ }
};

class ObjectPriv
: public CommonFunctionalityMixin<object> // which derives from object
{
    public:
        typedef CommonFunctionalityMixin<object> parent_type;

        virtual object* create()     { return new ObjectPriv; }
        // virtual void mainTask() defined in CommonFunctionalityMixin
        // virtual void derivedHelper() defined in CommonFunctionalityMixin
};

class SuperObjectPriv
: public CommonFunctionalityMixin<superObject> // which derives from superObject
{
    public:
        typedef CommonFunctionalityMixin<object> parent_type;

        virtual object* create()     { return new SuperObjectPriv; }

        // now we override CommonFunctionalityMixin's mainTask() with super's
        virtual void mainTask()
        {
            parent_type::mainTask();
            parent_type::derivedHelper();
        }
};
于 2013-09-07T22:26:40.697 に答える