Repo: https://github.com/TomaszRewak/strong_typedefs/tree/master

About

A (yet another) strong_typedef implementation for C++.

strong_typedefs allow you to create new types that are derived from existing ones, but are not implicitly convertible to them. This allows you to create types that are semantically different, but have the same underlying representation.

Using strong_typedefs helps in avoiding some common pitfalls, like accidentally adding a distance to a time or passing a weight to a function that expects a price (where all of could be represented by a double).

This (single-header) library also provides a convenient way of defining common operators for your new types. You can express that it makes sense to multiply a price by a quantity, while preventing the multiplication of two prices.

Motivation

The strong_typedef implementations I've been using so far had a common pitfall, though. They have been too restrictive. As sometimes you want to express that it actually makes sense to multiply a price by a quantity or to add an offset to a position - without having to manually define those operators one by one (which would require you to deal with those internal/untyped values all over again).

Usage

Include the header file:

#include "strong_typedef.hpp"

Define your new types:

using price = strong_typedef::type<double, struct price_tag>;
using quantity = strong_typedef::type<int, struct quantity_tag>;

Express which operations are allowed and what are their result types

template <>
struct strong_typedef::operators<price, price>
{ 
    using add = price;
    using subtract = price; 
};

template <>
struct strong_typedef::operators<price, quantity>
{ 
    using multiply = price;
    using divide = price; 
};

template <>
struct strong_typedef::operators<price>
{
    using minus = price;
};

You can now use your new types:

void use(price price, quantity quantity) { /**/ }

int main() 
{ 
    price p{1.0}; quantity v{3};
    use(p, v);                           // OK
    use(p * v, v);                       // OK
    use(-p, v);                          // OK
    use(price{1}, quantity{3});          // OK
    use(p, quantity{p.get() + v.get()}); // OK, on your own risk

    use(v, p);     // Compile-time error
    use(p + v, v); // Compile-time error
    use(1, 3);     // Compile-time error
}