8

編集:いくつかのコメントによると、単純とは、a) コードが少なく、b) 保守が容易で、c) 間違いにくいことを意味します。

編集 #2:また、プライベート継承の代わりに包含を使用することは、実装が実際に簡素化される場合、好ましくありませんInterfaceImpl

現在、これを行う唯一の方法は、実装者に抽象メソッドを定義させ、呼び出しをターゲットの基本型のメソッドに委任することです。例:

#include <iostream>
#include <memory>

class Interface
{
public:
    virtual void method1() = 0;
    virtual void method2(int x) = 0;
};

class MethodOneImpl
{
 private:
    void method1(int x)
    { std::cout << "MethodOneImpl::method1() " << x << std::endl; }

 public:
    void method1() { method1(0); }
};

class MethodTwoImpl
{
 public:
    void myFunc(int x)
    { std::cout << "MethodTwoImpl::myFunc(x)" << x << std::endl; }
};

class InterfaceImpl : public Interface
                    , private MethodOneImpl
                    , private MethodTwoImpl
{
public:    
    virtual void method1() { MethodOneImpl::method1(); }
    virtual void method2(int x) { MethodTwoImpl::myFunc(x); }
};

int main()
{
    std::unique_ptr<Interface> inf;
    inf.reset(new InterfaceImpl);
    inf->method1();
    inf->method2(0);

    // This should be disallowed!
    // std::unique_ptr<MethodOneImpl> moi;
    // moi.reset(new InterfaceImpl);
}

最初は、おそらくこれで問題が解決するのではないかと思いました。

class InterfaceImpl : public Interface
                    , private MethodOneImpl
                    , private MethodTwoImpl
{
public:    
    using MethodOneImpl::method1;
    // Obviously this wouldn't work as the method names don't match.
    //using MethodTwoImpl::??? 
};

最初の using ステートメントは両方のMethodOneImpl::method1メソッドをパブリックにしますが、実際には との契約を履行せずInterface、 のアクセシビリティを変更しますMethodOneImpl::method1(int)。そして明らかにmethod2、名前が一致しないため、このソリューションを使用できませんでした。

FWIW、私は解決策だと思うものを持っていますが、それは標準の一部ではありません(つまり、コンパイルされません)。私は C++ 委員会に提案をしようと考えていました。誰かアドバイスがあれば、以下のコメントをいただければ幸いです (ただし、アドバイスを回答として提出しないでください)。

4

5 に答える 5

4

別のオプション (少なくとも MS VC++ を使用している場合) は、仮想継承を使用することです。

struct MyInterface
{
    virtual void Method1() = 0;
    virtual void Method2() = 0;
};

class Method1Impl : public virtual MyInterface
{
    virtual void Method1() { _tprintf( _T("Method1\n") ); }
};

class Method2Impl : public virtual MyInterface
{
    virtual void Method2() { _tprintf( _T("Method2\n") ); }
};

class InterfaceImpl : public virtual MyInterface,
                      private Method1Impl,
                      private Method2Impl
{
};

void TestWeirdInterfaceImpl()
{
    MyInterface*    pItf = new InterfaceImpl();

    pItf->Method1();
    pItf->Method2();
}

