4

私はsのベクトルを持っていますKeyCallback:

typedef boost::function<void (const KeyEvent&)> KeyCallback

キーボード ボタンが押されたときのすべてのリスナーを格納するために使用します。それらを追加して、すべてのコールバックにイベントをディスパッチすることはできますが、ベクトルから特定の署名for_eachを実際に消去する方法がわかりません。KeyCallback

たとえば、次のようなものが必要です。

void InputManager::UnregisterCallback(KeyCallback callback) {
  mKeyCallbacks.erase(std::find(mKeyCallbacks.begin(), mKeyCallbacks.end(), callback));
}

boost::functionドキュメント（こちらを参照）によると、関数オブジェクトを比較するようなものはありません。これにより、上記の問題が説明されます。それで私は立ち往生していますか？これを回避する良い方法はありますか？

(コールバック メカニズムについて読んだことboost::signalsがありますが、どうやらかなり遅いようです。また、コールバックが 1 フレームに数回発生する可能性があると予想しています。)

4

2 に答える 2

8

アプローチ #1:

http://www.boost.org/doc/libs/1_51_0/doc/html/function/tutorial.html#id1546064

関数オブジェクト ラッパーは、== または != を介して、ラッパー内に格納できる任意の関数オブジェクトと比較できます。

したがって、解決策の 1 つは、UnregisterCallback のパラメーターに特別な型を定義することです (これは、型の消去もサポートします)。これは、boost::function と functor/function を比較できるという事実に基づいています。結果として、boost::function のベクトルが残るため、新しい型は、比較を実行する必要がある場所 (UnregisterCallback など) にのみ必要です。

ライブデモ

#include <boost/scoped_ptr.hpp>
#include <boost/function.hpp>
#include <algorithm>
#include <iostream>
#include <typeinfo>
#include <ostream>
#include <vector>
#include <string>

using namespace std;
using namespace boost;

typedef int KeyEvent;
typedef function<void (const KeyEvent &)> KeyCallback;

struct AbstractCallback
{
    virtual bool equals(const KeyCallback &f) const=0;
    virtual ~AbstractCallback(){}
};

template<typename Callback>
struct ConcreteCallback : AbstractCallback
{
    const Callback &callback;
    explicit ConcreteCallback(const Callback &p_callback) : callback(p_callback) {}
    virtual bool equals(const KeyCallback &f) const
    {
        return callback == f;
    }
};

struct KeyCallbackChecker
{
    scoped_ptr<AbstractCallback> func;
public:
    template<typename Func>
    KeyCallbackChecker(const Func &f) : func(new ConcreteCallback<Func>(f)) {}
    friend bool operator==(const KeyCallback &lhs,const KeyCallbackChecker &rhs)
    {
        return rhs.func->equals(lhs);
    }
    friend bool operator==(const KeyCallbackChecker &lhs,const KeyCallback &rhs)
    {
        return rhs==lhs;
    }
};

void func1(const KeyEvent &)
{
    cout << "func1" << endl;
}

void func3(const KeyEvent &)
{
    cout << "func3" << endl;
}

class func2
{
    int data;
public:
    explicit func2(int n) : data(n) {}
    friend bool operator==(const func2 &lhs,const func2 &rhs)
    {
        return lhs.data==rhs.data;
    }
    void operator()(const KeyEvent &)
    {
        cout << "func2, data=" << data << endl;
    }
};

struct Caller
{
    template<typename F> void operator()(F f)
    {
        f(1);
    }
};

class Callbacks
{
    vector<KeyCallback> v;
public:
    void register_callback(const KeyCallback &callback)
    {
        v.push_back(callback);
    }
    void unregister_callback(const KeyCallbackChecker &callback)
    {
        vector<KeyCallback>::iterator it=find(v.begin(),v.end(),callback);
        if(it!=v.end())
            v.erase(it);
    }
    void call_all()
    {
        for_each(v.begin(),v.end(),Caller());
        cout << string(16,'_') << endl;
    }
};

