Question

When reading <ratio> and <chrono> I tried to imagine a Length-type that protects against accidental conversion errors.

This is what I got:

#include <iostream>
#include <ratio>
using namespace std;

template<typename Scale>
struct Length  {
  long long val_;
  Length(long long val) : val_{val} {}
  Length() = default;
  Length(const Length&) = default;
  Length& operator=(const Length&) = default;
  // conversion
  template<typename Scale2>
  Length(const Length<Scale2> &other)
    : val_{ other.val_*(Scale2::num*Scale::den)/(Scale2::den*Scale::num) }
  { }
  // access
  long long value() const { return val_; }
}; 
typedef Length<ratio<1>> m;
typedef Length<kilo> km;
typedef Length<milli> mm;
typedef Length<ratio<1000,1094>> yard;

To be used like this

int main() {
  km len_km = 300;
  mm len_mm = len_km;
  cout << " millimeter:" << len_mm.value() << endl;
  cout << " m:" << m{len_km}.value() << endl;
  cout << " yd:" << yard{len_km}.value() << endl;
}

And now I could add all the + and * operations to get really comfortable… 🙂

I wonder:

• Is there an easier access to the arithmetic facilities that duration and time_point define in <chrono> anyway? Can I use those reduce the effort for Length?
• The compile-time constant (Scale2::num*Scale::den)/(Scale2::den*Scale::num) seems dangerous in the conversion constructor (fraction/underflow?), but I can not figure a better metaprogramming way, Any hints here?

Answer 1

• Is there an easier access to the
  arithmetic facilities that
  duration and time_point define in
  <chrono> anyway? Can I use those
  reduce the effort for Length?

For “mixed mode” arithmetic and comparisons you can take advantage of common_type<T1, T2>::type for defining return types. duration specializes common_type to be the greatest common divisor of Period1 and Period2, where Period1 and Period2 are the two ratios involved in an arithmetic or comparison operation. You might use it like:

template <typename Scale1, typename Scale2>
  typename std::common_type<Length<Scale1>, Length<Scale2>>::type
  operator+(Length<Scale1> x, Length<Scale2> y);

Unfortunately you’ll have to reinvent how to get the greatest common divisor of two ratios at compile time. Start with compile-time gcd and lcm meta-functions for unsigned long long.

Hmm… or you might be able to base your specialization of common_type on the one already done for duration. You could reinterpret the resultant duration‘s period as a scale factor for your Length. I haven’t prototyped this, just an idea.

• The compile-time constant
  (Scale2::num*Scale::den)/(Scale2::den*Scale::num) seems dangerous in the conversion
  constructor (fraction/underflow?),
  but I can not figure a better
  metaprogramming way, Any hints here?

Agreed. duration handles this with:

template <class Rep2, class Period2>
  constexpr duration(const duration<Rep2, Period2>& d);

Remarks: This constructor shall not
participate in overload resolution
unless treat_as_floating_point<rep>::value is true or both
ratio_divide<Period2, period>::den is
1 and treat_as_floating_point<Rep2>::value is false.
[ Note: This requirement prevents
implicit truncation error when
converting between integral-based
duration types. Such a construction
could easily lead to confusion about
the value of the duration. — end note]

I.e. you need to enable_if your Length conversion constructor such that it only exists if the conversion is exact (if you want to base your length on integral types). For the conversion to be exact, the conversion factor (Scale2::num*Scale::den)/(Scale2::den*Scale::num) must be computable without division (except division by 1). You can use ratio_divide to do this division for you, and then the resulting denominator must be 1 (for an exact conversion).

enable_if<ratio_divide<Scale2, Scale1>::type::den == 1, ...>

This is a great project for learning ratio! Have fun! 🙂