これは機能し、探しているものを満たしているように見えますが (#pragma で抑制する必要があるという C4250 の警告は別として)、これは私のアプローチではありません。(仮想継承はまだすべてのコンパイラでサポートされているものではないと思いますが、間違っている可能性があります)。

私はおそらく封じ込めを行い、定型コードが識別子になったら、それをある種のマクロマップ (ATL や MFC のマップに似ています) にラップして、それを台無しにすることを非常に困難にします。

したがって、これは私のマクロアプローチになります。

struct MyInterface
{
    virtual float Method1( int x ) = 0;
    virtual int Method2( float a, float b ) = 0;
    virtual void Method3( const TCHAR* sz ) = 0;
};

class Method1Impl
{
public:
    float Method1( int x ) {
        _tprintf( _T("Method1: %d\n"), x ); return 5.0;
    }
};

class Method2and3Impl
{
public:
    int Method2( float a, float b ) {
        _tprintf( _T("Method2: %f, %f\n"), a, b ); return 666;
    }

    void Method3( const TCHAR* sz ) {
        _tprintf( _T("Method3: %s"), sz );
    }
};


#define DECLARE_METHOD0( MethodName, Obj, R )   \
    virtual R MethodName() { return Obj.MethodName(); }

#define DECLARE_METHOD1( MethodName, Obj, R, A1 )   \
    virtual R MethodName( A1 a1 ) { return Obj.MethodName( a1 ); }

#define DECLARE_METHOD2( MethodName, Obj, R, A1, A2 )   \
    virtual R MethodName( A1 a1, A2 a2 ) { return Obj.MethodName( a1, a2 ); }


class InterfaceImpl : public MyInterface
{
public:
    DECLARE_METHOD1( Method1, m_method1Impl, float, int );
    DECLARE_METHOD2( Method2, m_method2and3Impl, int, float, float );
    DECLARE_METHOD1( Method3, m_method2and3Impl, void, const TCHAR* );

private:
    Method1Impl         m_method1Impl;
    Method2and3Impl     m_method2and3Impl;
};

void TestWeirdInterfaceImpl()
{
    MyInterface*    pItf = new InterfaceImpl();

    pItf->Method1( 86 );
    pItf->Method2( 42.0, 24.0 );
    pItf->Method3( _T("hi") );
}

C++ の神々が可変引数マクロで私たちを祝福するまでは、パラメータの数ごとに 1 つを宣言する必要があります。また、多重継承を使用した場合、2 番目の「Obj」パラメーターは必要ない可能性がありますが、前に述べたように、別の解決策 (この場合は 1 つの追加パラメーター) がある場合は多重継承を避けます。

しかし、3 番目のオプションは、Pragmatic Programmerの作成者がよく提唱しているように見えるものです。あなたが指摘したように、人的エラーが発生するため、繰り返したくないクッキーカッターコードが大量にある場合。独自の言語を定義し、コード ジェネレーター スクリプト (python、perl...) を記述して、実際のコードを自動作成します。この場合、インターフェイスを指定して、スクリプトにテキストを書き出させることができます。私はこの種のことを自分でやろうとしたことはありませんが、最近、結果を見て評価するためだけにどこかで使用したいと思っています.

于 2011-11-14T17:25:21.740 に答える
0

継承しないと仮想テーブルがいっぱいにならないため、MethodOneImpl /を継承せずMethodTwoImplに のスコープに入れることは不可能のようです。C++ は、他の言語のキーワードのようなものを欠いています。InterfaceInterfaceimplements

したがって、探しているのは要件 a) (より多くのコードを作成する必要があります)、中途半端に b) (保守が必ずしも困難ではないコード) を満たさない単なるブリッジ パターンであることを認識/受け入れない限り、仮想継承の問題に悩まされます。 ) であり、c) を満たす場合があります。

ここで(別の)可能な解決策(肥大化を減らす方法のみ)

class Interface 
{ public:
 virtual void method1() {return impl_->method1();}
 private:
     Interface() {}
 protected:
     struct Impl {
         virtual void method1() = 0; };
     std::shared_ptr<Impl> impl_;
     Interface(const std::shared_ptr<Impl> &impl) : impl_(impl) {}
};

  class InterfaceImpl : public Interface
{
  struct Impl : public Interface::Impl {
      void method1()  { std::cout << "InterfaceImpl::method1() " << std::endl; }  } ;
public:
    InterfaceImpl() : Interface(std::shared_ptr<Impl> (new Impl)) {}
      };

  template <class T>
  class GenericInterfaceImpl :  public Interface {
      struct Impl : public Interface::Impl {
          Impl( T &t) : t_(t) {}
          void method1() { t_.method1() ; } 
          T t_; };
public:
    GenericInterfaceImpl() : Interface(std::shared_ptr<Impl> (new Impl(T()))) {}
      };

 struct AMethod1Impl {
     void method1() { std::cout << "AMethod1Impl::method1() " << std::endl; }  } ;

