2

任意のデータを保持し、関連するクラスのメンバー関数を呼び出す汎用の「コールバック」オブジェクトを作成しようとしています。内部ポリシーにより、Boost を使用できません。

コールバック オブジェクトは次のようになります。

template<typename Object, typename Data>
class Callback
{
public:
  typedef void (Object::*PHandler)(Callback*);
  Callback(Object* obj, PHandler handler) : pObj(obj), pHandler(handler) {}
  Callback& set(PHandler handler) { pHandler = handler; return *this; }
  void run() { (pObj->*pHandler)(this); }

public:
  Data data;

protected:
  Object* pObj;
  PHandler pHandler;
};

そして、それが動作するクラス:

struct Object1
{
  struct Data { int i; };

  typedef Callback<Object1, Data> Callback1;

  void callback(Callback1* pDisp) { printf("%cb\n", pDisp->data.i); }

  void test()
  {
    Callback1 cb(this, &Object1::callback);
    cb.data.i = 1;
    cb.run();
  }
};

次のテストは期待どおりに機能します。

Object1 obj1;
obj1.test();

ここまでは順調ですね。

ただし、同僚がCallbackを使用する代わりにクラスから派生しようとするtypedefと、互換性のないポインターが原因でコンパイル エラーが発生しました。

struct Object2
{
  struct Data { int i; Data(int j) { i = j; } };

  class Callback2 : public Callback<Object2, Data>
  {
    Callback2(Object2* obj, PHandler handler, int i) : Callback(obj, handler) { data.i = i; }
  };

  void callback(Callback2* pDisp) { printf("%cb\n", pDisp->data.i); }

  void test()
  {
    Callback2 cb(this, &Object2::callback, 2);
    cb.run();
  }
};

Callback クラスで「奇妙な繰り返しテンプレート パターン」を使用してみましたが、派生クラスを動作させることができましたが、typedefメソッドを使用するコードが壊れました。

私の質問は：

クラスのユーザー側で余分な作業を必要とせずに、両方のケースで動作するようにクラスを変更するにはどうすればよいですか?Callback

4

3 に答える 3

1

車輪の再発明と青銅器時代の C++ の使用を提唱する会社で働いていることは残念です。ただし、状況と投稿したコードを考えると、あまり多くの変更を加えることなく、かなり単純な解決策があります。会社のポリシーのためではなく、ソフトウェア開発キットを開発していて、SDK のユーザーに特定のバージョンのブーストをインストールすることを要求したくなかったため、以前にも同様のことをしなければなりませんでした。

ところで、あなたが本当に求めているのはシグナルとスロットのメカニズムだと思います。この設計を確立されたソリューションにもう少し適合させたい場合は、それを検討することをお勧めします。

私はいくつかのリベラルな仮定を採用しました。主な仮定は、Data をコールバックに格納する必要はなく、代わりに送信者が渡すことができるというものです。これは、より柔軟な設計にする必要があります。これはまだ非常に単純です。これをさらに進めることができます (例: 可変数の引数とカスタムの戻り値の型、シグナル クラス、遅延通知など)。

template<typename Data>
class CallbackInterface
{
public: 
    virtual ~CallbackInterface() {}
    virtual void run(const Data& data) = 0;
    virtual CallbackInterface* clone() const = 0;
};

template<typename Object, typename Data>
class CallbackMethod: public CallbackInterface<Data>
{
public:
    typedef void (Object::*PHandler)(const Data&);
    CallbackMethod(Object* obj, PHandler handler) : pObj(obj), pHandler(handler) {}
    virtual void run(const Data& data) { (pObj->*pHandler)(data); }
    virtual CallbackInterface* clone() const {return new CallbackMethod(*this); }

protected:
    Object* pObj;
    PHandler pHandler;
};

template <class Data>
class Callback
{
public:
    template <class Object>
    Callback(Object* obj, void (Object::*method)(const Data&) ):
        cb(new CallbackMethod<Object, Data>(obj, method)) 
    {
    }

    Callback(const Callback& other): cb(other.cb->clone() )
    {

    }

    Callback& operator=(const Callback& other) 
    {
        delete cb;
        cb = other.cb->clone();
        return *this;
    }

    ~Callback() 
    {
        delete cb; 
    }

    void operator()(const Data& data) const
    {
       cb->run(data);
    }

private:
    CallbackInterface<Data>* cb;
};

使用例:

struct Foo
{
    void f(const int& x)
    {
        cout << "Foo: " << x << endl;
    }
};

struct Bar
{
    void f(const int& x)
    {
        cout << "Bar: " << x << endl;
    }
};

int main()
{
    Foo f;
    Callback<int> cb(&f, &Foo::f);
    cb(123); // outputs Foo: 123

    Bar b;
    cb = Callback<int>(&b, &Bar::f);
    cb(456); // outputs Bar: 456
}

ご覧のとおり、 Callback オブジェクト自体はオブジェクト型をテンプレート引数として渡す必要がないため、メソッドが署名に準拠していれば、任意の型のメソッドを指すことができます: void some_class::some_method(constデータ＆）。これらの Callback オブジェクトのリストを、それらすべてを呼び出すことができるクラスに保存すると、スロットが接続されたシグナルが得られます。

于 2010-06-24T22:46:13.500 に答える
0

派生のクラスタイプを渡す必要があります。typedef-wayを壊さないように、そのパラメーターにデフォルト値を与えることができます。次のようなものが機能するはずです

template<typename Object, typename Data, typename Derived = void>
class Callback;

namespace detail {
template<typename Object, typename Data, typename Derived>
struct derived { 
  typedef Derived derived_type;
};

template<typename Object, typename Data>
struct derived<Object, Data, void> { 
  typedef Callback<Object, Data, void> derived_type;
};
}

template<typename Object, typename Data, typename Derived>
class Callback : detail::derived<Object, Data, Derived>
{
  typedef typename 
    detail::derived<Object, Data, Derived>::derived_type
    derived_type;

  derived_type &getDerived() {
    return static_cast<derived_type&>(*this);
  }

public:
  // ... stays unchanged ...

  derived_type& set(PHandler handler) { 
    pHandler = handler; return getDerived(); 
  }
  void run() { (pObj->*pHandler)(&getDerived()); }

  // ... stays unchanged ...
};

または、このために2つのクラスを作成することもできます。1つは継承用で、もう1つは継承しない場合です。1つ目は継承用です

template<typename Object, typename Data, typename Derived>
class CallbackBase
{
  typedef Derived derived_type;

  derived_type &getDerived() {
    return static_cast<derived_type&>(*this);
  }

public:
  // ... stays unchanged ...

  derived_type& set(PHandler handler) { 
    pHandler = handler; return getDerived(); 
  }
  void run() { (pObj->*pHandler)(&getDerived()); }

  // ... stays unchanged ...
};

そして2つ目は非継承です。これには基本クラスを利用できます

template<typename Object, typename Data>
struct Callback : CallbackBase<Object, Data, Callback<Object, Data> > {
  Callback(Object* obj, PHandler handler) : Callback::CallbackBase(obj, handler) {}
};
于 2010-06-24T16:43:47.117 に答える
-2

内部ポリシーにより、Boost を使用できません。

終了する ;）

ただし、同僚が typedef を使用する代わりに Callback クラスから派生しようとしたとき

それらを撃ちます。

私はあなたに同情します、私は本当にそうします。

于 2010-06-24T16:40:22.017 に答える