Millimeters in boost::units

Question

I want to use boost::units for some SI metrics. However our code mostly deals with millimeters and instead of using

quantity<length> value = 1*milli*meter;

we would prefer something like

quantity<length> value = 1*millimeter;

However I am not sure how to define "millimeter" (without using #define).

Secondly, what is the overhead in using prefixed units?

Update: This needs to run without C++11 features (i.e. no UDL)

Answer 1

I am using the following approach:

// your namespace name for units
namespace outernamespace {
    namespace millimeter_system {
        typedef boost::units::scaled_base_unit<boost::units::si::meter_base_unit, boost::units::scale<10, boost::units::static_rational<-3>>> millimeter_base_unit;

        typedef boost::units::make_system<millimeter_base_unit>::type system;
        typedef boost::units::unit<boost::units::length_dimension, system> length;

        BOOST_UNITS_STATIC_CONSTANT(millimeter, length);
        BOOST_UNITS_STATIC_CONSTANT(millimeters, length);
    }

    typedef boost::units::quantity<millimeter_system::length> quantity_millimeter;
    using millimeter_system::millimeter;
    using millimeter_system::millimeters;
}

// demonstration of usage
void foo() {
    using namespace outernamespace;
    using namespace boost::units;
    using namespace boost::units::si;

    quantity_millimeter mm = 5 * millimeter;
    quantity<boost::units::si::length> m = 0.004 * meter;
    if (mm < static_cast<quantity_millimeter>(m)) {
        std::cout << 'lt ' << std::endl;
    }
    else {
        std::cout << 'geq ' << std::endl;
    }
}

Answer 2

C++11 is indeed the easiest solution. You could do

static const auto millimeter = milli * meter;

or

auto operator"" _mm (long double val) -> decltype(val * milli * meter)
{
     return val * milli * meter;
}

There should be no performance penalty as long as you are not converting to other prefixes. And even if you do it should be neglible.

If you don't want to use C++11 you'd need to find out the corresponding type of the expression milli * meter, though you could just replace auto by int and read the compiler message.

Answer 3

If you have a C++11 capable compiler you could use User Defined Literals for defining your units.

double operator"" _millimeter ( double value )
{
    return value;
}

You can use that like so:

double foo = 1000_millimeter;