struct AnotherMethod1Impl_not_working {
     void method1_not_present() { std::cout << "AnotherMethod1Impl_not_working ::method1_not_present() " << std::endl; }  } ;

int main() {
 // compilation of next line would fail 
 // (lame attempt to simulate ompilation fail when pure function not implemented)
 // Interface inf;

 std::unique_ptr<Interface> inf;
 inf.reset(new InterfaceImpl);
 inf->method1();
 inf.reset(new GenericInterfaceImpl<AMethod1Impl>() );
 inf->method1();

 // compilation of next line would fail
 // inf.reset(new GenericInterfaceImpl<AnotherMethod1Impl_not_working>() );

    }
于 2011-11-17T09:56:14.883 に答える
0

これはあなたの目的に役立ちますか?インターフェイスの関係を維持し、クライアント コードを考慮せずに保守可能なコードを提供します。

functionoid で各メソッドを分離し、異なる基本クラスの各メソッドのプロトタイプを制御する機能を提供します。

#include <iostream>
#include <memory>
using namespace std;

    //No Control over this.
    class MethodOneImpl
    {
     private:
        void method1(int x)
        { std::cout << "MethodOneImpl::method1() " << x << std::endl; }

     public:
        void method1() { method1(0); }
    };

    class MethodTwoImpl
    {
     public:
        void myFunc(int x)
        { std::cout << "MethodTwoImpl::myFunc(x)" << x << std::endl; }
    };

    //*************************//

    class Interface
    {
    public:
        virtual void method1() = 0;
        virtual void method2(int x) = 0;
    };

    //This is what i would do. //

    class BaseFuncType
    {
    //no pure virtual
    void Call()
          {
              throw "error";
          }
    void Call(int x)
          {
              throw "error";
          }
    };


    class Method1: public BaseFuncType
    {
    auto_ptr<MethodOneImpl> MethodPtr;
    public:
    Method1()
    {
        MethodPtr.reset(new MethodOneImpl());
    }
    virtual int Call() 
    {
        MethodPtr->method1(); 
    }
    };

    class Method2: public BaseFuncType
    {
        auto_ptr<MethodTwoImpl> MethodPtr;
    public:
    Method2()
    {
       MethodPtr.reset(new MethodTwoImpl());
    }
    virtual int Call(int x) 
    {
        MethodPtr->myFunc(x);
    }
    };
    template <class T1>
    class MethodFactory
    {
    private:
       T1 methodObj;
    public:
    void CallMethod()
    {
       methodObj.Call();
    }
    void CallMethod(int x)
    {
       methodObj.Call(x);
    }

    };
    class InterfaceImpl : public Interface
    {
        auto_ptr<MethodFactory> factory;
    public:
        virtual void method1() 
        {   
            factory.reset(new MethodFactory<Method1>());
            factory->CallMethod(); 
        }
        virtual void method2(int x) 
        { 
            factory.reset(new MethodFactory<Method2>());
            factory->CallMethod(x); 
        }
    };

    int main()
    {
        auto_ptr<Interface> inf;
        inf.reset(new InterfaceImpl);
        inf->method1();
        inf->method2(10);

        // This should be disallowed!
        // std::unique_ptr<MethodOneImpl> moi;
        // moi.reset(new InterfaceImpl);
    }
于 2011-11-15T20:25:08.117 に答える
0
class AbsInterface
{
    // this is a simple interface class.
public:
    virtual void Method1() = 0;
    virtual void Method2() = 0;
};

class Functor1
{
public:
    void operator () ()
    {
        printf("This Is Void Functor1");
    }
};

class Functor2
{
public:
    void operator () ()
    {
    printf("This Is void Functor2");
    }
};

template <class T1, class T2>
class DerivedTemplateClass : public AbsInterface
{
public:
    virtual void Method1() { T1()(); }
    virtual void Method2() { T2()(); }
};

void main()
{
    DerivedTemplateClass<Stratege1, Stratege2> instance;
    instance.Method1();
    instance.Method2();
}

ご覧のとおり、Functor を使用しました。テンプレートとファンクターを使用できます。

于 2011-11-15T08:45:59.133 に答える