在 lambda 中包装模板化函数调用

Question

我正在尝试编写代码来执行与此类似的操作（为演示目的编写的代码）：

template <typename F, typename Args...>
inline auto runFunc(F func) -> foo
{
    return foo([func](Args... args) -> std::result_of<F>::type
        {
            // Do something before calling func
            func(args...);
            // Do something after call func
        });
}

所以基本上我正在尝试编写一个函数，该函数返回一个对象，该对象接受与模板化函数类型匹配的 lambda。显然这段代码不起作用，因为我没有定义 Args...。我将如何在 C++11 中解决这个问题？

Answer 1

template<class F_before, class F, class F_after>
struct decorate_func_t {
  F_before f0;
  F f1;
  F_after f2;

  template<class...Args>
  typename std::result_of<F(Args...)>::type operator()(Args&&...args)const{
    f0();
    auto r = f1(std::forward<Args>(args)...);
    f2();
    return r;
  }
};
template<class F_before, class F, class F_after>
decorate_func_t<F_before, F, F_after>
decorate_func( F_before before, F f, F_after after ){
  return {std::move(before), std::move(f), std::move(after)};
}

然后：

template <typename F, typename Args...>
inline auto runFunc(F func) -> foo
{
  return foo(decorate_func(
        []{/* Do something before calling func */},
        func,
        []{/* Do something after call func */ }
  };
}

C++11 lambda 中缺少 auto 参数，这使您可以做到最好。

在 C++14 中这是微不足道的：

template <class F>
auto runFunc(F func)
{
  return foo(
    [func](auto&&... args) // ->decltype(auto) maybe
    {
      // Do something before calling func
      auto r = func(decltype(args)(args)...);
      // Do something after call func
      return r;
    }
  );
}

请注意，许多名义上的 C++11 编译器实际上支持 lambda 上的 auto 参数。

Answer 2

您可以使用如下示例中的支撑结构：

#include<type_traits>
#include<cassert>

struct foo {
    template<typename F>
    foo(F f) { assert(42 == f(42)); }
};

template<typename>
struct S;

template<typename R, typename... Args>
struct S<R(*)(Args...)> {
    template <typename F>
    static auto runFunc(F func) -> foo
    {
        return foo{[func](Args... args) -> R
            {
                // Do something before calling func
                auto r = func(args...);
                // Do something after call func
                return r;
            }};
    }
};

template<typename F>
inline auto runFunc(F func) -> foo
{
    return S<F>::runFunc(func);
}

int f(int i) { return i; }

int main() {
    runFunc(f);
}

因为我不清楚问题的背景是什么，我不确定我是否得到了您所要求的内容。
希望上面的代码可以帮到你。

Answer 3

仍然不确定这是您要搜索的内容，我冒着发布的风险：

#include <iostream>

struct foo
{
    template<typename T>
    foo(T lambda)
    {
        lambda(1, 2);
    }
};

template <typename F, typename... Args>
inline typename std::result_of<F>::type runFunc(F func)
{
    return foo(
        [func](Args... args)
        {
            std::cout << "Before";
            func(args...);
            std::cout << "After";
        }
    );
}

struct print
{
    void operator()(int i) const
    {
        std::cout << i << std::endl;
    }

    void operator()(int i, int j) const
    {
        std::cout << i << " " << j << std::endl;
    }
};

int main()
{
    runFunc<print, int, int>(print());
}