Creating several mutually incompatible numerical types [duplicate]

Answer 1

One approach is a templated class that serves as the one implementation and type aliases of that class for your real types. This could look as follows:

namespace detail {
    template<typename Alias>
    struct Implementation {
        //do everything once
    };
}

using A = detail::Implementation<struct DummyA>;
using B = detail::Implementation<struct DummyB>;
using C = detail::Implementation<struct DummyC>;

As long as each uses a different type as the template argument, each will be a unique type with the same implementation, and the real class can be hidden away in something users shouldn't touch.

Answer 2

Just to consider:

#include <iostream>

template <class T,int tag_num=0>
class base{
  public:
    T val;

    base(T val_arg) : val (val_arg) {}

    base<T,tag_num>& operator+(const base<T,tag_num>& a)
    {
      val += a.val;
      return *this;
    }
};

template <class T,int tag_num>
std::ostream& operator<< (std::ostream& s, const base<T,tag_num>& a)
{
    s << a.val;
    return s;
}

typedef base<long,1> my_type_1;
typedef base<long,2> my_type_2;

int main()
{
   my_type_1 v1(1);
   my_type_1 v2(2);
   my_type_1 res = v1 + v2;
   std::cout << res << std::endl;

   my_type_1 r1 = v1;

   my_type_2 v3(3);
   //my_type_1 r2 = v3; // This is a compilation error
   //my_type_1 res2 = v1 + v3; // This is a compilation error
   //std::cout << res2 << std::endl;
   return 0;
}

Answer 3

A quick way is to define each new type using BOOST_STRONG_TYPEDEF. It will implement the operators for you. Off course this "uses" preprocessor macros, but you don't have to define them. Boost.units implements arithmetic types the template way, but is a bit more involved if you want to define your own system (outside the SI system).

If you want to roll your own template classes then it becomes important to make each instantiation a unique type. There are several ways to do this. One way would be to give the template a second template argument (in addition to the "underlying type") to make instantiations unique. This second template argument could be as simple as an integer:

template< class T, int id>
struct strong_typedef {
    // your operators here
};

But then you'd have to keep an administration of which integers you have been using before (which is difficult if definitions are distributed over different locations).

Alternatively you could introduce a tag type as a second parameter:

template< class T, class Tag>
struct strong_typedef// etc...

struct integerA {};
typedef strong_typedef< long, integerA> MyIntegerAType;

Answer 4

You can consider using class templates if your implementation is same across types. Even you can specialize a template for certain types. Just research the concept and you will know what I am talking about.