int main(int argc,char *argv[])
{
    Callbacks cb;
    cb.register_callback(func1);
    cb.register_callback(func2(1));
    cb.register_callback(func2(2));
    cb.register_callback(func3);
    cb.call_all();

    cb.unregister_callback(func2(2));
    cb.call_all();
    cb.unregister_callback(func1);
    cb.call_all();

return 0;
}

出力は次のとおりです。

func1
func2, data=1
func2, data=2
func3
________________
func1
func2, data=1
func3
________________
func2, data=1
func3
________________

長所：

  • 登録文字列とベクターへの保存には引き続きboost::関数を使用します
  • Functor オブジェクトは、それを unregister_callback に渡す必要がある場合にのみ、比較を定義する必要があります
  • これは簡単に一般化できます。typedefed KeyCallback を使用する代わりに、テンプレート パラメーターを 1 つ追加するだけです。したがって、他のタイプのコールバックのために、他の場所で簡単に使用できます。

短所：

  • ユーザーがすでに boost::function にラップされたコールバックを持っている場合 - unregister_callback では使用できません。これは、boost::function と比較できるものが必要なためです (たとえば、関数ポインター、または定義された比較を持つファンクター)。

アプローチ #2:

もう 1 つのアプローチは、カスタムの boost::function のようなソリューションを実装することです。これは、比較可能なコールバックのみを受け入れます。

ライブデモ

#include <boost/shared_ptr.hpp>
#include <algorithm>
#include <iostream>
#include <typeinfo>
#include <ostream>
#include <vector>

using namespace std;
using namespace boost;

typedef int KeyEvent;
typedef void (*func_type)(const KeyEvent &);

struct AbstractCallback
{
    virtual void operator()(const KeyEvent &p)=0;
    virtual bool compare_to(const std::type_info &rhs_type,const void *rhs) const=0;
    virtual bool compare_to(const std::type_info &rhs_type,const func_type *rhs) const=0;
    virtual bool equals(const AbstractCallback &rhs) const=0;
};

template<typename Callback>
struct ConcreteCallback : AbstractCallback
{
    Callback callback;
    ConcreteCallback(Callback p_callback) : callback(p_callback) {}
    void operator()(const KeyEvent &p)
    {
        callback(p);
    }
    bool compare_to(const std::type_info &rhs_type,const void *rhs) const
    {
        return (typeid(Callback)==rhs_type) &&
            ( *static_cast<const Callback*>(rhs) == callback );
    }
    bool compare_to(const std::type_info &rhs_type,const func_type *rhs) const
    {
        return false;
    }
    bool equals(const AbstractCallback &rhs) const
    {
        return rhs.compare_to(typeid(Callback),&callback);
    }
};

template<>
struct ConcreteCallback<func_type> : AbstractCallback
{
    func_type callback;
    ConcreteCallback(func_type p_callback) : callback(p_callback) {}
    void operator()(const KeyEvent &p)
    {
        callback(p);
    }
    bool compare_to(const std::type_info &rhs_type,const void *rhs) const
    {
        return false;
    }
    bool compare_to(const std::type_info &rhs_type,const func_type *rhs) const
    {
        return *rhs == callback;
    }
    bool equals(const AbstractCallback &rhs) const
    {
        return rhs.compare_to(typeid(func_type),&callback);
    }
};


struct KeyCallback
{
    shared_ptr<AbstractCallback> func;
public:
    template<typename Func>
    KeyCallback(Func f) : func(new ConcreteCallback<Func>(f)) {}
    friend bool operator==(const KeyCallback &lhs,const KeyCallback &rhs)
    {
        return lhs.func->equals(*rhs.func);
    }
    void operator()(const KeyEvent &p)
    {
        (*func)(p);
    }
};

void func1(const KeyEvent &)
{
    cout << "func1" << endl;
}

void func3(const KeyEvent &)
{
    cout << "func3" << endl;
}

