在C ++中创建快速函数重载

Question

template<typename Functor, typename Return, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6,
                typename Arg7, typename Arg8, typename Arg9, typename Arg10> class LambdaCall : public Instruction {
                public:
                    LambdaCall(Functor func
                        ,unsigned char constructorarg1
                        ,unsigned char constructorarg2
                        ,unsigned char constructorarg3
                        ,unsigned char constructorarg4
                        ,unsigned char constructorarg5
                        ,unsigned char constructorarg6
                        ,unsigned char constructorarg7
                        ,unsigned char constructorarg8
                        ,unsigned char constructorarg9
                        ,unsigned char constructorarg10)
                        : arg1(constructorarg1)
                        , arg2(constructorarg2)
                        , arg3(constructorarg3)
                        , arg4(constructorarg4)
                        , arg5(constructorarg5)
                        , arg6(constructorarg6)
                        , arg7(constructorarg7)
                        , arg8(constructorarg8)
                        , arg9(constructorarg9)
                        , arg10(constructorarg10)
                        , function(func) {}
                    void Call(State& state) {
                        state.Push<Return>(func(*state.GetRegisterValue<Arg1>(arg1)
                            ,*state.GetRegisterValue<Arg1>(arg1)
                            ,*state.GetRegisterValue<Arg2>(arg2)
                            ,*state.GetRegisterValue<Arg3>(arg3)
                            ,*state.GetRegisterValue<Arg4>(arg4)
                            ,*state.GetRegisterValue<Arg5>(arg5)
                            ,*state.GetRegisterValue<Arg6>(arg6)
                            ,*state.GetRegisterValue<Arg7>(arg7)
                            ,*state.GetRegisterValue<Arg8>(arg8)
                            ,*state.GetRegisterValue<Arg9>(arg9)
                            ,*state.GetRegisterValue<Arg10>(arg10)
                         ));
                    }
                    Functor function;
                    unsigned char arg1;
                    unsigned char arg2;
                    unsigned char arg3;
                    unsigned char arg4;
                    unsigned char arg5;
                    unsigned char arg6;
                    unsigned char arg7;
                    unsigned char arg8;
                    unsigned char arg9;
                    unsigned char arg10;
            };

然后再次为我想要支持的每个可能数量的参数，再次为void返回。

有什么方法可以更快地完成这项工作？

编辑： 显然，对于上述功能的目标存在一些（可理解的）混淆。

我想创建一个接受N个模板参数的函数，有N个unsigned char变量，在它的构造函数中接受它们并分配它们，使用第N个模板和第N个char参数调用特定函数，并将返回值传递给给定lamba函数，然后将其返回到最后一个函数，该函数具有特殊的模板参数 然后我希望这适用于任何给定数量的参数或无效返回。 最好不要为每个参数编号和无效返回可能性写入重载，因为这将涉及22个专业化 编辑：没有可变参数，不是任何给定的数量，但最多可以说十。 我查看了Boost预处理器库，但它无法正常工作。