自己写的C++类型枚举量，可以使用类型识别取代模板，绑定枚举量和多组调用函数，在调用阶段只要指定某组函数就可以根据枚举量调用相应函数。
代码如下：
#ifndef __MYENUM_H__
#define __MYENUM_H__ namespace MyEnum {
#include <assert.h> //------------------------------------------------------ EnumFunction ------------------------------------------// /** 绑定序号和函数对象 */
template<int _ID, typename _FUNC>
class EnumFunction
{
public:
enum { id = _ID, };
typedef _FUNC func;
}; // end class EnumFunction template<int _ID>
class _Nil { public: enum { id = _ID, };}; /** 空函数用作占位 */
class _NilFunc
{
public:
/** 无参数版本 */
void operator()(){};
/** 带一个参数版本 */
template<typename _Pr0> void operator() (_Pr0){};
/** 带一个参数版本 */
template<typename _Pr0, typename _Pr1> void operator() (_Pr0, _Pr1){};
/** 带两个参数版本 */
template<typename _Pr0, typename _Pr1, typename _Pr2> void operator() (_Pr0, _Pr1, _Pr2){};
/** 带三个参数版本 */
template<typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3> void operator() (_Pr0, _Pr1, _Pr2, _Pr3){};
/** 带四个参数版本 */
template<typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4>
void operator() (_Pr0, _Pr1, _Pr2, _Pr3, _Pr4){};
/** 带五个参数版本 */
template<typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4, typename _Pr5>
void operator() (_Pr0, _Pr1, _Pr2, _Pr3, _Pr4, _Pr5){};
/** 带六个参数版本 */
template<typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4, typename _Pr5, typename _Pr6>
void operator() (_Pr0, _Pr1, _Pr2, _Pr3, _Pr4, _Pr5, _Pr6){};
/** 带七个参数版本 */
template<typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4, typename _Pr5, typename _Pr6,
typename _Pr7>
void operator() (_Pr0, _Pr1, _Pr2, _Pr3, _Pr4, _Pr5, _Pr6, _Pr7){};
/** 带八个参数版本 */
template<typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4, typename _Pr5, typename _Pr6,
typename _Pr7, typename _Pr8>
void operator() (_Pr0, _Pr1, _Pr2, _Pr3, _Pr4, _Pr5, _Pr6, _Pr7, _Pr8){};
/** 带九个参数版本 */
template<typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4, typename _Pr5, typename _Pr6,
typename _Pr7, typename _Pr8, typename _Pr9>
void operator() (_Pr0, _Pr1, _Pr2, _Pr3, _Pr4, _Pr5, _Pr6, _Pr7, _Pr8, _Pr9){};
}; /** 用于适配EnumFunction */
template<typename _EnumFunc>
class _NormalFunc
{
public:
/** 无参数版本 */
void operator()(){ _EnumFunc::func()(); };
/** 带一个参数版本 */
template<typename _Pr0> void operator()(_Pr0 pr0){ _EnumFunc::func()(pr0); };
/** 带一个参数版本 */
template<typename _Pr0, typename _Pr1> void operator()(_Pr0 pr0, _Pr1 pr1){ _EnumFunc::func()(pr0, pr1); };
/** 带两个参数版本 */
template<typename _Pr0, typename _Pr1, typename _Pr2> void operator()(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2){ _EnumFunc::func()(pr0, pr1, pr2); };
/** 带三个参数版本 */
template<typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3>
void operator()(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3){ _EnumFunc::func()(pr0, pr1, pr2, pr3); };
/** 带四个参数版本 */
template<typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4>
void operator()(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4){ _EnumFunc::func()(pr0, pr1, pr2, pr3, pr4); };
/** 带五个参数版本 */
template<typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4, typename _Pr5>
void operator()(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4, _Pr5 pr5){ _EnumFunc::func()(pr0, pr1, pr2, pr3, pr4, pr5); };
/** 带六个参数版本 */
template<typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4, typename _Pr5, typename _Pr6>
void operator()(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4, _Pr5 pr5, _Pr6 pr6){ _EnumFunc::func()(pr0, pr1, pr2, pr3, pr4, pr5, pr6); };
/** 带七个参数版本 */
template<typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4, typename _Pr5, typename _Pr6,
typename _Pr7>
void operator()(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4, _Pr5 pr5, _Pr6 pr6, _Pr7 pr7){
_EnumFunc::func()(pr0, pr1, pr2, pr3, pr4, pr5, pr6, pr7); };
/** 带八个参数版本 */
template<typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4, typename _Pr5, typename _Pr6,
typename _Pr7, typename _Pr8>
void operator()(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4, _Pr5 pr5, _Pr6 pr6, _Pr7 pr7, _Pr8 pr8){
_EnumFunc::func()(pr0, pr1, pr2, pr3, pr4, pr5, pr6, pr7, pr8); };
/** 带九个参数版本 */
template<typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4, typename _Pr5, typename _Pr6,
typename _Pr7, typename _Pr8, typename _Pr9>
void operator()(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4, _Pr5 pr5, _Pr6 pr6, _Pr7 pr7, _Pr8 pr8, _Pr9 pr9){
_EnumFunc::func()(pr0, pr1, pr2, pr3, pr4, pr5, pr6, pr7, pr8, pr9); };
}; //-------------------------------------------------------- EnumItem ---------------------------------------------// #define _DEFAULT_NIL_FUNC(num) typename _Ty##num = _Nil<INT_MIN + num>
/** 枚举值，最多十个绑定函数 */
template<_DEFAULT_NIL_FUNC(), _DEFAULT_NIL_FUNC(), _DEFAULT_NIL_FUNC(), _DEFAULT_NIL_FUNC(),
_DEFAULT_NIL_FUNC(), _DEFAULT_NIL_FUNC(), _DEFAULT_NIL_FUNC(), _DEFAULT_NIL_FUNC(),
_DEFAULT_NIL_FUNC(), _DEFAULT_NIL_FUNC()>
class EnumItem
{
public:
template<int _ID> class Invoke {};
template<>
class Invoke<_Ty0::id> : public _NormalFunc<_Ty0> {};
template<>
class Invoke<_Ty1::id> : public _NormalFunc<_Ty1> {};
template<>
class Invoke<_Ty2::id> : public _NormalFunc<_Ty2> {};
template<>
class Invoke<_Ty3::id> : public _NormalFunc<_Ty3> {};
template<>
class Invoke<_Ty4::id> : public _NormalFunc<_Ty4> {};
template<>
class Invoke<_Ty5::id> : public _NormalFunc<_Ty5> {};
template<>
class Invoke<_Ty6::id> : public _NormalFunc<_Ty6> {};
template<>
class Invoke<_Ty7::id> : public _NormalFunc<_Ty7> {};
template<>
class Invoke<_Ty8::id> : public _NormalFunc<_Ty8> {};
template<>
class Invoke<_Ty9::id> : public _NormalFunc<_Ty9> {}; static int enumID;
}; int _Count() { static int _count = ; return ++ _count; } template<typename _Ty0, typename _Ty1, typename _Ty2, typename _Ty3,
typename _Ty4, typename _Ty5, typename _Ty6, typename _Ty7,
typename _Ty8, typename _Ty9>
int EnumItem<_Ty0, _Ty1, _Ty2, _Ty3, _Ty4, _Ty5, _Ty6, _Ty7, _Ty8, _Ty9>::enumID = _Count(); //--------------------------------------------------- Enum ---------------------------------------------//
template<int _ID> class _NilEnumItem
{
public:
template<int id>
class Invoke : public _NilFunc {}; static const int enumID = _ID;
};
#define DEFAULT_NIL_ITEM(num) typename _Ty##num = _NilEnumItem<INT_MIN + num> template<DEFAULT_NIL_ITEM(), DEFAULT_NIL_ITEM(), DEFAULT_NIL_ITEM(), DEFAULT_NIL_ITEM(),
DEFAULT_NIL_ITEM(), DEFAULT_NIL_ITEM(), DEFAULT_NIL_ITEM(), DEFAULT_NIL_ITEM(),
DEFAULT_NIL_ITEM(), DEFAULT_NIL_ITEM()>
class Enum
{
private:
explicit Enum(_Ty0) : enumID(_Ty0::enumID) {}
explicit Enum(_Ty1) : enumID(_Ty1::enumID) {}
explicit Enum(_Ty2) : enumID(_Ty2::enumID) {}
explicit Enum(_Ty3) : enumID(_Ty3::enumID) {}
explicit Enum(_Ty4) : enumID(_Ty4::enumID) {}
explicit Enum(_Ty5) : enumID(_Ty5::enumID) {}
explicit Enum(_Ty6) : enumID(_Ty6::enumID) {}
explicit Enum(_Ty7) : enumID(_Ty7::enumID) {}
explicit Enum(_Ty8) : enumID(_Ty8::enumID) {}
explicit Enum(_Ty9) : enumID(_Ty9::enumID) {} public:
template<typename _T>
static Enum Get() { return Enum(_T()); } template<typename _T>
bool EqualTo() { enumID == Enum(_T()); } bool operator == (const Enum& e) { return enumID == e.enumID; }
bool operator != (const Enum& e) { return enumID != e.enumID; } #define _PARAMLIST0
#define _PARAMLIST1(p1) p1
#define _PARAMLIST2(p1, p2) p1,##p2
#define _PARAMLIST3(p1, p2, p3) p1,##p2,##p3
#define _PARAMLIST4(p1, p2, p3, p4) p1,##p2,##p3,##p4
#define _PARAMLIST5(p1, p2, p3, p4, p5) p1,##p2,##p3,##p4,##p5
#define _PARAMLIST6(p1, p2, p3, p4, p5, p6) p1,##p2,##p3,##p4,##p5,##p6
#define _PARAMLIST7(p1, p2, p3, p4, p5, p6, p7) p1,##p2,##p3,##p4,##p5,##p6,##p7
#define _PARAMLIST8(p1, p2, p3, p4, p5, p6, p7, p8) p1,##p2,##p3,##p4,##p5,##p6,##p7,##p8
#define _PARAMLIST9(p1, p2, p3, p4, p5, p6, p7, p8, p9) p1,##p2,##p3,##p4,##p5,##p6,##p7,##p8,##p9
#define _PARAMLIST10(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) p1,##p2,##p3,##p4,##p5,##p6,##p7,##p8,##p9,##p10 #define _INVOKE_WITHOUT_RETURN_BODY(_PARAMSLIST) \
if(enumID == _Ty0::enumID) \
_Ty0::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty1::enumID) \
_Ty1::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty2::enumID) \
_Ty3::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty3::enumID) \
_Ty4::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty4::enumID) \
_Ty4::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty5::enumID) \
_Ty5::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty6::enumID) \
_Ty6::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty7::enumID) \
_Ty7::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty8::enumID) \
_Ty8::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty9::enumID) \
_Ty9::Invoke<_FuncID>()(_PARAMSLIST); \
else \
assert(false && "提供不存在enumID"); template<int _FuncID>
void InvokeWithoutReturn()
{ _INVOKE_WITHOUT_RETURN_BODY(_PARAMLIST0); } template<int _FuncID, typename _Pr0>
void InvokeWithoutReturn(_Pr0 pr0)
{ _INVOKE_WITHOUT_RETURN_BODY(_PARAMLIST1(pr0)); } template<int _FuncID, typename _Pr0, typename _Pr1>
void InvokeWithoutReturn(_Pr0 pr0, _Pr1 pr1)
{ _INVOKE_WITHOUT_RETURN_BODY(_PARAMLIST2(pr0, pr1)); } template<int _FuncID, typename _Pr0, typename _Pr1, typename _Pr2>
void InvokeWithoutReturn(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2)
{ _INVOKE_WITHOUT_RETURN_BODY(_PARAMLIST3(pr0, pr1, pr2)); } template<int _FuncID, typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3>
void InvokeWithoutReturn(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3)
{ _INVOKE_WITHOUT_RETURN_BODY(_PARAMLIST4(pr0, pr1, pr2, pr3)); } template<int _FuncID, typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4>
void InvokeWithoutReturn(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4)
{ _INVOKE_WITHOUT_RETURN_BODY(_PARAMLIST5(pr0, pr1, pr2, pr3, pr4)); } template<int _FuncID, typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4
, typename _Pr5>
void InvokeWithoutReturn(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4, _Pr5 pr5)
{ _INVOKE_WITHOUT_RETURN_BODY(_PARAMLIST6(pr0, pr1, pr2, pr3, pr4, pr5)); } template<int _FuncID, typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4
, typename _Pr5, typename _Pr6>
void InvokeWithoutReturn(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4, _Pr5 pr5,
_Pr6 pr6)
{ _INVOKE_WITHOUT_RETURN_BODY(_PARAMLIST7(pr0, pr1, pr2, pr3, pr4, pr5, pr6)); } template<int _FuncID, typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4
, typename _Pr5, typename _Pr6, typename _Pr7>
void InvokeWithoutReturn(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4, _Pr5 pr5,
_Pr6 pr6, _Pr7 pr7)
{ _INVOKE_WITHOUT_RETURN_BODY(_PARAMLIST8(pr0, pr1, pr2, pr3, pr4, pr5, pr6, pr7)); } template<int _FuncID, typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4
, typename _Pr5, typename _Pr6, typename _Pr7, typename _Pr8>
void InvokeWithoutReturn(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4, _Pr5 pr5,
_Pr6 pr6, _Pr7 pr7, _Pr8 pr8)
{ _INVOKE_WITHOUT_RETURN_BODY(_PARAMLIST9(pr0, pr1, pr2, pr3, pr4, pr5, pr6, pr7, pr8)); } template<int _FuncID, typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3, typename _Pr4
, typename _Pr5, typename _Pr6, typename _Pr7, typename _Pr8, typename _Pr9>
void InvokeWithoutReturn(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4, _Pr5 pr5,
_Pr6 pr6, _Pr7 pr7, _Pr8 pr8, _Pr9 pr9)
{ _INVOKE_WITHOUT_RETURN_BODY(_PARAMLIST10(pr0, pr1, pr2, pr3, pr4, pr5, pr6, pr7, pr8, pr9)); } #define _INVOKE_WITH_RETURN_BODY(_PARAMSLIST) \
if(enumID == _Ty0::enumID) \
return _Ty0::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty1::enumID) \
return _Ty1::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty2::enumID) \
return _Ty3::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty3::enumID) \
return _Ty4::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty4::enumID) \
return _Ty4::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty5::enumID) \
return _Ty5::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty6::enumID) \
return _Ty6::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty7::enumID) \
return _Ty7::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty8::enumID) \
return _Ty8::Invoke<_FuncID>()(_PARAMSLIST); \
else if(enumID == _Ty9::enumID) \
return _Ty9::Invoke<_FuncID>()(_PARAMSLIST); \
else \
assert(false && "提供不存在enumID"); template<int _FuncID, typename _Ret>
_Ret InvokeWithReturn()
{ _INVOKE_WITH_RETURN_BODY(_PARAMLIST0); } template<int _FuncID, typename _Ret, typename _Pr0, typename _Pr1>
_Ret InvokeWithReturn(_Pr0 pr0)
{ _INVOKE_WITH_RETURN_BODY(_PARAMLIST1(pr0)); } template<int _FuncID, typename _Ret, typename _Pr0, typename _Pr1>
_Ret InvokeWithReturn(_Pr0 pr0, _Pr1 pr1)
{ _INVOKE_WITH_RETURN_BODY(_PARAMLIST2(pr0, pr1)); } template<int _FuncID, typename _Ret, typename _Pr0, typename _Pr1, typename _Pr2>
_Ret InvokeWithReturn(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2)
{ _INVOKE_WITH_RETURN_BODY(_PARAMLIST3(pr0, pr1, pr2)); } template<int _FuncID, typename _Ret, typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3>
_Ret InvokeWithReturn(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3)
{ _INVOKE_WITH_RETURN_BODY(_PARAMLIST4(pr0, pr1, pr2, pr3)); } template<int _FuncID, typename _Ret, typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3,
typename _Pr4>
_Ret InvokeWithReturn(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4)
{ _INVOKE_WITH_RETURN_BODY(_PARAMLIST5(pr0, pr1, pr2, pr3, pr4)); } template<int _FuncID, typename _Ret, typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3,
typename _Pr4, typename _Pr5>
_Ret InvokeWithReturn(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4, _Pr5 pr5)
{ _INVOKE_WITH_RETURN_BODY(_PARAMLIST6(pr0, pr1, pr2, pr3, pr4, pr5)); } template<int _FuncID, typename _Ret, typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3,
typename _Pr4, typename _Pr5, typename _Pr6>
_Ret InvokeWithReturn(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4, _Pr5 pr5, _Pr6 pr6)
{ _INVOKE_WITH_RETURN_BODY(_PARAMLIST7(pr0, pr1, pr2, pr3, pr4, pr5, pr6)); } template<int _FuncID, typename _Ret, typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3,
typename _Pr4, typename _Pr5, typename _Pr6, typename _Pr7>
_Ret InvokeWithReturn(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4, _Pr5 pr5, _Pr6 pr6,
_Pr7 pr7)
{ _INVOKE_WITH_RETURN_BODY(_PARAMLIST8(pr0, pr1, pr2, pr3, pr4, pr5, pr6, pr7)); } template<int _FuncID, typename _Ret, typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3,
typename _Pr4, typename _Pr5, typename _Pr6, typename _Pr7, typename _Pr8>
_Ret InvokeWithReturn(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4, _Pr5 pr5, _Pr6 pr6,
_Pr7 pr7, _Pr8 pr8)
{ _INVOKE_WITH_RETURN_BODY(_PARAMLIST9(pr0, pr1, pr2, pr3, pr4, pr5, pr6, pr7, pr8)); } template<int _FuncID, typename _Ret, typename _Pr0, typename _Pr1, typename _Pr2, typename _Pr3,
typename _Pr4, typename _Pr5, typename _Pr6, typename _Pr7, typename _Pr8, typename _Pr9>
_Ret InvokeWithReturn(_Pr0 pr0, _Pr1 pr1, _Pr2 pr2, _Pr3 pr3, _Pr4 pr4, _Pr5 pr5, _Pr6 pr6,
_Pr7 pr7, _Pr8 pr8, _Pr9 pr9)
{ _INVOKE_WITH_RETURN_BODY(_PARAMLIST10(pr0, pr1, pr2, pr3, pr4, pr5, pr6, pr7, pr8, pr9)); } private:
int enumID;
}; } #endif // end __MYENUM_H___
测试用代码：
#include <iostream>
#include "MyEnum.h"
using namespace MyEnum; template<typename _Ty0, typename _Ty1>
class F0
{
public:
void operator() (_Ty0 t0, _Ty0 t1)
{
std::cout << "Enum1 - Func：F0 () -> { x + y } = " << t0 + t1 << std::endl;
}
}; template<typename _Ty0, typename _Ty1>
class F1
{
public:
void operator() (_Ty0 t0, _Ty0 t1)
{
std::cout << "Enum1 - Func：F1 () -> { x * y } = " << t1 * t0 << std::endl;
}
}; template<typename _Ty0, typename _Ty1>
class F2
{
public:
void operator() (_Ty0 t0, _Ty0 t1)
{
std::cout << "Enum2 - Func：F2 () -> { x - y } = " << t0 - t1 << std::endl;
}
}; template<typename _Ty0, typename _Ty1>
class F3
{
public:
void operator() (_Ty0 t0, _Ty0 t1)
{
std::cout << "Enum2 - Func：F3 () -> { x / y } = " << t1 / t0 << std::endl;
}
}; class Enum1 : public EnumItem< EnumFunction<, F0<int, int>>, EnumFunction<, F1<int, int>> > {};
class Enum2 : public EnumItem< EnumFunction<, F2<int, int>>, EnumFunction<, F3<int, int>> > {};
typedef Enum<
Enum1,
Enum2
> EnumTest; void Invoke0(EnumTest e, int p1, int p2)
{
e.InvokeWithoutReturn<>(p1, p2);
} void Invoke2(EnumTest e, int p1, int p2)
{
e.InvokeWithoutReturn<>(p1, p2);
} int main()
{
EnumTest enum1 = EnumTest::Get<Enum1>();
EnumTest enum2 = EnumTest::Get<Enum2>(); Invoke0(enum1, , );
Invoke0(enum2, , ); std::cout << std::endl; Invoke2(enum1, , );
Invoke2(enum2, , ); std::cout << std::endl; //enum2.InvokeWithoutReturn<0>(); enum2 = enum1;
Invoke0(enum2, , ); if(enum2 == enum1) {
std::cout << "Enum2 == Enum1" << std::endl;
}
else {
std::cout << "Enum2 != Enum1" << std::endl;
} return ;
}
测试结果 ：
可以看见我们完美地把一组函数绑定到enum1与enum2上，并通过 InvokeWithoutReturn<n>（）方法可以指定调用哪一组函数