class func2
{
    int data;
public:
    func2(int n) : data(n) {}
    friend bool operator==(const func2 &lhs,const func2 &rhs)
    {
        return lhs.data==rhs.data;
    }
    void operator()(const KeyEvent &)
    {
        cout << "func2, data=" << data << endl;
    }
};

struct Caller
{
    template<typename F>
    void operator()(F f)
    {
        f(1);
    }
};

int main(int argc,char *argv[])
{
    vector<KeyCallback> v;

    v.push_back(KeyCallback(func1));
    v.push_back(KeyCallback(func1));
    v.push_back(KeyCallback(func1));

    v.push_back(KeyCallback(func2(1)));
    v.push_back(KeyCallback(func2(1)));

    v.push_back(KeyCallback(func2(2)));
    v.push_back(KeyCallback(func2(2)));
    v.push_back(KeyCallback(func2(2)));
    v.push_back(KeyCallback(func2(2)));

    v.push_back(KeyCallback(func3));

    for_each(v.begin(),v.end(),Caller());

    cout << count(v.begin(),v.end(),KeyCallback(func1)) << endl;
    cout << count(v.begin(),v.end(),KeyCallback(func2(1))) << endl;
    cout << count(v.begin(),v.end(),KeyCallback(func2(2))) << endl;
    cout << count(v.begin(),v.end(),KeyCallback(func3)) << endl;
    return 0;
}

出力は次のとおりです。

func1
func1
func1
func2, data=1
func2, data=1
func2, data=2
func2, data=2
func2, data=2
func2, data=2
func3
3
2
4
1

長所：

  • 登録/登録解除コールバックで同じ型を使用します。ユーザーは自分の関数とファンクターを外部にラップして KeyCallback に保存し、KeyCallback を unregister_callback に渡すことができます。
  • boost::function への依存関係はありません

短所：

  • unregister_callback で使用されていない場合でも、Functor オブジェクトには比較が定義されている必要があります
  • ユーザーが既に boost::function にラップされたコールバックを持っている場合、定義された比較が必要なため、KeyCallback に変換できません。
  • 異なる種類のコールバックを使用して、他の場所で同様の機能が必要な場合は、boost::function のようなクラスを改善する必要があります (さまざまなパラメーターを使用するなど)。または、boost::funciton 自体を抽出して変更することもできます。

アプローチ #3:

ここでは、std/boost ::function から継承された新しいクラスを作成しています

ライブデモ

#include <type_traits>
#include <functional>
#include <algorithm>
#include <stdexcept>
#include <iostream>
#include <typeinfo>
#include <utility>
#include <ostream>
#include <vector>
#include <string>

using namespace std;

// _____________________________Implementation__________________________________________

#define USE_VARIADIC_TEMPLATES 0

template<typename Callback,typename Function>
bool func_compare(const Function &lhs,const Function &rhs)
{
    typedef typename conditional<is_function<Callback>::value,typename add_pointer<Callback>::type,Callback>::type request_type;
    if (const request_type* lhs_internal = lhs.template target<request_type>())
        if (const request_type* rhs_internal = rhs.template target<request_type>())
            return *rhs_internal == *lhs_internal;
    return false;
}

#if USE_VARIADIC_TEMPLATES
    #define FUNC_SIG_TYPES typename ...Args
    #define FUNC_SIG_TYPES_PASS Args...
#else
    #define FUNC_SIG_TYPES typename function_signature
    #define FUNC_SIG_TYPES_PASS function_signature
#endif

template<FUNC_SIG_TYPES>
struct function_comparable: function<FUNC_SIG_TYPES_PASS>
{
    typedef function<FUNC_SIG_TYPES_PASS> Function;
    bool (*type_holder)(const Function &,const Function &);
public:
    function_comparable(){}
    template<typename Func>
    function_comparable(Func f_)
        : Function(f_), type_holder(func_compare<Func,Function>)
    {
    }
    template<typename Func>
    function_comparable &operator=(Func f_)
    {
        Function::operator=(f_);
        type_holder=func_compare<Func,Function>;
        return *this;
    }
    friend bool operator==(const Function &lhs,const function_comparable &rhs)
    {
        return rhs.type_holder(lhs,rhs);
    }
    friend bool operator==(const function_comparable &lhs,const Function &rhs)
    {
        return rhs==lhs;
    }
    friend void swap(function_comparable &lhs,function_comparable &rhs)// noexcept
    {
        lhs.swap(rhs);
        lhs.type_holder.swap(rhs.type_holder);
    }
};

