Question

I wanted to have a PrintDuration function that prints how long a task took and would allow the user to specify the units in which to print. Example usage:

auto start = std::chrono::system_clock::now();
std::this_thread::sleep_for(std::chrono::seconds(3));
PrintDuration<std::chrono::microseconds>(std::cout, start, "Waited for:");

and it would print something like: "Waited for: 3000000μs\n"

My question is: how to find the units supplied by the user?

At the moment, I am using the following:

template <class T>
std::intmax_t GetNum(const T& duration)
{
    return T::period::num;
}

template <class T>
std::intmax_t GetDen(const T& duration)
{
    return T::period::den;
}


typedef std::chrono::time_point<std::chrono::system_clock> TimePoint_t;

template <class Duration = std::chrono::seconds>
void PrintDuration(std::ostream& output,
                   const TimePoint_t& start,
                   std::string message) 
{
    auto duration = std::chrono::system_clock::now() - start;
    auto convertedDuration = std::chrono::duration_cast<Duration>(duration);
    auto count = convertedDuration.count();

    std::string units("");

    if (GetNum(convertedDuration) == 1)
    {
        if (GetDen(convertedDuration) == std::nano::den)    
            units = "ns";
        else if (GetDen(convertedDuration) == std::micro::den)
            units = "\u03BCs"; // us
        else if (GetDen(convertedDuration) == std::milli::den)
            units = "ms";
        else if (GetDen(convertedDuration) == 1)
            units = "s";
        else
            units = "";
    }
    else if(GetDen(convertedDuration) == 1)
    {
        if (GetNum(convertedDuration) == 60)
            units = "m";
        else if (GetNum(convertedDuration) == 3600)
            units = "h";
        else
            units = "";
    }

    output << message << ' ' << count << units << '.' << std::endl;
}

While that works fine, it seems quite verbose. I looked at the documentation for C++ but couldn’t find it. Any help is greatly appreciated.

Answer 1

You could write it like this:

template <typename T>
const wchar_t* GetUnits(T) { return L"unknown units"; }

template<>
const wchar_t* GetUnits(std::chrono::nanoseconds) { return L"ns"; }

template<>
const wchar_t* GetUnits(std::chrono::microseconds) { return L"\u03BCs"; }

template<>
const wchar_t* GetUnits(std::chrono::milliseconds) { return L"ms"; }

typedef std::chrono::time_point<std::chrono::system_clock> TimePoint_t;

template <class Duration>
void PrintDuration(std::wostream& output, const TimePoint_t& start, const std::wstring& message) 
{
    auto duration = std::chrono::system_clock::now() - start;
    auto convertedDuration = std::chrono::duration_cast<Duration>(duration);

    output << message << L" " << convertedDuration.count() << GetUnits(convertedDuration) << L"." << std::endl;
}

int main(int /*argc*/, char* /*argv*/[])
{
    auto start = std::chrono::system_clock::now();
    std::this_thread::sleep_for(std::chrono::seconds(3));
    PrintDuration<std::chrono::microseconds>(std::wcout, start, L"Waited for:");
    return 0;
}