C++에서 이벤트 메커니즘 의 간결 한 실현 및 포기 해 야 할 특성

이벤트 모델 은 광범 위 하 게 사용 되 는 좋 은 것 이지 만 C+표준 라 이브 러 리 에는 이미 만들어 진 것 이 없고 다른 실현 은 복잡 하거나 우아 하지 않다.예 를 들 어 매크로 를 사용 해 야 한다.이제 VC 11 은 XP 에서 사용 할 수 있 습 니 다.C+11 이 제공 하 는 선진 시설 을 시원 하 게 들 고 가 벼 운 실현 을 하 세 요.간결 한 목적 을 달성 하기 위해 일부 특성 을 포기 해 야 합 니 다.1.함수 가 이미 연결 되 었 는 지 판단 하 는 것 은 지원 되 지 않 습 니 다.조건 반전 등 이벤트 고급 특성(예 를 들 어 모든 처리 결과 의 최대 최소 값 을 되 돌려 줍 니 다.지 정 된 매개 변수 와 일치 하 는 이벤트 처리 함수 만 리 셋 합 니 다)4.이벤트 매개 변 수 는 이론 적 으로 무한 하고 실제 적 으로 유한 합 니 다.보통 0~10 개의 매개 변수(VC 11 은 길 어 지 는 템 플 릿 매개 변 수 를 지원 하지 않 습 니 다.GCC 가 있 습 니 다.그러나 템 플 릿 매개 변수 와 편 특 화 를 통 해 모 의 할 수 있 기 때문에 이론 적 으로 무제 한)5.스 레 드 안전 이 아 닌 주:3,5 두 가 지 는 전략 모델 을 도입 하여 유연 한 지원 을 제공 할 수 있다.표준 라 이브 러 리 와 Loki 가 한 것 처럼 완전한 사건 체 제 를 실현 할 수 있다.가장 간단 한 실현

 
#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 는 리 턴 함 수 를 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<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; 
} 

여기 작은 단점 이 있 지만 모방 함수 에 대해 지침 이나 인용 을 사용 하려 면 직접 연결 할 수 없습니다.이렇게 해 야 합 니 다.

e.addHandler(ref(f2)); 
e.addHandler(ref(*pf2)); // pf2   f2                    ，       

문자,하물며 Lambda 표현 식 이 있 는 상황 에서?개선 1.bind 를 좋아 하지 않 는 사람 이 있 습 니 다.사용 하기 귀 찮 습 니 다.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++; 
} 

2.확장 매개 변수 갯 수 입 니 다.템 플 릿 인자 가 길 어 지지 않 았 습 니 다.변경 하 십시오.

 
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); 
} 
}; 

현재 0~2 개의 인 자 를 지원 합 니 다.각 템 플 릿 에 공공 코드 가 있 음 을 알 고 추출 하여 기본 클래스 에 넣 은 다음 에 해 야 할 일 은 텍스트 생 성 기 를 열 어 전체 코드코드 다운로드

 
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 

테스트 코드 의 각종 바 인 딩 방식

 
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; 
//      
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; 
} 

입 니 다.