Главная » C++ » Хранение объектов boost :: function в контейнере

Хранение объектов boost :: function в контейнере

У меня есть вектор KeyCallbacks:

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 для механизмов обратного вызова, но это, по-видимому, довольно медленно, и я ожидаю, что обратные вызовы будут срабатывать, возможно, несколько раз за кадр.)

4

Решение

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

Обертки объекта функции можно сравнить через == или! = С любым объектом функции, который может быть сохранен в оболочке.

Итак, одним из решений является определение специального типа для параметра UnregisterCallback (который также поддерживает стирание типов). Это основано на том факте, что вы можете сравнить boost :: function с функтором / функцией — в результате у вас все еще будет вектор boost :: function, новый тип требуется только для мест, где вам нужно выполнить сравнение, например, UnregisterCallback:

LIVE DEMO

#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
________________

Pros:

  • Мы по-прежнему используем boost :: function для регистрации и сохранения в векторе
  • Объект Functor должен иметь определенное сравнение только тогда, когда необходимо передать его в unregister_callback
  • Это может быть легко обобщено — просто добавьте один параметр шаблона вместо использования определения типа KeyCallback. Таким образом, может быть легко использован в других местах, для других типов обратных вызовов.

Cons:

  • Если у пользователя уже есть обратный вызов, добавленный в boost :: function — его нельзя использовать с unregister_callback, потому что он требует чего-то, что можно сравнить с boost :: function (например, указатель на функцию или функтор с определенным сравнением)

Другой подход заключается в реализации пользовательского решения, похожего на boost :: function, которое принимает сопоставимые только обратные вызовы.

LIVE DEMO

#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

Pros:

  • Мы используем тот же тип в регистрации / отмене регистрации обратного вызова. Пользователь может хранить свои функции и функторы снаружи, обернутые в KeyCallback — и передать KeyCallback нашему unregister_callback.
  • Нет никакой зависимости от boost :: function

Cons:

  • Объект Functor должен иметь определенное сравнение, даже если он не используется с unregister_callback
  • Если у пользователя уже есть обратный вызов, добавленный в boost :: function — он не может быть преобразован в наш KeyCallback, поскольку требует определенного сравнения.
  • Если вам нужна подобная функциональность в других местах, с различными типами обратных вызовов — тогда наши классы boost :: function-like должны быть улучшены (принимая разные и несколько параметров, и т. Д., И т. Д.), Или мы можем извлечь и модифицировать сам boost :: funciton.

Здесь мы создаем новый класс, который унаследован от std / boost :: function

LIVE DEMO

#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
________________

Pros:

  • Мы можем использовать тот же тип в регистрации / отмене регистрации обратного вызова. Пользователь может хранить свои функции и функторы снаружи, обернутые в KeyCallback — и передать KeyCallback нашему unregister_callback. Более того, в этой версии мы можем использовать обычный boost :: function для параметра функции register.
  • Мы все еще можем использовать boost :: function для регистрации и сохранения в векторе
  • Когда мы используем boost :: function для регистрации, объект functor должен был определять сравнение только тогда, когда необходимо передать его в unregister_callback.
  • Он обобщен, поэтому может быть легко использован в других местах, для других типов обратных вызовов.
  • Эта версия основана на простом указателе функции вместо выделения + абстрактный класс (vptr). Так что у него меньше нареканий, им легче управлять.

Cons:

  • Если у пользователя уже есть обратный вызов, добавленный в boost :: function — его нельзя использовать с unregister_callback, потому что он требует чего-то, что можно сравнить с boost :: function (например, указатель на функцию или функтор с определенным сравнением)

РЕДАКТИРОВАТЬ:

Круто, я сейчас пробую # 1, но я не совсем понимаю, почему это работает, когда мы применяем наши собственные == операторы?

повышение :: функции можно сравнить против функций или функторов, но не против другого 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.

8

Другие решения

Я не уверен, правильно ли я понимаю вашу проблему. Я понимаю, что у вас есть вектор KeyCallback функциональные объекты. Каждый из них имеет одинаковую подпись void (const KeyEvent &), Обычно вы звоните каждому из них для определенного KeyEvent объект. И вы хотите удалить один или несколько из этих объектов из вектора.

Если я прав, то проблема в том, как определить KeyCallback объект? Вот одно решение: использовать указатель.

Если KeyCallback Объект является указателем на функцию, тогда никакие две функции не могут иметь одинаковый адрес. Если это объект класса с 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, …,f42 должен быть создан за пределами вставки. Вы не можете использовать insert вставить функциональный объект в map на лету, вроде бы,
    callback.insert (std :: make_pair (address, func4 (5)));
    если вы не назначаете и не управляете уникальным address себя, так как вы не можете взять адрес временного объекта.
  • Этот пример работы заключается в том, что все f40 в f42 иметь уникальный адрес. Все они существуют, когда мы добавляем их, поэтому они не могут иметь дублирующийся адрес. Но если сказать, что я динамически создал f42, добавь это, delete это, создать другой func4 объект, затем добавьте его. Возможно, что новый func4 объект использовал старый f42в памяти, и, следовательно, адрес больше не является уникальным, и новая вставка заменит новую.

Однако я думаю, что вы можете придумать лучший уникальный ключ для каждого обратного вызова, чем их адреса.

0

Источник
По вопросам рекламы [email protected]
Web-Answers © 2024 Наверх