c++ - 将具有任意参数和占位符的函数存储在类中并稍后调用

Question

所以我正在创建一种事件处理程序，如果您愿意的话，我正在编写一个“事件监听器包装器”。

基本思路是这样的:当您想要订阅一个事件时，您可以创建一个函数，该函数应在事件触发时调用。 <-- 已经完成了(有点，我会解释)

您将此监听器函数放入包装器中，以将函数传递给调度程序。

调度程序获取一个事件，为您的监听器找到包装器，并使用事件设置的参数值调用底层函数。

只要所有听众只接受我的 EventBase 类的一个参数，我就已经有了一些工作。然后我必须将其强制转换为传递监听器的正确事件。

我想要的是让我的监听器函数具有“任何”类型的参数，并以一种允许我根据触发的事件用我想要的任何参数调用它的方式存储函数。每个监听器函数只会接收一种类型的事件，或者事件本身。这将使我不必在每个监听器中对每个事件进行类型转换，而是传递正确的事件。

我为这个包装器找到了一些几乎完美的代码，但有一些我似乎无法修复的小问题。我将在下面解释。

@hmjd 的代码:

#include <iostream>
#include <string>
#include <functional>
#include <memory>

void myFunc1(int arg1, float arg2)
{
    std::cout << arg1 << ", " << arg2 << '\n';
}
void myFunc2(const char *arg1)
{
    std::cout << arg1 << '\n';
}

class DelayedCaller
{
public:
    template <typename TFunction, typename... TArgs>
    static std::unique_ptr<DelayedCaller> setup(TFunction&& a_func,
                                                TArgs&&... a_args)
    {
        return std::unique_ptr<DelayedCaller>(new DelayedCaller(
            std::bind(std::forward<TFunction>(a_func),
                      std::forward<TArgs>(a_args)...)));
    }
    void call() const { func_(); }

private:
    using func_type = std::function<void()>;
    DelayedCaller(func_type&& a_ft) : func_(std::forward<func_type>(a_ft)) {}
    func_type func_;
};

int main()
{
    auto caller1(DelayedCaller::setup(&myFunc1, 123, 45.6));
    auto caller2(DelayedCaller::setup(&myFunc2, "A string"));

    caller1->call();
    caller2->call();

    return 0;
}

我在这里做的第一件事是必须将 std::unique_ptr 替换为 std::shared_ptr。不知道为什么真的。这几乎有效。在我的用例中，我需要存储一个方法函数(意味着绑定(bind)需要传递包含方法对象？)，并且在存储函数时我不知道参数值是什么，这就是事件来决定。所以我的调整如下:

class DelayedCaller
{
public:

    template <typename TFunction, typename TClass>
    static std::shared_ptr<DelayedCaller> setup(TFunction&& a_func,
                                                TClass && a_class)
    {

        auto func = std::bind(std::forward<TFunction>(a_func),
                              std::forward<TClass>(a_class),
                              std::placeholders::_1);

        return std::shared_ptr<DelayedCaller>(new DelayedCaller(func));
    }

    template <typename T>
    void call( T v ) const { func_(v); }

private:
    using func_type = std::function<void(  )>;
    DelayedCaller(func_type&& a_ft) : func_(std::forward<func_type>(a_ft)) {}
    func_type func_;
};

为了测试，我删除了参数包并将其替换为持有函数的类对象的直接参数。我还为绑定(bind)提供了一个用于 1 个参数的占位符(最好稍后用 void call() 函数替换)。

它是这样创建的:

eventManager->subscribe(EventDemo::descriptor, DelayedCaller::setup(
                                &AppBaseLogic::getValueBasic,
                                this
                                ));

问题是:在这条线上:

return std::shared_ptr<DelayedCaller>(new DelayedCaller(func));

我得到“没有匹配函数来调用‘DelayedCaller::DelayedCaller(std::_Bind(AppBaseLogic*, std::_Placeholder<1>)>&)’ 返回 std::shared_ptr(new DelayedCaller(func));"

只有在使用 placeholder::_1 时才会发生这种情况。如果我用正确类型的已知值替换它，它就可以工作，当然，当然在没有任何有用数据的情况下调用该函数除外。

所以，我想我需要一种方法来存储带有我不知道其类型的占位符的函数？

如果我把事物的名称弄错了，请原谅我。我是 c++ 的新手，我最近几天才开始学习它。

**编辑:**

好的，所以我只是更新为什么我需要这样存储函数。我的事件调度程序中有一张 map ，如下所示:

std::map< const char*, std::vector<DelayedCaller> > _observers;

我希望能够像这样调用“Delayed Caller”中的函数:

void Dispatcher::post( const EventBase& event ) const
{
    // Side Note: I had to do this instead of map.find() and map.at() because 
    // passing a "const char*" was not evaluating as equal to event.type() even 
    // though event.type() is also a const char*. So instead I am checking it 
    // myself, which is fine because it gives me a little more control.

    std::string type(event.type());
    for( auto const &x : _observers ) {
        std::string type2(x.first);
        if ( type == type2 ) {
            auto&& observers = x.second;

            for( auto&& observer : observers ) {
                // event may be any descendant of EventBase.
                observer.slot->call(event);
            }
            break;
        }
    }
}

我的听众目前看起来像这样:

void AppBaseLogic::getValue(const EventBase &e) {
    const EventDemo& demoEvent = static_cast<const EventDemo&>( e );
    std::cout << demoEvent.type();
}

我正在尝试存储每个函数，以便参数看起来像这样:

void AppBaseLogic::getValue(const EventAnyDescendant &e) {
    std::cout << e.type();
}

希望对您有所帮助。感谢大家花时间帮助我解决这个问题。

关于 lambda 的旁注:有人建议使用它们，我知道它们是什么或如何使用它们，但我打算对它们进行一些研究，看看这是否更有意义。从我所看到的情况来看，我担心他们的可维护性。

Answer 1

不太清楚您的DelayedCaller 正在做什么。如果您重构代码并删除它，您将得到:

auto c1 = []() {myFunc1(123, 45.6);}; // or use bind, the result is exactly the same
auto c2 = []() {myFunc2("A string");};

vector<function<void()>> v {c1, c2};
v[0]();
v[1](); // ok

现在，如果您尝试在这个版本中引入占位符修改，那么为什么它首先不起作用就变得很清楚了:

auto cSome = [](???) {getValueBasic(???)};

您将 ??? 替换为什么？

getValueBasic 接受一些特定类型的参数，它会泄漏到 cSome 签名中。无论您将其包装在多少个模板包装器中，它都会泄漏到每个包装器的签名中，直至并包括最外层的包装器。 bind 和 std::placeholders 不是能够让它不发生的魔杖。

换句话说，如果您不知道函数的类型，就无法调用它(很明显，不是吗？)

一种类型删除签名并使所有可调用对象符契约(Contract)一类型的方法是在运行时对其进行类型检查和类型转换(又名dynamic_cast)。另一种是双重 dispatch 。这两种方法都是 visitor 相同一般概念的不同体现。谷歌“访问者模式”了解更多信息。