2

我想弄清楚如何std::function用“之前”和“之后”的钩子来装饰。

我在找出正确的语法时遇到了一些麻烦。这是我到目前为止所拥有的：

// create a "before" hook
template<typename Functor, typename Hook>
Functor hook_before(const Functor & original, Hook hook)
{
    // not legal, but illustrates what I want to achieve
    template<typename Args ...args> 
    return [=](Args ...args)
    {
        hook();
        original(args...);
    };
}

我的示例应用程序在Ideone上。

谁能帮我弄清楚？

4

3 回答 3

3

这里去（未经测试）：

template <typename HOOK, typename RET, typename... ARGS>
struct BeforeHook {
    std::function<RET(ARGS...)> functor;
    HOOK hook;
    BeforeHook(blah) : blah {};

    RET operator()(ARGS&&... args) const {
        hook();
        return functor(args...);
    }
};

template <typename HOOK, typename RET, typename... ARGS>
BeforeHook<HOOK, RET, ARGS...> hook_before(const std::function<RET(ARGS...)> &original, HOOK hook) {
    return BeforeHook<HOOK, RET, ARGS...>(original, hook);
}

用法：

auto hooked = hook_before(original_functor, hook_functor);
hooked(args_for_original_functor); // calls hook_functor, then original_functor

或类似的规定。original_functor 需要转换为std::function，但几乎所有可调用的都是。两个仿函数都需要成本可调用，但如果您愿意，可以将其const删除operator()。

如果您想尝试返回 lambda 而不是 的实例，请对模板参数和BeforeHook使用相同的技巧，并确定是否可以在 lambda 中使用模板参数包：RET...ARGS

template <typename HOOK, typename RET, typename... ARGS>
std::function<RET(ARGS...)> hook_before(const std::function<RET(ARGS...)> &original, HOOK hook) {
    return [=](ARGS&&... args) -> RET {
        hook();
        return original(args...);
    };
}

无论哪种方式，我认为关键技巧是std::function在模板参数推导中使用将返回类型与参数分开。

于 2012-06-06T09:38:41.447 回答
3

你可以这样做：

#include <functional>
#include <iostream>

template <class Hook, class ReturnType, class... ArgType>
std::function<ReturnType(ArgType...)> hook_before(
    const std::function<ReturnType(ArgType...)>& original, 
    Hook hook)
{
    return [=](ArgType... args){
        hook();
        return original(std::move(args)...);
    };
}

int main()
{
    std::function<int(int, int)> sum = [](int a, int b) { return a + b; };

    std::cout << sum(3, 4) << std::endl;

    auto myhook = []() { std::cout << "Calculating sum" << std::endl; };
    auto hooked_sum = hook_before(sum, myhook);
    std::cout << hooked_sum(3, 4) << std::endl;
}

该hook_before函数接受两个函子，并返回另一个接受与第一个（ArgType 参数包）相同的参数但hook首先调用的函数。

于 2012-06-06T09:53:49.950 回答
2

试试下面的。

template<typename Functor, typename Hook>
struct BeforeHooked
{
    Functor f;
    Hook hook;

    template<class... Args>
    typename std::result_of<F(Args&&...)>::type
    operator()(Args&&... args)
    {
        hook();
        return f(std::forward<Args&&>(args)...);
    }
};

template<typename Functor, typename Hook>
Functor hook_before(Functor f, Hook hook)
{
    return BeforeHooked{f, hook};
}

代码未经测试，但假设你有一个可以编译它的编译器，我认为它应该做你想做的事。与其他答案不同，它可以接受任何函子，而不仅仅是std::function，如果你给它一个多态函子，它仍然是多态的。

于 2012-06-06T10:15:02.840 回答