快捷導(dǎo)航

C++中事件機(jī)制的簡(jiǎn)潔實(shí)現(xiàn)及需要放棄的特性

更新時(shí)間：2013年02月01日 14:54:38 作者：

事件模型是被廣泛使用的好東西，但是C++標(biāo)準(zhǔn)庫(kù)里沒(méi)有現(xiàn)成的,現(xiàn)在VC11可以用在XP下了，那么就痛快的拿起C++11提供的先進(jìn)設(shè)施組合出一個(gè)輕便的實(shí)現(xiàn)吧感興趣的朋友可以了解下，或許對(duì)你有所幫助

事件模型是被廣泛使用的好東西，但是C++標(biāo)準(zhǔn)庫(kù)里沒(méi)有現(xiàn)成的，其他實(shí)現(xiàn)又復(fù)雜或者不優(yōu)雅，比如需要使用宏。現(xiàn)在VC11可以用在XP下了，那么就痛快的拿起C++11提供的先進(jìn)設(shè)施組合出一個(gè)輕便的實(shí)現(xiàn)吧。

為了達(dá)到簡(jiǎn)潔的目的，需要放棄一些特性：
1、不支持判斷函數(shù)是否已經(jīng)綁定過(guò)（因?yàn)閟td::function不提供比較方法，自己實(shí)現(xiàn)function的話代碼又變多了）
2、需要使用者接收返回的回調(diào)函數(shù)標(biāo)識(shí)來(lái)移除事件綁定（原因同上）
3、事件沒(méi)有返回值，不支持回調(diào)函數(shù)優(yōu)先級(jí)、條件回調(diào)等事件高級(jí)特性（比如返回所有處理結(jié)果中的最大最小值；只回調(diào)與指定參數(shù)匹配的事件處理函數(shù)）
4、事件參數(shù)理論上無(wú)限，實(shí)際上有限，一般支持0~10個(gè)參數(shù)（VC11還沒(méi)有支持變長(zhǎng)模板參數(shù)，GCC有了。不過(guò)可以通過(guò)缺省模板參數(shù)和偏特化來(lái)模擬，所以理論上無(wú)限制）
5、不是線程安全的

注：3、5兩條可以通過(guò)引入策略模式來(lái)提供靈活支持，就像標(biāo)準(zhǔn)庫(kù)和Loki做的那樣，實(shí)現(xiàn)一個(gè)完整的事件機(jī)制。

最簡(jiǎn)單的實(shí)現(xiàn)

