当前位置:  编程技术>c/c++/嵌入式

C++中事件机制的简洁实现及需要放弃的特性

    来源: 互联网  发布时间：2014-10-12

    本文导语:  事件模型是被广泛使用的好东西，但是C++标准库里没有现成的，其他实现又复杂或者不优雅，比如需要使用宏。现在VC11可以用在XP下了，那么就痛快的拿起C++11提供的先进设施组合出一个轻便的实现吧。为了达到简洁的目的，...

事件模型是被广泛使用的好东西，但是C++标准库里没有现成的，其他实现又复杂或者不优雅，比如需要使用宏。现在VC11可以用在XP下了，那么就痛快的拿起C++11提供的先进设施组合出一个轻便的实现吧。

为了达到简洁的目的，需要放弃一些特性：
1、不支持判断函数是否已经绑定过（因为std::function不提供比较方法，自己实现function的话代码又变多了）
2、需要使用者接收返回的回调函数标识来移除事件绑定（原因同上）
3、事件没有返回值，不支持回调函数优先级、条件回调等事件高级特性（比如返回所有处理结果中的最大最小值；只回调与指定参数匹配的事件处理函数）
4、事件参数理论上无限，实际上有限，一般支持0~10个参数（VC11还没有支持变长模板参数，GCC有了。不过可以通过缺省模板参数和偏特化来模拟，所以理论上无限制）
5、不是线程安全的

注：3、5两条可以通过引入策略模式来提供灵活支持，就像标准库和Loki做的那样，实现一个完整的事件机制。

最简单的实现
代码如下:

#include
#include
using namespace std;
template
class Event
{
typedef void HandlerT(Param1, Param2);
int m_handlerId;
public:
Event() : m_handlerId(0) {}
template int addHandler(FuncT func)
{
m_handlers.emplace(m_handlerId, forward(func));
return m_handlerId++;
}
void removeHandler(int handlerId)
{
m_handlers.erase(handlerId);
}
void operator ()(Param1 arg1, Param2 arg2)
{
for ( const auto& i : m_handlers )
i.second(arg1, arg2);
}
private:
map m_handlers;
};

addHandler把回调函数完美转发给std::function，让标准库来搞定各种重载，然后返回一个标识符用来注销绑定。试一下，工作的不错：
代码如下:

void f1(int, int)
{
puts("f1()");
}
struct F2
{
void f(int, int)
{
puts("f2()");
}
void operator ()(int, int)
{
puts("f3()");
}
};
int _tmain(int argc, _TCHAR* argv[])
{
Event e;
int id = e.addHandler(f1);
e.removeHandler(id);
using namespace std::placeholders;
F2 f2;
e.addHandler(bind(&F2::f, f2, _1, _2));
e.addHandler(bind(f2, _1, _2));
e.addHandler([](int, int) {
puts("f4()");
});
e(1, 2);
return 0;
}

虽然这里有一个小小的缺点，对于仿函数，如果想使用它的指针或引用是不可以直接绑定的，需要这样做：
代码如下:

e.addHandler(ref(f2));
e.addHandler(ref(*pf2)); // pf2是指向f2的指针 但是使用仿函数对象指针的情形不多，也不差多敲几个

字符，何况在有Lambda表达式的情况下呢？
改进
1、有人不喜欢bind，用起来麻烦，放到addhandler里面去：
代码如下:

template int addHandler(ObjT obj, FuncT func)
{
using namespace std::placeholders;
m_handlers.emplace(m_handlerId, std::bind(func, std::forward(obj), _1, _2));
return m_handlerId++;
}

2、扩展参数个数。没有变长模板参数，变通一下：
代码如下:

