[editar: metros / jardas alterados para foo / bar; não se trata de converter metros em jardas. ]

Qual é a melhor maneira de anexar um tipo a um escalar, como umdouble? O caso de uso típico é a unidade de medida (mas não estou procurando uma implementação real,impulso tem um)

Parece ser simples como:

template <typename T>
struct Double final
{
    typedef T type;
    double value;
};

namespace tags
{
    struct foo final {};
    struct bar final {};
}
constexpr double FOOS_TO_BARS_ = 3.141592654;
inline Double<tags::bar> to_bars(const Double<tags::foo>& foos)
{
    return Double<tags::bar> { foos.value * FOOS_TO_BARS_ };
}

static void test(double value)
{
    using namespace tags;
    const Double<foo> value_in_foos{ value };    
    const Double<bar> value_in_bars = to_bars(value_in_foos);
}

Esse é realmente o caso? Ou existem complexidades ocultas ou outras considerações importantes para essa abordagem?

Isso pareceria longe, muito superior ao

   inline double foos_to_bars(double foos)
   {
      return foos * FOOS_TO_BARS_;
   }

sem adicionar quase nenhuma complexidade ou sobrecarga.