復(fù)制代碼代碼如下:

 
#include <map> 
#include <functional> 
using namespace std; 
template<class Param1, class Param2> 
class Event 
{ 
typedef void HandlerT(Param1, Param2); 
int m_handlerId; 
public: 
Event() : m_handlerId(0) {} 
template<class FuncT> int addHandler(FuncT func) 
{ 
m_handlers.emplace(m_handlerId, forward<FuncT>(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<int, function<HandlerT>> m_handlers; 
}; 

addHandler把回調(diào)函數(shù)完美轉(zhuǎn)發(fā)給std::function，讓標(biāo)準(zhǔn)庫(kù)來(lái)搞定各種重載，然后返回一個(gè)標(biāo)識(shí)符用來(lái)注銷綁定。試一下，工作的不錯(cuò)：

復(fù)制代碼代碼如下:

 
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<int, int> 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; 
} 

雖然這里有一個(gè)小小的缺點(diǎn)，對(duì)于仿函數(shù)，如果想使用它的指針或引用是不可以直接綁定的，需要這樣做：

復(fù)制代碼代碼如下:

e.addHandler(ref(f2)); 
e.addHandler(ref(*pf2)); // pf2是指向f2的指針 但是使用仿函數(shù)對(duì)象指針的情形不多，也不差多敲幾個(gè)

字符，何況在有Lambda表達(dá)式的情況下呢？
改進(jìn)
1、有人不喜歡bind，用起來(lái)麻煩，放到addhandler里面去：

復(fù)制代碼代碼如下:

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

2、擴(kuò)展參數(shù)個(gè)數(shù)。沒(méi)有變長(zhǎng)模板參數(shù)，變通一下：

復(fù)制代碼代碼如下:

 
struct NullType {}; 
template<class P1 = Private::NullType, class P2 = Private::NullType> 
class Event 
{ 
public: 
template<class ObjT, class FuncT> int addHandler(ObjT obj, FuncT func) 
{ 
using namespace std::placeholders; 
m_handlers.emplace(m_handlerId, std::bind(func, std::forward<ObjT>(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<Private::NullType, Private::NullType> 
{ 
public: 
template<class ObjT, class FuncT> int addHandler(ObjT obj, FuncT func) 
{ 
using namespace std::placeholders; 
m_handlers.emplace(m_handlerId, std::bind(func, std::forward<ObjT>(obj))); 
return m_handlerId++; 
} 
void operator ()() 
{ 
for ( const auto& i : m_handlers ) 
i.second(); 
} 
}; 
template<class P1> 
class Event<P1, Private::NullType> 
{ 
public: 
template<class ObjT, class FuncT> int addHandler(ObjT obj, FuncT func) 
{ 
using namespace std::placeholders; 
m_handlers.emplace(m_handlerId, std::bind(func, std::forward<ObjT>(obj), _1)); 
return m_handlerId++; 
} 
void operator ()(P1 arg1) 
{ 
for ( const auto& i : m_handlers ) 
i.second(arg1); 
} 
}; 

現(xiàn)在支持0~2個(gè)參數(shù)了。注意到各個(gè)模板里有公共代碼，提取出來(lái)放進(jìn)基類，然后要做的就是打開(kāi)文本生成器了
完整代碼
代碼下載

復(fù)制代碼代碼如下:

 
View Code 
#pragma once 
#include <map> 
#include <functional> 
namespace Utility 
{ 
namespace Private 
{ 
struct NullType {}; 
template<class HandlerT> 
class EventBase 
{ 
public: 
EventBase() : m_handlerId(0) {} 
template<class FuncT> int addHandler(FuncT func) 
{ 
m_handlers.emplace(m_handlerId, std::forward<FuncT>(func)); 
return m_handlerId++; 
} 
void removeHandler(int handlerId) 
{ 
m_handlers.erase(handlerId); 
} 
protected: 
int m_handlerId; 
std::map<int, std::function<HandlerT>> m_handlers; 
}; 
} 
template<class P1 = Private::NullType, class P2 = Private::NullType, class P3 = Private::NullType, class P4 = Private::NullType, class P5 = Private::NullType, class P6 = Private::NullType, class P7 = Private::NullType, class P8 = Private::NullType, class P9 = Private::NullType, class P10 = Private::NullType> 
class Event 
: public Private::EventBase<void (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)> 
{ 
public: 
using Private::EventBase<void (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)>::addHandler; 
template<class ObjT, class FuncT> int addHandler(ObjT obj, FuncT func) 
{ 
using namespace std::placeholders; 
m_handlers.emplace(m_handlerId, std::bind(func, std::forward<ObjT>(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<Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType> 
: public Private::EventBase<void ()> 
{ 
public: 
using Private::EventBase<void ()>::addHandler; 
template<class ObjT, class FuncT> 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 P1> 
class Event<P1, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType> 
: public Private::EventBase<void (P1)> 
{ 
public: 
using Private::EventBase<void (P1)>::addHandler; 
template<class ObjT, class FuncT> int addHandler(ObjT obj, FuncT func) 
{ 
using namespace std::placeholders; 
m_handlers.emplace(m_handlerId, std::bind(func, std::forward<ObjT>(obj), _1)); 
return m_handlerId++; 
} 
void operator ()(P1 arg1) 
{ 
for ( const auto& i : m_handlers ) 
i.second(arg1); 
} 
}; 
template<class P1, class P2> 
class Event<P1, P2, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType> 
: public Private::EventBase<void (P1, P2)> 
{ 
public: 
using Private::EventBase<void (P1, P2)>::addHandler; 
template<class ObjT, class FuncT> int addHandler(ObjT obj, FuncT func) 
{ 
using namespace std::placeholders; 
m_handlers.emplace(m_handlerId, std::bind(func, std::forward<ObjT>(obj), _1, _2)); 
return m_handlerId++; 
} 
void operator ()(P1 arg1, P2 arg2) 
{ 
for ( const auto& i : m_handlers ) 
i.second(arg1, arg2); 
} 
}; 
template<class P1, class P2, class P3> 
class Event<P1, P2, P3, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType> 
: public Private::EventBase<void (P1, P2, P3)> 
{ 
public: 
using Private::EventBase<void (P1, P2, P3)>::addHandler; 
template<class ObjT, class FuncT> int addHandler(ObjT obj, FuncT func) 
{ 
using namespace std::placeholders; 
m_handlers.emplace(m_handlerId, std::bind(func, std::forward<ObjT>(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 P1, class P2, class P3, class P4> 
class Event<P1, P2, P3, P4, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType> 
: public Private::EventBase<void (P1, P2, P3, P4)> 
{ 
public: 
using Private::EventBase<void (P1, P2, P3, P4)>::addHandler; 
template<class ObjT, class FuncT> int addHandler(ObjT obj, FuncT func) 
{ 
using namespace std::placeholders; 
m_handlers.emplace(m_handlerId, std::bind(func, std::forward<ObjT>(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 P1, class P2, class P3, class P4, class P5> 
class Event<P1, P2, P3, P4, P5, Private::NullType, Private::NullType, Private::NullType, Private::NullType, Private::NullType> 
: public Private::EventBase<void (P1, P2, P3, P4, P5)> 
{ 
public: 
using Private::EventBase<void (P1, P2, P3, P4, P5)>::addHandler; 
template<class ObjT, class FuncT> int addHandler(ObjT obj, FuncT func) 
{ 
using namespace std::placeholders; 
m_handlers.emplace(m_handlerId, std::bind(func, std::forward<ObjT>(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 P1, class P2, class P3, class P4, class P5, class P6> 
class Event<P1, P2, P3, P4, P5, P6, Private::NullType, Private::NullType, Private::NullType, Private::NullType> 
: public Private::EventBase<void (P1, P2, P3, P4, P5, P6)> 
{ 
public: 
using Private::EventBase<void (P1, P2, P3, P4, P5, P6)>::addHandler; 
template<class ObjT, class FuncT> int addHandler(ObjT obj, FuncT func) 
{ 
using namespace std::placeholders; 
m_handlers.emplace(m_handlerId, std::bind(func, std::forward<ObjT>(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 P1, class P2, class P3, class P4, class P5, class P6, class P7> 
class Event<P1, P2, P3, P4, P5, P6, P7, Private::NullType, Private::NullType, Private::NullType> 
: public Private::EventBase<void (P1, P2, P3, P4, P5, P6, P7)> 
{ 
public: 
using Private::EventBase<void (P1, P2, P3, P4, P5, P6, P7)>::addHandler; 
template<class ObjT, class FuncT> int addHandler(ObjT obj, FuncT func) 
{ 
using namespace std::placeholders; 
m_handlers.emplace(m_handlerId, std::bind(func, std::forward<ObjT>(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 P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8> 
class Event<P1, P2, P3, P4, P5, P6, P7, P8, Private::NullType, Private::NullType> 
: public Private::EventBase<void (P1, P2, P3, P4, P5, P6, P7, P8)> 
{ 
public: 
using Private::EventBase<void (P1, P2, P3, P4, P5, P6, P7, P8)>::addHandler; 
template<class ObjT, class FuncT> int addHandler(ObjT obj, FuncT func) 
{ 
using namespace std::placeholders; 
m_handlers.emplace(m_handlerId, std::bind(func, std::forward<ObjT>(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 P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9> 
class Event<P1, P2, P3, P4, P5, P6, P7, P8, P9, Private::NullType> 
: public Private::EventBase<void (P1, P2, P3, P4, P5, P6, P7, P8, P9)> 
{ 
public: 
using Private::EventBase<void (P1, P2, P3, P4, P5, P6, P7, P8, P9)>::addHandler; 
template<class ObjT, class FuncT> int addHandler(ObjT obj, FuncT func) 
{ 
using namespace std::placeholders; 
m_handlers.emplace(m_handlerId, std::bind(func, std::forward<ObjT>(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 

測(cè)試代碼
各種綁定方式

復(fù)制代碼代碼如下:

 
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<int, int> e; 
// 一般函數(shù) 
e.addHandler(f1); 
int id = e.addHandler(&f1); 
e.removeHandler(id); // 移除事件處理函數(shù) 
// 成員函數(shù) 
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); // 對(duì)象拷貝構(gòu)造 
puts("----addHandler(F2(), &F2::f)----"); 
e.addHandler(F2(), &F2::f); // 對(duì)象轉(zhuǎn)移構(gòu)造 
puts("--------"); 
// 仿函數(shù) 
F3 f3; 
const F3 *pf3 = &f3; 
puts("----addHandler(f3)----"); 
e.addHandler(f3); // 對(duì)象拷貝構(gòu)造 
puts("----addHandler(F3())----"); 
e.addHandler(F3()); // 對(duì)象轉(zhuǎn)移構(gòu)造 
puts("--------"); 
e.addHandler(ref(f3)); // 引用仿函數(shù)對(duì)象 
e.addHandler(ref(*pf3)); // 引用仿函數(shù)常量對(duì)象 
puts("--------"); 
// Lambda表達(dá)式 
e.addHandler([](int, int) { 
puts("f4()"); 
}); 
// 激發(fā)事件 
e(1, 2); 
return 0; 
} 