C++ 具有任意数量参数的模板函数

我想编写一个函数

invoke\u measure\u time

，它将测量作为参数给出的任何其他函数的执行时间。我部分解决了我的问题，我有以下代码：

int sum(int a, int b){
    std::this_thread::sleep_for(std::chrono::milliseconds(5000));
    return a + b;
}

template<typename T>
std::pair<std::chrono::milliseconds, T> invoke_measure_time(std::function<T()> f){
    auto start = std::chrono::system_clock::now();
    auto f_result = f();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - start);

    return std::make_pair(duration, f_result);
}

int main(){
    auto fun = std::bind(sum, 10, 20);
    auto emma = invoke_measure_time<int>(fun);
    std::cout << "time: " << emma.first.count() << ", result = " << emma.second << std::endl;
}

---

或者类似的。如何实现这一点？

简单的解决方案是让

调用\u measure\u time

获取任何可以无参数调用的函数对象（为了简洁起见，我省略了计时内容）：

可以包装到lambda中，该lambda无需参数即可调用：

int main() {
    auto x = invoke_and_measure([](){ return sum(1,2);});
    std::cout << x;
}

intmain（）{
autox=invoke_和_度量（[]（）{返回和（1,2）；}）；
std:：cout简单的解决方案是让
调用\u measure\u time
获取任何可以无参数调用的函数对象（为了简洁起见，我省略了计时内容）：

可以包装到lambda中，该lambda无需参数即可调用：

int main() {
    auto x = invoke_and_measure([](){ return sum(1,2);});
    std::cout << x;
}

intmain（）{
autox=invoke_和_度量（[]（）{返回和（1,2）；}）；
std:：cout如果您将temapte类型改为泛型类型，那么我们可以添加一个可变模板参数来获取函数的参数

template<typename Function, typename... Args>
auto invoke_measure_time(Function f, Args&&... args) {
    auto start = std::chrono::system_clock::now();
    auto f_result = f(std::forward<Args>(args)...);
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - start);

    return std::make_pair(duration, f_result);
}

如果您将temapte类型改为泛型类型，那么我们可以添加一个可变模板参数来获取函数的参数

template<typename Function, typename... Args>
auto invoke_measure_time(Function f, Args&&... args) {
    auto start = std::chrono::system_clock::now();
    auto f_result = f(std::forward<Args>(args)...);
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - start);

    return std::make_pair(duration, f_result);
}

您可以执行以下操作：

template<typename F, typename ... Ts>
auto invoke_measure_time(F&& f, Ts&&... args)
{
    auto start = std::chrono::system_clock::now();
    auto f_result = std::invoke(std::forward<F>(f), std::forward<Ts>(args)...);
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - start);

    return std::make_pair(duration, f_result);
}

模板
自动调用\u度量\u时间（F&&F、Ts&&…参数）
{
自动启动=标准：：时钟：：系统时钟：：现在（）；
自动f_结果=std:：invoke（std:：forward（f），std:：forward（args）…）；
自动持续时间=std:：chrono:：duration\u cast（std:：chrono:：system\u clock:：now（）-start）；
返回std:：make_pair（持续时间、f_结果）；
}


如果
f
返回
无效
有问题，顺便说一句。
您可以执行以下操作：

template<typename F, typename ... Ts>
auto invoke_measure_time(F&& f, Ts&&... args)
{
    auto start = std::chrono::system_clock::now();
    auto f_result = std::invoke(std::forward<F>(f), std::forward<Ts>(args)...);
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - start);

    return std::make_pair(duration, f_result);
}

模板
自动调用\u度量\u时间（F&&F、Ts&&…参数）
{
自动启动=标准：：时钟：：系统时钟：：现在（）；
自动f_结果=std:：invoke（std:：forward（f），std:：forward（args）…）；
自动持续时间=std:：chrono:：duration\u cast（std:：chrono:：system\u clock:：now（）-start）；
返回std:：make_pair（持续时间、f_结果）；
}


案例当
f
return
void
是有问题的，顺便说一句。
你的解决方案很好，你应该感觉很好。非常感谢！你的解决方案很好，你应该感觉很好。非常感谢！你的解决方案确实正是我想要的，但我接受了一个不同的解决方案，因为它比我提出的方法干净得多。很好解决方案！你们的解决方案确实是我想要的，但我接受了一个不同的方案，因为它比我提出的方法要干净得多。尽管是很好的解决方案！
template<typename F, typename ... Ts>
auto invoke_measure_time(F&& f, Ts&&... args)
{
    auto start = std::chrono::system_clock::now();
    auto f_result = std::invoke(std::forward<F>(f), std::forward<Ts>(args)...);
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - start);

    return std::make_pair(duration, f_result);
}