C++使用类型代替枚举量
2014-03-17 16:09
316 查看
自己写的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(0), _DEFAULT_NIL_FUNC(1), _DEFAULT_NIL_FUNC(2), _DEFAULT_NIL_FUNC(3),
_DEFAULT_NIL_FUNC(4), _DEFAULT_NIL_FUNC(5), _DEFAULT_NIL_FUNC(6), _DEFAULT_NIL_FUNC(7),
_DEFAULT_NIL_FUNC(8), _DEFAULT_NIL_FUNC(9)>
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 = 0; 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(0), DEFAULT_NIL_ITEM(1), DEFAULT_NIL_ITEM(2), DEFAULT_NIL_ITEM(3),
DEFAULT_NIL_ITEM(4), DEFAULT_NIL_ITEM(5), DEFAULT_NIL_ITEM(6), DEFAULT_NIL_ITEM(7),
DEFAULT_NIL_ITEM(8), DEFAULT_NIL_ITEM(9)>
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<0, F0<int, int>>, EnumFunction<2, F1<int, int>> > {};
class Enum2 : public EnumItem< EnumFunction<0, F2<int, int>>, EnumFunction<2, F3<int, int>> > {};
typedef Enum<
Enum1,
Enum2
> EnumTest;
void Invoke0(EnumTest e, int p1, int p2)
{
e.InvokeWithoutReturn<0>(p1, p2);
}
void Invoke2(EnumTest e, int p1, int p2)
{
e.InvokeWithoutReturn<2>(p1, p2);
}
int main()
{
EnumTest enum1 = EnumTest::Get<Enum1>();
EnumTest enum2 = EnumTest::Get<Enum2>();
Invoke0(enum1, 100, 23);
Invoke0(enum2, 100, 23);
std::cout << std::endl;
Invoke2(enum1, 100, 23);
Invoke2(enum2, 100, 23);
std::cout << std::endl;
//enum2.InvokeWithoutReturn<0>();
enum2 = enum1;
Invoke0(enum2, 1, 3);
if(enum2 == enum1) {
std::cout << "Enum2 == Enum1" << std::endl;
}
else {
std::cout << "Enum2 != Enum1" << std::endl;
}
return 0;
}
测试结果 ：
可以看见我们完美地把一组函数绑定到enum1与enum2上，并通过 InvokeWithoutReturn<n>（）方法可以指定调用哪一组函数
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 【C/C++开发】C++之enum枚举量声明、定义、使用与枚举类详解与枚举类前置类型声明
- C++建立单向链表链表头指针需要使用指针类型的引用参数？
- 实战c++中的智能指针unique_ptr系列-- 使用std::unique_ptr代替new operator(错误：‘unique_ptr’ is not a member of ‘std’)
- 使用标准C++的类型转换符：static_cast、dynamic_cast、reinterpret_cast、和const_cast
- 数组类型的数据结构在C++里面定义和使用
- 读书笔记 effective c++ Item 47 使用traits class表示类型信息
- C/C++:enum-枚举量声明、定义和使用
- [c++]使用前后缀表示常量的类型
- 使用JNI时C++中的类型对应
- 使用集合接口的时候应该使用通用类型代替具体的实现类型
- c++中string类型字符串的使用
- 使用C/C++给静态类型数据添加运算符重载功能
- google竞赛题SecretSum的另一种C++解法, 使用递归生成代替循环 -- 2
- C++使用模板实现数值型字符串类型间的转换
- C++和C#有关值类型和引用类型，以及对引用类型使用ref的效果
- 实战c++中的智能指针unique_ptr系列-- 使用std::unique_ptr代替new operator(错误：‘unique_ptr’ is not a member of ‘std’)
- C++使用模板类实现任意类型switch和变量case
- 在c++中，有哪4个与类型转换相关的关键字，这些关键字各有什么特点，应该在什么场合下使用？
- C++拷贝构造函数的参数为什么必须使用引用类型
- C++中四种类型转换运算符的使用方法（reinterpret_cast，const_cast，static_cast，dynamic_cast）