// ________________________________Example______________________________________________

typedef void (function_signature)();

void func1()
{
    cout << "func1" << endl;
}

void func3()
{
    cout << "func3" << endl;
}

class func2
{
    int data;
public:
    explicit func2(int n) : data(n) {}
    friend bool operator==(const func2 &lhs,const func2 &rhs)
    {
        return lhs.data==rhs.data;
    }
    void operator()()
    {
        cout << "func2, data=" << data << endl;
    }
};
struct Caller
{
    template<typename Func>
    void operator()(Func f)
    {
        f();
    }
};
class Callbacks
{
    vector<function<function_signature>> v;
public:
    void register_callback_comparator(function_comparable<function_signature> callback)
    {
        v.push_back(callback);
    }
    void register_callback(function<function_signature> callback)
    {
        v.push_back(callback);
    }
    void unregister_callback(function_comparable<function_signature> callback)
    {
        auto it=find(v.begin(),v.end(),callback);
        if(it!=v.end())
            v.erase(it);
        else
            throw runtime_error("not found");
    }
    void call_all()
    {
        for_each(v.begin(),v.end(),Caller());
        cout << string(16,'_') << endl;
    }
};

int main()
{
    Callbacks cb;
    function_comparable<function_signature> f;
    f=func1;
    cb.register_callback_comparator(f);

    cb.register_callback(func2(1));
    cb.register_callback(func2(2));
    cb.register_callback(func3);
    cb.call_all();

    cb.unregister_callback(func2(2));
    cb.call_all();
    cb.unregister_callback(func1);
    cb.call_all();
}

出力は次のとおりです。

func1
func2, data=1
func2, data=2
func3
________________
func1
func2, data=1
func3
________________
func2, data=1
func3
________________

長所：

  • コールバックの登録/登録解除で同じ型を使用できます。ユーザーは自分の関数とファンクターを外部にラップして KeyCallback に保存し、KeyCallback を unregister_callback に渡すことができます。さらに、このバージョンでは、レジスタ関数のパラメータにプレーンな boost::function を使用できます。
  • 登録文字列とベクトルへの保存に boost::function を引き続き使用できます
  • 登録に boost::function を使用する場合、ファンクター オブジェクトは unregister_callback に渡す必要がある場合にのみ比較を定義する必要があります。
  • 一般化されているため、他の場所や他のタイプのコールバックで簡単に使用できます。
  • このバージョンは、割り当て + 抽象クラス (vptr) ではなく、単純な関数ポインターに基づいています。そのため、不適切な操作が 1 つ少なくなり、管理が容易になります。

短所：

  • ユーザーがすでに boost::function にラップされたコールバックを持っている場合 - unregister_callback では使用できません。これは、boost::function と比較できるものが必要なためです (たとえば、関数ポインター、または定義された比較を持つファンクター)。

編集：

素晴らしい、私は今 #1 を試していますが、独自の == 演算子を適用するとなぜ機能するのかよくわかりません。

boost::functionは、関数またはファンクターと比較できますが、別の boost::function と比較することはできません。

#include <boost/function.hpp>

void f1(){}
void f2(){}

int main()
{
    boost::function<void ()> bf1(f1),bf2(f2);
    bf1 == f1; // Works OK
    //bf1 == bf2; - COMPILE ERROR
    return 0;
}

#1 のアプローチでは、「bf1 == f1;」と同様の比較を行います。KeyCallbackChecker はファンクター/関数をキャプチャし、ConcreteCallback::equals 内でそのような種類の比較を実行します。

于 2012-10-27T00:08:25.053 に答える
0

