C++使用类型代替枚举量

自己写的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>（）方法可以指定调用哪一组函数