有没有更简单的方法来执行宏以定义数量可变的参数的函数？

Question

I have a macro that defines a function with a variable amount of arguments, the macro has some logic to decide which real function must be called. My current approach is the following:

#define FUNC(ret,args,args_call) \
    ret my_func(args) { \
        if( something ) other_func(args_call);\
        return one_func(args_call);\
    }
#define PARAM(...) __VA_ARGS__

I use it like that:

class AClass : public AInterface {
public:
    FUNC(int,PARAM(int a, int b),PARAM(a,b))
};

I was wondering if there is a better way to do that.

Note: The declared ( my_func in my example) function will be used to reimplement a method from the super class, so the approaches using templates (the ones that I am aware of) will not solve my problem.

Edit2: Even using a proper variadic templated function, I still need the macro to declare the function because it overrides a function in the superclass.

#define FUNC(ret,args,args_call) \
ret my_func(args) { \
    return proper_variadic_templated_function<ret>(args_call);\
}

Answer 1

If we use the EVAL , helper, and Conditional macros from the first two code blocks here . We can create some recursive macros to parse the parameter array.

As the comma is syntactic we will need to escape it for outputting.

#define COMMA() ,

We can generate two functions to separate the types from the names.

#define I_WT_R() I_WT
#define I_WT(t,v,n,...) \
    t v IS_DONE(n)(      \
        EAT               \
    ,                      \
       OBSTRUCT(COMMA)()    \
       OBSTRUCT(I_WT_R)()    \
    )(n,__VA_ARGS__)
#define WithTypes(...) I_WT(__VA_ARGS__,DONE)

And.

#define I_WoT_R() I_WoT
#define I_WoT(t,v,n,...) \
    v IS_DONE(n)(         \
        EAT                \
    ,                       \
        OBSTRUCT(COMMA)()    \
        OBSTRUCT(I_WoT_R)()   \
    )(n,__VA_ARGS__)
#define WithoutTypes(...) I_WoT(__VA_ARGS__,DONE)

Redefining your macro as such:

#define FUNC(ret,args) EVAL(                           \
    ret my_func(WithTypes args) {                      \
        if( something ) other_func(WithoutTypes args); \
        return one_func(WithoutTypes args);            \
    })

Allows you the slightly better syntax of:

class AClass : public AInterface {
public:
    FUNC(int,(int,a,int,b))
};

Compiling to (after adding newlines):

class AClass : public AInterface {
public:
    int my_func(int a , int b ) {
        if( something )
            other_func(a , b );
        return one_func(a , b );
    }
};

Hope that helps.