あなたの問題を正しく理解しているかどうかわかりません。私の理解では、KeyCallback関数オブジェクトのベクトルがあるということです。それぞれに同じ署名がありますvoid (const KeyEvent &)。通常、特定のKeyEventオブジェクトに対してそれぞれを呼び出します。そして、これらのオブジェクトの 1 つ以上をベクトルから削除したいとします。

私が正しければ、実際の問題は、特定のKeyCallbackオブジェクトをどのように識別するかということです。解決策の 1 つを次に示します。ポインターを使用します。

KeyCallbackオブジェクトが関数ポインタである場合、2 つの関数が同じアドレスを持つことはできません。を持つクラス オブジェクトの場合operator()、各具象オブジェクトには一意のアドレスがあります。したがって、次のコードが機能します。ただし、ベクターではなくmap. forまた、の代わりにループを使用する必要がありますfor_each。

#include <iostream>
#include <map>
#include <boost/function.hpp>

typedef int KeyEvent;
typedef boost::function<void (const KeyEvent &)> KeyCallback;

void func1 (const KeyEvent &x)
{
    std::cout << "Call func1 with " << x << std::endl;
}

void func2 (const KeyEvent &x)
{
    std::cout << "Call func2 with " << x << std::endl;
}

class func3
{
    public :

    void operator() (const KeyEvent &x) const
    {
        std::cout << "Call func3 with " << x << std::endl;
    }
};

class func4
{
    public :

    func4 () : data_(0) {}
    func4 (int d) : data_(d) {}

    void operator() (const KeyEvent &x) const
    {
        std::cout << "Call func4(" << data_ << ") with " << x << std::endl;
    }

    private :

    int data_;
};

template <typename T>
long ptol (T *p)
{
    void *vp = (void *) p;
    return reinterpret_cast<long>(vp);
}

int main()
{
    func3 f30;
    func4 f40;
    func4 f41(1);
    func4 f42(2);
    std::map<long, KeyCallback> callback;
    callback[ptol(&func1)] = func1;
    callback[ptol(&func2)] = func2;
    callback[ptol(&f30)] = f30;
    callback[ptol(&f40)] = f40;
    callback[ptol(&f41)] = f41;
    callback[ptol(&f42)] = f42;

    for (std::map<long, KeyCallback>::const_iterator m = callback.begin(); m != callback.end(); ++m)
        m->second(1);

    std::cout << "ERASE func1 and f41" << std::endl;

    callback.erase(ptol(&func1));
    callback.erase(ptol(&f41));

    for (std::map<long, KeyCallback>::const_iterator m = callback.begin(); m != callback.end(); ++m)
        m->second(1);

    return 0;
}

そして、ここに出力があります

Call func1 with 1
Call func2 with 1
Call func4(2) with 1
Call func4(1) with 1
Call func4(0) with 1
Call func3 with 1
ERASE func1 and f41
Call func2 with 1
Call func4(2) with 1
Call func4(0) with 1
Call func3 with 1

欠点は

  • 特定の順番で呼び出すことはできません。
  • などのオブジェクトは、挿入の外側で作成する必要がありますf40。callback.insert(std::make_pair(address, func4(5))); のように、関数オブジェクトをその場で挿入するためにf42使用することはできません。一時オブジェクトのアドレスを取得できないため、一意のものを自分で割り当てて管理しない限り。insertmapaddress
  • この例の作業は、すべてが一意のアドレスf40を持つことです。f42それらはすべて追加時に存在するため、アドレスが重複することはありません。しかし、私が動的に作成f42したとしたら、それを追加し、delete別のfunc4オブジェクトを作成してから追加します。新しいfunc4オブジェクトが古いf42のメモリ位置を使用した可能性があるため、アドレスが一意ではなくなり、新しい挿入によって新しいオブジェクトが置き換えられます。

ただし、コールバックごとにアドレスよりも優れた一意のキーを考え出すことができると思います。

于 2012-10-27T01:40:01.860 に答える