【问题标题】:C/C++ build a generic stack frame to call different callback functionsC/C++ 构建通用栈帧来调用不同的回调函数
【发布时间】:2021-08-07 18:12:49
【问题描述】:

我正在重构一个 C++ 应用程序,它引用了一组多个回调函数,每个回调函数都有不同数量的参数,我想知道是否有 通用 方法来构建专用参数在调用它们之前堆栈帧。

换句话说:首先根据要调用的函数获取所有需要的参数,然后执行对被调用函数透明的调用。

在某种程度上,这与可变参数函数相反,因为这将是一个知道它可以接收不同数量参数的单个函数。在这里,我有一堆不可变的常规函数​​,我想从通用集线器调用它们。

我把 C 和 C++ 标签都放在这里是因为我对这两种语言的命题都感兴趣,我觉得对 C 有用的东西也会是适用于 C++,我仍然对“仅限 C++”的解决方案持开放态度,例如可变参数模板等。

这一切的背景是,引用的程序实际上是在解析一个命令行,然后根据命令的名称调用一个函数,作为程序名称之后的第一个参数传递,然后所有需要的都是纯字符串,但取决于调用的命令。

我知道我可以写这样的东西:

    if(nb_of_args == 1)
        my_callback_ptr(argv[n]);
    else if (nb_of_args == 2)
        my_callback_ptr(argv[n],argv[n+1]);
    else if (nb_of_args == 3)
        my_callback_ptr(argv[n],argv[n+1],argv[n+2]);
    else if (nb_of_args == 4)
        my_callback_ptr(argv[n],argv[n+1],argv[n+2],argv[n+3]);
    else if…

…将编译调用限制为唯一数量的参数,而不考虑函数本身,但我仍然希望做得更好。

提前感谢大家。

【问题讨论】:

  • 让你的回调采用数组,而不是单独的参数。
  • 不幸的是,这就是问题的关键:我无法更改它们。它们太多了,除了这个之外,还用在许多不同的地方。除此之外,这个问题本身仍然很有趣。
  • 我不认为这可以在标准 C 中完成。如果函数都采用相同的类型,适合默认参数提升,并且只有参数的数量不同,那么在某些系统上你使用没有原型的函数指针可能会逃脱:void (*my_callback_ptr)(); my_callback_ptr(argv[n], argv[n+1], argv[n+2], argv[n+3]. etc);。一般这种方式传递太多参数是UB,但是在很多常见的系统上额外的会被忽略。
  • 您可以尝试可变参数模板,然后明确地专门化它们。这会使代码有点混乱,但您可以为所有代码调用template <class... Args> void callback(Args...)。如果论点是可推论的,您也不必担心它们。不过,它并不比当前的解决方法好多少。它可能看起来像这样:template<> void callback<int,int>(int a, int b){ my_callback_ptr(a,b); }
  • 普通std:: bind无法处理的任何事情???

标签: c++ c variadic stack-frame


【解决方案1】:

一种可行的方法是实现调度表,该表将包含指向包装函数的指针,自动将适当数量的参数传递给每个回调。

#include <array>
#include <utility>
#include <cstddef>

template<auto x_p_callback, ::std::size_t... x_indexes>
void invoke_callback(char const * const * const pp_args, ::std::index_sequence<x_indexes...>)
{
    (*x_p_callback)(pp_args[x_indexes]...);
}

template<typename x_Callback >
struct
t_ArgsCount;

template<typename x_Result, typename... x_Args>
struct
t_ArgsCount<x_Result (x_Args...)>
:   ::std::integral_constant<::std::size_t, sizeof...(x_Args)>
{};

template<auto x_p_callback>
void callback_sunk(char const * const * const pp_args)
{
    using
    t_Callback = typename ::std::remove_reference<decltype(*x_p_callback)>::type;

    using
    t_Sequence = typename ::std::make_index_sequence<t_ArgsCount<t_Callback>::value>;

    invoke_callback<x_p_callback>(pp_args, t_Sequence{});
}

using
t_Callback = void (char const * const * const pp_args);

template<auto... x_p_callbacks>
constexpr auto make_table(void)
{
    return ::std::array<t_Callback *, sizeof...(x_p_callbacks)>{&callback_sunk<x_p_callbacks>...};
}

void my_callback_0() {}
void my_callback_1(char const *) {}
void my_callback_2(char const *, char const *) {}
void my_callback_3(char const *, char const *, char const *) {}

int main(int argc, char const * const * const pp_args)
{
    constexpr auto table{make_table<my_callback_0, my_callback_1, my_callback_2, my_callback_3>()};
    table.at(argc)(pp_args);
}

online compiler

【讨论】:

    【解决方案2】:

    虽然我对自己写的C代码有些疑惑(有待验证)。为了解决使用 callback(int argc, char *argv[] 之类的原型(作为 C/C++ 主)转换回调的困难,我的想法是将指针放入函数表中,该表将回调索引为指向可变函数的指针。

    这样,我们可以通过表中的指针调用所有传递最大参数数量的回调函数。显然,被调用的函数只会使用它们需要的参数,而不会使用其他参数。

    另一方面,这段代码会消耗指令,根据情况甚至会使用堆栈内存将无用的参数传递给不需要它们的函数。

    此代码似乎运行正确,但需要验证!

    #include <stdio.h>
    
    #define CBCALL(cbidx, argv, n) \
        ft[cbidx].f(argv[n],argv[n+1],argv[n+2],argv[n+3],argv[n+4])
    
    int cb0();
    int cb1(char *);
    int cb2(char *, char *);
    int cb3(char *, char *, char *);
    int cb4(char *, char *, char *, char *);
    int cb5(char *, char *, char *, char *, char *);
    
    typedef int FN(char *,...);
    
    struct table {
        FN * f;
    } ft[]={
    {(FN *)cb0},
    {(FN *)cb1},
    {(FN *)cb2},
    {(FN *)cb3},
    {(FN *)cb4},
    {(FN *)cb5}
    };
    
    
    int main(int argc, char * argv[])
    {
        if (argc<7) {
            CBCALL(argc-1,argv,1);
    
            if (argc>2)
            {// Trying with copied parms and NULL.
                char *xarg[5];
                xarg[0]=argv[1];
                xarg[1]=argv[2];
                xarg[2]=NULL;
                xarg[3]=NULL;
                xarg[4]=NULL;
    
                CBCALL(2,xarg,0);
            }
    
        } else {
            printf("Max 5 parameters are allowed!\n");
        }
    
        return 0;
    }
    
    int cb0()
    {
        printf("No parms\n");
        return 0;
    }
    
    int cb1(char *a)
    {
        printf("%s\n",a);
        return 1;
    }
    
    int cb2(char *a, char *b)
    {
        printf("%s %s\n",a,b);
        return 2;
    }
    
    int cb3(char *a, char *b, char *c)
    {
        printf("%s %s %s\n",a,b,c);
        return 3;
    }
    
    int cb4(char *a, char *b, char *c, char *d)
    {
        printf("%s %s %s %s\n",a,b,c,d);
        return 4;
    }
    
    int cb5(char *a, char *b, char *c, char *d, char *e)
    {
        printf("%s %s %s %s %s\n",a,b,c,d,e);
        return 5;
    }
    

    【讨论】:

      猜你喜欢
      • 2013-06-08
      • 2012-06-22
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 2012-10-30
      • 1970-01-01
      • 2023-01-23
      相关资源
      最近更新 更多