struct NullType {};
template
class Event
{
public:
template int addHandler(ObjT obj, FuncT func)
{
using namespace std::placeholders;
m_handlers.emplace(m_handlerId, std::bind(func, std::forward(obj), _1, _2));
return m_handlerId++;
}
void operator ()(P1 arg1, P2 arg2)
{
for ( const auto& i : m_handlers )
i.second(arg1, arg2);
}
};
template
class Event
{
public:
template int addHandler(ObjT obj, FuncT func)
{
using namespace std::placeholders;
m_handlers.emplace(m_handlerId, std::bind(func, std::forward(obj)));
return m_handlerId++;
}
void operator ()()
{
for ( const auto& i : m_handlers )
i.second();
}
};
template
class Event
{
public:
template int addHandler(ObjT obj, FuncT func)
{
using namespace std::placeholders;
m_handlers.emplace(m_handlerId, std::bind(func, std::forward(obj), _1));
return m_handlerId++;
}
void operator ()(P1 arg1)
{
for ( const auto& i : m_handlers )
i.second(arg1);
}
};

现在支持0~2个参数了。注意到各个模板里有公共代码，提取出来放进基类，然后要做的就是打开文本生成器了
完整代码
代码下载
代码如下:

View Code
#pragma once
#include
#include
namespace Utility
{
namespace Private
{
struct NullType {};
template
class EventBase
{
public:
EventBase() : m_handlerId(0) {}
template int addHandler(FuncT func)
{
m_handlers.emplace(m_handlerId, std::forward(func));
return m_handlerId++;
}
void removeHandler(int handlerId)
{
m_handlers.erase(handlerId);
}
protected:
int m_handlerId;
std::map m_handlers;
};
}
template
class Event
: public Private::EventBase
{
public:
using Private::EventBase::addHandler;
template int addHandler(ObjT obj, FuncT func)
{
using namespace std::placeholders;
m_handlers.emplace(m_handlerId, std::bind(func, std::forward(obj), _1, _2, _3, _4, _5, _6, _7, _8, _9, _10));
return m_handlerId++;
}
void operator ()(P1 arg1, P2 arg2, P3 arg3, P4 arg4, P5 arg5, P6 arg6, P7 arg7, P8 arg8, P9 arg9, P10 arg10)
{
for ( const auto& i : m_handlers )
i.second(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
}
};
template
class Event
: public Private::EventBase
{
public:
using Private::EventBase::addHandler;
template int addHandler(ObjT const obj, FuncT func)
{
m_handlers.emplace(m_handlerId, std::bind(func, obj));
return m_handlerId++;
}
void operator ()()
{
for ( const auto& i : m_handlers )
i.second();
}
};
template
class Event
: public Private::EventBase
{
public:
using Private::EventBase::addHandler;
template int addHandler(ObjT obj, FuncT func)
{
using namespace std::placeholders;
m_handlers.emplace(m_handlerId, std::bind(func, std::forward(obj), _1));
return m_handlerId++;
}
void operator ()(P1 arg1)
{
for ( const auto& i : m_handlers )
i.second(arg1);
}
};
template
class Event
: public Private::EventBase
{
public:
using Private::EventBase::addHandler;
template int addHandler(ObjT obj, FuncT func)
{
using namespace std::placeholders;
m_handlers.emplace(m_handlerId, std::bind(func, std::forward(obj), _1, _2));
return m_handlerId++;
}
void operator ()(P1 arg1, P2 arg2)
{
for ( const auto& i : m_handlers )
i.second(arg1, arg2);
}
};
template
class Event
: public Private::EventBase
{
public:
using Private::EventBase::addHandler;
template int addHandler(ObjT obj, FuncT func)
{
using namespace std::placeholders;
m_handlers.emplace(m_handlerId, std::bind(func, std::forward(obj), _1, _2, _3));
return m_handlerId++;
}
void operator ()(P1 arg1, P2 arg2, P3 arg3)
{
for ( const auto& i : m_handlers )
i.second(arg1, arg2, arg3);
}
};
template
class Event
: public Private::EventBase
{
public:
using Private::EventBase::addHandler;
template int addHandler(ObjT obj, FuncT func)
{
using namespace std::placeholders;
m_handlers.emplace(m_handlerId, std::bind(func, std::forward(obj), _1, _2, _3, _4));
return m_handlerId++;
}
void operator ()(P1 arg1, P2 arg2, P3 arg3, P4 arg4)
{
for ( const auto& i : m_handlers )
i.second(arg1, arg2, arg3, arg4);
}
};
template
class Event
: public Private::EventBase
{
public:
using Private::EventBase::addHandler;
template int addHandler(ObjT obj, FuncT func)
{
using namespace std::placeholders;
m_handlers.emplace(m_handlerId, std::bind(func, std::forward(obj), _1, _2, _3, _4, _5));
return m_handlerId++;
}
void operator ()(P1 arg1, P2 arg2, P3 arg3, P4 arg4, P5 arg5)
{
for ( const auto& i : m_handlers )
i.second(arg1, arg2, arg3, arg4, arg5);
}
};
template
class Event
: public Private::EventBase
{
public:
using Private::EventBase::addHandler;
template int addHandler(ObjT obj, FuncT func)
{
using namespace std::placeholders;
m_handlers.emplace(m_handlerId, std::bind(func, std::forward(obj), _1, _2, _3, _4, _5, _6));
return m_handlerId++;
}
void operator ()(P1 arg1, P2 arg2, P3 arg3, P4 arg4, P5 arg5, P6 arg6)
{
for ( const auto& i : m_handlers )
i.second(arg1, arg2, arg3, arg4, arg5, arg6);
}
};
template
class Event
: public Private::EventBase
{
public:
using Private::EventBase::addHandler;
template int addHandler(ObjT obj, FuncT func)
{
using namespace std::placeholders;
m_handlers.emplace(m_handlerId, std::bind(func, std::forward(obj), _1, _2, _3, _4, _5, _6, _7));
return m_handlerId++;
}
void operator ()(P1 arg1, P2 arg2, P3 arg3, P4 arg4, P5 arg5, P6 arg6, P7 arg7)
{
for ( const auto& i : m_handlers )
i.second(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}
};
template
class Event
: public Private::EventBase
{
public:
using Private::EventBase::addHandler;
template int addHandler(ObjT obj, FuncT func)
{
using namespace std::placeholders;
m_handlers.emplace(m_handlerId, std::bind(func, std::forward(obj), _1, _2, _3, _4, _5, _6, _7, _8));
return m_handlerId++;
}
void operator ()(P1 arg1, P2 arg2, P3 arg3, P4 arg4, P5 arg5, P6 arg6, P7 arg7, P8 arg8)
{
for ( const auto& i : m_handlers )
i.second(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}
};
template
class Event
: public Private::EventBase
{
public:
using Private::EventBase::addHandler;
template int addHandler(ObjT obj, FuncT func)
{
using namespace std::placeholders;
m_handlers.emplace(m_handlerId, std::bind(func, std::forward(obj), _1, _2, _3, _4, _5, _6, _7, _8, _9));
return m_handlerId++;
}
void operator ()(P1 arg1, P2 arg2, P3 arg3, P4 arg4, P5 arg5, P6 arg6, P7 arg7, P8 arg8, P9 arg9)
{
for ( const auto& i : m_handlers )
i.second(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}
};
} // namespace Utility

测试代码
各种绑定方式
代码如下:

View Code
#include "Event.h"
using namespace std;
void f1(int, int)
{
puts("f1()");
}
struct F2
{
F2() { puts("F2 construct"); }
F2(const F2 &) { puts("F2 copy"); }
F2(F2 &&) { puts("F2 move"); }
F2& operator=(const F2 &) { puts("F2 copy assign"); return *this; }
F2& operator=(F2 &&) { puts("F2 move assign"); return *this; }
void f(int, int)
{
puts("f2()");
}
void fc(int, int) const
{
puts("f2c()");
}
};
struct F3
{
F3() { puts("F3 construct"); }
F3(const F3 &) { puts("F3 copy"); }
F3(F3 &&) { puts("F3 move"); }
F3& operator=(const F3 &) { puts("F3 copy assign"); return *this; }
F3& operator=(F3 &&) { puts("F3 move assign"); return *this; }
void operator ()(int, int) const
{
puts("f3()");
}
};
int _tmain(int argc, _TCHAR* argv[])
{
Utility::Event e;
// 一般函数
e.addHandler(f1);
int id = e.addHandler(&f1);
e.removeHandler(id); // 移除事件处理函数
// 成员函数
using namespace std::placeholders;
F2 f2;
const F2 *pf2 = &f2;
e.addHandler(bind(&F2::f, &f2, _1, _2)); // std::bind
e.addHandler(&f2, &F2::f);
e.addHandler(pf2, &F2::fc); // 常量指针
puts("----addHandler(f2, &F2::f)----");
e.addHandler(f2, &F2::f); // 对象拷贝构造
puts("----addHandler(F2(), &F2::f)----");
e.addHandler(F2(), &F2::f); // 对象转移构造
puts("--------");
// 仿函数
F3 f3;
const F3 *pf3 = &f3;
puts("----addHandler(f3)----");
e.addHandler(f3); // 对象拷贝构造
puts("----addHandler(F3())----");
e.addHandler(F3()); // 对象转移构造
puts("--------");
e.addHandler(ref(f3)); // 引用仿函数对象
e.addHandler(ref(*pf3)); // 引用仿函数常量对象
puts("--------");
// Lambda表达式
e.addHandler([](int, int) {
puts("f4()");
});
// 激发事件
e(1, 2);
return 0;
}

    
 
 
 
本站(WWW.)旨在分享和传播互联网科技相关的资讯和技术，将尽最大努力为读者提供更好的信息聚合和浏览方式。
本站(WWW.)站内文章除注明原创外，均为转载、整理或搜集自网络。欢迎任何形式的转载，转载请注明出处。












  • 相关文章推荐
  • 如何理解消息机制和事件机制
  • 如何在linux下实现event事件机制
  • java的事件处理机制如何运用？
  • 请关注一下java的事件机制！
  • Windows下的消息时间事件机制在Unix下如何实现?
  • jQuery新的事件绑定机制on()示例应用
  • jquery新的绑定事件机制on方法的使用方法
  • 我想问一下java的事件驱动机制是如何实现的，如何实现自定义的事件驱动？不够再加100！
  • 学习JAVA响应事件的机制——————200分言谢————————
  • window.onload事件覆盖掉body onload事件(window.onload和html body onload事件冲突)解决办法
  • JQuery文本改变触发事件如聚焦事件、失焦事件
  • Python 3 Tkinter教程之事件Event绑定处理代码实例
  • 我的一个jComboBox下拉组件，在加入itemStateChanged()监听事件后速度就非常慢，我在事件响应部分没有加任何代码也是慢？去掉监听事件后就一切正常，为何？
  • jQuery新的事件绑定机制on()示例应用 iis7站长之家
  • 事件能传递吗，就是子类触发了一个鼠标事件，能不能也将这个鼠标事件发给父类
  • jquery阻止后续事件只执行第一个事件
  • 在JBuilder中窗体的什么事件与Delphi中的窗体的CloseQuery事件相同？
  • swing事件里怎么没有鼠标右键产生的事件？
  • 使用epoll lt或者et 每次wait到一个事件处理完后是否需要重新投递事件呢?
  • jquery button默认enter事件(回车事件)
  • 我用画布（Canvas类）接受MouseEvent事件，但我又想这个事件的getX（）方法返回的坐标是以窗口的原点为原点，该怎么办？
  • 新手问题：linux的安全事件和系统事件有没有什么文件可查，或者命令查？知道的都来答啊～～～～～～～～
  • 关于java的事件问题，如何在程序中使一个button被click，从而引发这个button的事件处理代码？？？？
  • JTextArea 怎么没有textChanged事件？怎样实现这个事件？（一定有分）
  • Linux下不能播放音乐，我用的是Red Hat 9，启动事件音效时有事件声音，但是在播放MP3或视频时却无声音
  • asp.net Textbox控件注册回车事件与触发按钮提交事件的实现方法
  • jQuery中事件对象e的事件冒泡用法示例介绍
  • java抓取鼠标事件和鼠标滚轮事件示例
  • C# DoubleClick与MouseDoubleClick区别，双击事件引发顺序
  • 如何响应JTREE中的节点点击事件？？


    • 站内导航:


    特别声明:169IT网站部分信息来自互联网,如果侵犯您的权利,请及时告知,本站将立即删除！

    ©2012-2021,,E-mail:www_#163.com(请将#改为@)

    浙ICP备11055608号-3