c++ - 尝试构建包装器测量函数调用时间的问题

Question

我正在实现一些数据结构，每个数据结构都支持一组命令，例如INSERT value.

我使用了一个标记器来生成一个包含每个单词/值的向量。

我希望能够将每个函数调用所花费的时间输出到 .txt 文件，加上函数返回的内容（如果它确实返回了某些内容）。

例如，如果命令是INSERT AVLTREE 4，我只想输出调用所avl.insert(4)花费的时间。如果命令是SEARCH AVLTREE 4，我想输出调用所avl.search(4)花费的时间，以及它的结果（例如"SUCCESS"或"FAILURE"）。

以下代码可能有很多问题，但这是我想出的：

我制作了两个文件（.cpp/.hpp），其中包含以下自破解函数包装器，以及一个变体和一个结构：

// WRAPPER CPP
// file: wrap.cpp


#include "wrap.hpp"


#include <chrono>
#include <string>
#include <utility>

#include <boost/variant.hpp>


using std::chrono::high_resolution_clock;
using std::chrono::time_point;
using std::chrono::nanoseconds;

using std::string;
using std::to_string;

using std::forward;

using boost::get;
using boost::static_visitor;
using boost::apply_visitor;


// I'm overloading std::to_string, so it works on std::strings as well.
string to_string(const string &value)
{
    return value;
}

// I want to apply to_string on whatever is inside my variant.
class to_string_visitor : public static_visitor<>
{
    public:
        template <typename T>
        void operator()(T & operand) const
        {
            to_string(operand);
        }
};

// Takes two points in time and returns the time 
// between them in nanoseconds.
const nanoseconds::rep duration(const nanoseconds tpoints_difference) noexcept
{
    const auto result = tpoints_difference.count();
    return result;
}

// Generates a point in time.
const high_resolution_clock::time_point timeNow(void) noexcept
{
    const auto result = high_resolution_clock::now();
    return result;
}

// Here's where's the problematic magic happens:
// The ret boolean is set to true if the function F returns a value,
// otherwise, it is set to false.
//
// Variadic arguments are being taken and then std::forwarded to F.
template<typename F, typename... Args>
const output wrapper(bool ret, F function, Args&&... args) noexcept
{
        // Generate a point in time, t1.
    const high_resolution_clock::time_point t1 = timeNow();

        // If F returns a result,
    if (ret == true)
    {
                // assign it to result (my variant).
        result = function(forward<Args>(args)...);
    }
    else
    {
                // just call F with Args forwarded.
        function(forward<Args>(args)...);
    }

        // Generate another point in time, t2 and
        // count the difference between t2 - t1.
    const auto elapsed = duration(timeNow() - t1);

        // Make whatever is inside result a string
        // using std::to_string.
    apply_visitor(to_string_visitor(), result);

        // My struct
    output out;

        // which contains the time elapsed and
        // the result returned
    out.time = elapsed;
    out.result = get<string>(result);

        // I can theoretically use both time elapsed and
        // result returned however I want. Hooray!..almost:(
    return out;
}

这是变体result：

// These are all the types a data structure function may return.
variant<int, unsigned, uint32_t, size_t, graph_size, string> result = 0;

graph_size，仅供参考：

struct graph_size
{
    unsigned vertices; //Number of vertices that the Graph currently contains
    unsigned edges;    //Number of edges that the Graph currently contains
};

最后，output结构：

typedef struct output
{
    double time;          // function call time
    string result;        // what function returned

        // notice that if function returned nothing,
        // result will be an empty string.
    output() : time(0), result("") {}
} output;

我正在尝试wrapper像这样使用：

AVL avl;
// stuff
auto out = wrapper(true, avl.insert, 4);

我收到以下错误：

invalid use of non-static member function 'void AVL::insert(int)'

这是一个奖励，它应该暗示我对我的拙劣但不能完全理解它：

no matching function for call to 'wrapper(bool, <unresolved overloaded function type>, unsigned int&)'

有什么想法吗？

我感谢所有提前花费的时间:)

编辑1：问题标题可能不太合适，如果你有好的想法，我会很高兴地改变

标签： c++templateswrappervariantvariadic

Answer 1

由于您需要根据返回类型的不同行为，您可以使用专业化/SFINAE，例如：

template<typename F, typename... Args>
auto wrapper(F function, Args&&... args) noexcept
-> std::enable_if_t<std::is_same<void, std::invoke_result_t<F, Args&&...>>::value, output>
{
    const high_resolution_clock::time_point t1 = timeNow();
    function(forward<Args>(args)...);
    const auto elapsed = duration(timeNow() - t1);

    output out;
    out.time = elapsed;
    out.result = ""; // void return
    return out;
}

template<typename F, typename... Args>
auto wrapper(F function, Args&&... args) noexcept
-> std::enable_if_t<!std::is_same<void, std::invoke_result_t<F, Args&&...>>::value, output>
{
    const high_resolution_clock::time_point t1 = timeNow();
    auto result = function(forward<Args>(args)...);
    const auto elapsed = duration(timeNow() - t1);

    output out;
    out.time = elapsed;
    out.result = to_string(result);
    return out;
}

可能的用法：

AVL avl;

auto out = wrapper([&](){ return avl.insert(4);});