Perfect forwarding for void and non-void returning functions

c++, c++11, overloading, rvalue-reference

Solution

The problem is that default template arguments don't make for different templates, the same way that default function arguments don't make for different overloads. There are some ways around this, and I described them in my Remastered enable_if article.

However, I would not do that. I would simply take advantage of the fact that in generic code you can "`return` void", and use RAII to print out the elapsed time:

template <typename Functor, typename ... Args>
auto measure(Functor f, Args && ... args)
    -> decltype(f(std::forward<Args>(args)...))
{
    scoped_timer timer;
    return f(std::forward<Args>(args)...);
}

The `scoped_timer` class can be written trivially: save `now` in the constructor, and compute and output `elapsed` in the destructor.

Problem

Previously I was using a macro to measure the time a function call took whenever I wanted to quickly check that. Now, with C++11 available, I would like to finally remove that ugly peace of preprocessor code and replace it with something like this: ``` template <typename Functor, typename ... Args> auto measure(Functor f, Args && ... args) -> decltype(f(std::forward<Args>(args)...)) { auto now = std::chrono::high_resolution_clock::now(); auto ret = f(std::forward<Args>(args)...); auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>( std::chrono::high_resolution_clock::now() - now).count(); std::cout << "Time elapsed: " << elapsed << "ms" << std::endl; return ret; } ``` Which works fine for functions that return something (i.e. not `void`). So I felt like I needed an overload for `void` functions - but you cannot overload a function just on return type. I tried to walk around this problem using some template magic, but to no avail; the compiler still complains that the function `measure` is defined two times: ``` template < typename Functor, typename ... Args, typename ReturnType = typename std::enable_if< !std::is_void< typename std::result_of<Functor(Args...)>::type >::value, typename std::result_of<Functor(Args...)>::type >::type > ReturnType measure(Functor f, Args && ... args) { auto now = std::chrono::high_resolution_clock::now(); auto ret = f(std::forward<Args>(args)...); auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>( std::chrono::high_resolution_clock::now() - now).count(); std::cout << "Time elapsed: " << elapsed << "ms" << std::endl; return ret; } template < typename Functor, typename ... Args, typename ReturnType = typename std::enable_if< std::is_void< typename std::result_of<Functor(Args...)>::type >::value >::type > ReturnType measure(Functor f, Args && ... args) { auto now = std::chrono::high_resolution_clock::now(); f(std::forward<Args>(args)...); auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>( std::chrono::high_resolution_clock::now() - now).count(); std::cout << "Time elapsed: " << elapsed << "ms" << std::endl; } ``` Is there a way around this? UPDATE Here is the function I am now using thanks to R. Martinho Fernandes: ``` template <typename Functor, typename ... Args> auto measure(Functor f, Args && ... args) -> decltype(f(std::forward<Args>(args)...)) { struct scoped_timer { scoped_timer() : now_(std::chrono::high_resolution_clock::now()) {} ~scoped_timer() { auto elapsed = std::chrono::duration_cast< std::chrono::milliseconds >(std::chrono::high_resolution_clock::now() - now_).count(); std::cout << "Time elapsed: " << elapsed << "ms" << std::endl; } private: std::chrono::high_resolution_clock::time_point const now_; } scoped_timer; return f(std::forward<Args>(args)...); } ```

Original source