C++ conversion operator to chrono::duration - works with c++17 but not C++14 or less

Question

The following code compiles with gcc 7.1.0 with C++17 set but does not compile with C++14 set (or Visual Studio 2017). It is easy to reproduce on Wandbox.

What has to be done to make it work with C++11/14?

#include <iostream>
#include <chrono>

int main()
{
    struct Convert
    {
        operator std::chrono::milliseconds()
        {
            std::cout << "operator std::chrono::milliseconds" << std::endl;
            return std::chrono::milliseconds(10);
        }

        operator int64_t ()
        {
            std::cout << "operator int64_t" << std::endl;
            return 5;
        }
    };

    Convert convert;

    std::chrono::milliseconds m(convert);
    std::cout << m.count() << std::endl;
    int64_t i(convert);
    std::cout << i << std::endl;
}

Answer 1

Let's start with why this doesn't work in C++14. There are two relevant c'tors for std::chrono::duration (which std::chrono::milliseconds is aliased to be):

duration( const duration& ) = default;

template< class Rep2 >
constexpr explicit duration( const Rep2& r );

The templated one is a much better match for an argument of type Convert. But it will only participate in overload resolution if Rep2 (a.k.a Convert) is implicitly convertible to the representation type of std::chrono::duration. For milliseconds, that is long on Wandbox. Your int64_t conversion operator makes that implicit conversion possible.

But here's the catch. The check for this implicit conversion doesn't take the cv-qualifiers of the conversion member function into account. So that overload is chosen, but it accepts by a const reference. And your user defined conversion operator is not const qualified! @Galik noted it in the comments to your post. As such, the conversion fails inside the c'tor of milliseconds.

So how to resolve it? Two ways:

1. Mark the conversion operator const. That will however pick the conversion to int64_t for both m and i.

2. Mark the conversion to int64_t as explicit. Now the templated overload won't participate in overload resolution for m.

And finally, why does this work in C++17? That would be guaranteed copy elision. Since your Convert has a conversion to std::chrono::milliseconds, it is used to initialized m directly. The minutia of it involves not even needing to choose the copy constructor, just to elide it later.