将 c++11 std::function 包装在另一个 std::function 中

Wrap c++11 std::function in another std::function?

本文关键字：std function 另一个 包装 c++11      更新时间：2023-10-16

我想将 std：：bind（） 或 lambda 的结果包装在一个跟踪函数调用执行时间的辅助函数中。我想要一个通用的解决方案，它可以处理任意数量的参数（和类方法）并且与 c++11 兼容。

我的目的是获取包装的函数并将其传递给 boost：：signals2：：signal，因此生成的函数对象需要在签名上与原始函数相同。

我基本上正在寻找一些像这样工作的神奇类或函数Wrapper：

std::function<void(int)> f = [](int x) {
    std::cerr << x << std::endl;
};
boost::signals2::signal<void(int)> x_signal;
x_signal.connect(Wrapper<void(int)>(f));
x_signal(42);

那将计算打印 42 需要多长时间。

谢谢！

如果是关于性能，我强烈建议不要双重包装函数。

您可以没有这些：

template <typename Caption, typename F>
auto timed(Caption const& task, F&& f) {
    return [f=std::forward<F>(f), task](auto&&... args) {
        using namespace std::chrono;
        struct measure {
            high_resolution_clock::time_point start;
            Caption const& task;
            ~measure() { std::cout << " -- (" << task << " completed in " << duration_cast<microseconds>(high_resolution_clock::now() - start).count() << "µs)n"; }
        } timing { high_resolution_clock::now(), task };
        return f(std::forward<decltype(args)>(args)...);
    };
}

观看现场演示：

住在科里鲁

#include <chrono>
#include <iostream>
template <typename Caption, typename F>
auto timed(Caption const& task, F&& f) {
    return [f=std::forward<F>(f), task](auto&&... args) {
        using namespace std::chrono;
        struct measure {
            high_resolution_clock::time_point start;
            Caption const& task;
            ~measure() { std::cout << " -- (" << task << " completed in " << duration_cast<microseconds>(high_resolution_clock::now() - start).count() << "µs)n"; }
        } timing { high_resolution_clock::now(), task };
        return f(std::forward<decltype(args)>(args)...);
    };
}
#include <thread>
int main() {
    using namespace std;
    auto f = timed("IO", [] { cout << "hello worldn"; return 42; });
    auto g = timed("Sleep", [](int i) { this_thread::sleep_for(chrono::seconds(i)); });
    g(1);
    f();
    g(2);
    std::function<int()> f_wrapped = f;
    return f_wrapped();
}

打印（例如）：

 -- (Sleep completed in 1000188µs)
hello world
 -- (IO completed in 2µs)
 -- (Sleep completed in 2000126µs)
hello world
 -- (IO completed in 1µs)
exitcode: 42

更新：c++11 版本

住在科里鲁

#include <chrono>
#include <iostream>
namespace detail {
    template <typename F>
    struct timed_impl {
        std::string _caption;
        F _f;
        timed_impl(std::string const& task, F f) 
            : _caption(task), _f(std::move(f)) { }
        template <typename... Args>
        auto operator()(Args&&... args) const -> decltype(_f(std::forward<Args>(args)...))
        {
            using namespace std::chrono;
            struct measure {
                high_resolution_clock::time_point start;
                std::string const& task;
                ~measure() { std::cout << " -- (" << task << " completed in " << duration_cast<microseconds>(high_resolution_clock::now() - start).count() << "µs)n"; }
            } timing { high_resolution_clock::now(), _caption };
            return _f(std::forward<decltype(args)>(args)...);
        }
    };
}
template <typename F>
detail::timed_impl<F> timed(std::string const& task, F&& f) {
    return { task, std::forward<F>(f) };
}
#include <thread>
int main() {
    using namespace std;
    auto f = timed("IO", [] { cout << "hello worldn"; return 42; });
    auto g = timed("Sleep", [](int i) { this_thread::sleep_for(chrono::seconds(i)); });
    g(1);
    f();
    g(2);
    std::function<int()> f_wrapped = f;
    return f_wrapped();
}
我相信

你想做的事情可以用可变参数模板来解决。

http://www.cplusplus.com/articles/EhvU7k9E/

你基本上可以将参数列表从外部 std：：function "转发"到内部。

编辑：

下面，我使用可变参数模板概念添加了一个最小的工作示例。在main(...)中，一个 lambda 函数被包装到另一个 std::function 对象中，使用内部 lambda 函数的指定参数。这是通过将要测量的函数作为参数传递给模板化函数measureTimeWrapper来完成的。它返回一个与传入的函数具有相同签名的函数（假设您在 measureTimeWrapper 的模板参数中正确定义了该 lambda 的参数列表）。

测量运行时间的函数只是坐在这里等待由其参数定义的毫秒数。除此之外，它根本不关心时间测量。这是由包装器函数完成的。

请注意，内部函数的返回值以这种方式丢失;如果要保留它，则可能需要更改返回值的方式（可能作为结构，包含测量的时间和实际返回值）。

请记住至少使用-std=c++11编译代码。

#include <iostream>
#include <cstdlib>
#include <functional>
#include <chrono>
#include <thread>

template<typename T, typename... Args>
std::function<double(Args...)> measureTimeWrapper(std::function<T> fncFunctionToMeasure) {
  return [fncFunctionToMeasure](Args... args) -> double {
    auto tsStart = std::chrono::steady_clock::now();
    fncFunctionToMeasure(args...);
    auto tsEnd = std::chrono::steady_clock::now();
    std::chrono::duration<double> durTimeTaken = tsEnd - tsStart;
    return durTimeTaken.count();
  };
}
int main(int argc, char** argv) {
  std::function<double(int)> fncMeasured = measureTimeWrapper<void(int), int>([](int nParameter) {
      std::cout << "Process function running" << std::endl;
      std::chrono::milliseconds tsTime(nParameter); // Milliseconds
      std::this_thread::sleep_for(tsTime);
    });
  std::cout << "Time taken: " << fncMeasured(500) << " sec" << std::endl;
  return EXIT_SUCCESS;
}

#include <iostream>
#include <functional>
template<typename Signature>
std::function<Signature>    Wrapper(std::function<Signature> func)
{
  return [func](auto... args)
    {
      std::cout << "function tracked" << std::endl;
      return func(args...);
    };
}
int     lol(const std::string& str)
{
  std::cout << str << std::endl;
  return 42;
}
int     main(void)
{
  auto wrapped = Wrapper<int(const std::string&)>(lol);
  std::cout << wrapped("Hello") << std::endl;
}
将

"function tracked"部分替换为您想要的任何跟踪逻辑（计时、缓存等）

但这需要c++14

相关文章：