C ++是否有可能实现指向不同参数列表的函数指针？

Question

我最近写了关于类成员函数回调的函数。 我需要保存回调对象和函数指针，然后调用函数指针并在需要回调的地方填写适当的参数。

我以typedef void (AAA::*Function)(int a, int b); ，但是当我需要支持成员函数的不同参数列表时，显然我需要一种动态的方法来实现它。

class AAA
{
public:
    int add(int a, int b)
    {
        return (a + b);
    }
};

class BBB
{
public:

    void setValue(std::string value)
    {
        this->value = value;
    }

private:
    std::string value;
};

class CCC
{
public:

    void bind(??? p)    // Binding objects and callback functions.
    {
        this->p = p;
    }

    template <class... Args>
    auto callback(Args&&... args)   // Autofill parameter list.
    {
        return this->p(std::forward<Args>(args)...);
    }

private:
    ??? p;  // How is this function pointer implemented?
};

int main()
{
    AAA aaa;
    BBB bbb;

    CCC ccc;
    ccc.bind(???(aaa, &AAA::add));
    int number = ccc.callback(5, 6);

    ccc.bind(???(bbb, &BBB::setValue));
    ccc.callback("Hello");

    system("pause");
    return 0;
}

我不知道如何实现函数指针“ ???”。

Answer 1

C ++是一种类型安全的语言。 这意味着您无法完全执行问题中概述的内容。 指向带有特定参数的函数的指针与指向带有不同参数的函数的指针是不同的类型。 这是C ++的基础。

std::bind可用于将不同类型键入为同一类型，但最后得到一个类型，该类型只能用一组匹配的参数（如果有）来调用。 无法使用其实际参数调用“底层”绑定函数。 这是因为std::bind的全部目的是使它们消失并且不可访问。 这就是std::bind目的。

在保持C ++类型安全性的界限和约束的同时，只有有限的设置选项可以使这项工作有效。

1. 以某种方式使用void * 。 其实不。 不要那样做 那只会造成更多的问题和头痛。

2. 有一个单独的列表和回调类，每个带有一组特定参数的回调集都有一个列表。 在调用回调时，您必须知道要传递哪些参数。 因此，只需从适当的列表中获取回调即可。

3. 利用std::variant 。 类型安全的std::variant仅限于C ++ 17（但boost具有类似的模板，该模板几乎是等效的，并且可用于较早的C ++版本）。 您所有的回调都使用一个std::variant参数，它是每个可能参数集的变体（指定为其中的std::tuple或某个类/结构实例）。 如果每个回调都收到包含错误参数值的std::variant ，则必须决定要做什么。

另外， std::variant可以是不同std::function类型的变体，从而将类型检查的责任转移给了调用者，而不是每个回调。

最重要的是，C ++本质上是一种类型安全的语言。 而这恰恰是为什么人们选择使用C ++而不是另一种没有相同类型安全性的语言的原因之一。

但是，作为一种类型安全的语言，这意味着在将不同的类型组合在一起时，您会受到某些限制。 具体来说：您不能。 C ++中的所有内容始终且必须是单一类型。

Answer 2

基本上，您要求具有完全动态键入和检查的函数调用。

要具有完全动态的函数调用，您基本上必须放弃C ++函数调用系统。

这是一个坏主意，但我会告诉您如何做。

可动态调用的对象大致如下所示：

using dynamic_function = std::function< std::any( std::vector<std::any> ) >

在哪里使用

struct nothing_t {};

当我们想返回void 。

然后，编写采用对象和特定签名并将其包装的机制。

template<class R, class...Args, class F>
struct dynamic_function_maker {
  template<std::size_t...Is>
  dynamic_function operator()(std::index_sequence<Is...>, F&& f)const {
    return [f=std::forward<F>(f)](std::vector<std::any> args)->std::any {
      if (sizeof...(Is) != args.size())
        throw std::invalid_argument("Wrong number of arguments");
      if constexpr( std::is_same< std::invoke_result_t<F const&, Args... >, void >{} )
      {
        f( std::any_cast<Args>(args[Is])... );
        return nothing_t{};
      }
      else
      {
        return f( std::any_cast<Args>(args[Is])... );
      }
    };
  }
  dynamic_function operator()(F&& f)const {
    return (*this)(std::make_index_sequence<sizeof...(Args)>{}, std::forward<F>(f));
  }
};
template<class R, class...Args, class F>
dynamic_function make_dynamic_function(F f){
  return dynamic_function_maker<R,Args...,F>{}(std::forward<F>(f));
}

接下来，您将要推断出函数指针等的签名：

template<class R, class...Args>
dynamic_function make_dynamic_function(R(*f)(Args...)){
  return dynamic_function_maker<R,Args...,F>{}(std::forward<F>(f));
}
template<class Tclass R, class...Args>
dynamic_function make_dynamic_function(T* t, R(T::*f)(Args...)){
  return dynamic_function_maker<R,Args...,F>{}(
    [t,f](auto&&...args)->decltype(auto){return (t->*f)(decltype(args)(args)...);}
  );
}

然后在修正上面的错字之后，您应该能够解决您原来的问题。

同样，作为真正可以编写和理解上述代码的人， 我强烈建议您不要使用它 。 这是脆弱而危险的。

几乎没有一个很好的理由将回调存储在您不知道要使用什么参数的地方。

您要用来调用它的每组参数应该有不同的CCC类型和实例。 当人们问这个问题的次数是99/100时，他们在问错问题。