C ++可变参数宏还是可变参数模板？

Question

I would like to simplify some code and would like help figuring out if there is a way to do it with a variadic macro or better yet a variadic template. The sample code below will show what I am trying to do.

#include <string>
#include <iostream>
#include <map>
#include <typeinfo>

// Class that registers an external function handler
template <typename ReturnType, typename... Args> class Redirector
{
    const std::string &m_funcName;

public:
    typedef ReturnType (*FuncTy)(Args...);
    Redirector(const std::string &functionName, FuncTy pfunc) : m_funcName(functionName)
    {
        GetMap()[functionName] = pfunc;
    }

    ~Redirector()
    {
        auto i = GetMap().find(m_funcName);
        if (i == GetMap().end()) return;
        i->second = nullptr;
        GetMap().erase(m_funcName);
    }

    static std::map<std::string, FuncTy> &GetMap()
    {
        static std::map<std::string, Redirector::FuncTy> _map;
        return _map;        
    }

    static FuncTy &GetHandler(std::string functionName)
    {
        auto i = GetMap().find(functionName);
        if (i == GetMap().end()) {
            std::cerr << functionName << " is not present in the list of functions to be redirected.\n";
            exit(-1);
        }
        return i->second;
    }
};

// Actual functions we want to call
void foo(int a)
{
    std::cout << "foo:" << a << std::endl;
}

void bar(double b, int *p)
{
    std::cout << "bar:" << b << " and " << p << std::endl;
}


// Redirection Handlers 
void foo1(int A)
{
    auto handle = Redirector<void, int>::GetHandler("_FOO");
    handle(A);
}
Redirector<void, int>_FOOHandler("_FOO", reinterpret_cast<Redirector<void, int>::FuncTy>(foo));

void bar1(double B, int *P)
{
    auto handle = Redirector<void, double, int *>::GetHandler("_BAR");
    handle(B, P);
}
Redirector<void, double, int *>_BARHandler("_BAR", reinterpret_cast<Redirector<void, double, int *>::FuncTy>(bar));

// Main 
int main()
{
    int i = 7;

    foo1(i);
    bar1(3.4, &i);

    return 0;
}

Assume there will be lots of foo1 & bar1 functions that are needed and all of them would do the same just would take different number of parameters and different types of parameters. The following is not a working macro but just an idea to show what I am trying to do:

define REGISTER_HANDLER(NAME,PARAMS)\
void NAME ## 1(PARAMS)\                                                                              
{\                                                                                                  
    auto handle = Redirector<PARAM_TYPES>::GetHandler("_"#NAME);\                                   
    handle(PARAM_NAMES);\                                                                                      
}\                                                                                                   
Redirector<PARAM_TYPES>NAME ## Handler("_"#NAME, reinterpret_cast<Redirector<PARAM_TYPES>::FuncTy>(foo));\

REGISTER_HANDLER(foo,int a);
REGISTER_HANDLER(bar,double b,int *p);

I have looked into using the __VA_ARGS__ for macros, but I can't quite figure out how to get just the parameter types or just the parameter names.

Answer 1

Well I think I found a solution that works:

#define REGISTER_HANDLER(NAME,...)                                                                                          \
template<typename... Args>                                                                                                  \
void NAME##1(Args... args)                                                                                                  \
{                                                                                                                           \
    auto handle = Redirector<void, Args...>::GetHandler("_"#NAME);                                                          \
    handle((args)...);                                                                                                      \
}                                                                                                                           \
Redirector<void,__VA_ARGS__>NAME ## HandlerObject("_"#NAME, reinterpret_cast<Redirector<void,__VA_ARGS__>::FuncTy>(NAME));

REGISTER_HANDLER(foo,int);
REGISTER_HANDLER(bar,double, int*);

If someone has a better idea please let me know.