Deriving different and incomparable types from int in C++

I know I cannot derive from an int an开发者_如何学Cd it is not even necessary, that was just one (non)solution that came to my mind for the problem below.

I have a pair (foo,bar) both of which are represented internally by an int but I want the typeof(foo) to be incomparable with the typeof(bar). This is mainly to prevent me from passing (foo,bar) to a function that expects (bar, foo). If I understand it correctly, typedef will not do this as it is only an alias. What would be the easiest way to do this. If I were to create two different classes for foo and bar it would be tedious to explicitly provide all the operators supported by int. I want to avoid that.

---

As an alternative to writing it yourself, you can use BOOST_STRONG_TYPEDEF macro available in boost/strong_typedef.hpp header.

// macro used to implement a strong typedef.  strong typedef
// guarentees that two types are distinguised even though the
// share the same underlying implementation.  typedef does not create
// a new type.  BOOST_STRONG_TYPEDEF(T, D) creates a new type named D
// that operates as a type T.

So, e.g.

BOOST_STRONG_TYPEDEF(int, foo)
BOOST_STRONG_TYPEDEF(int, bar)

---

template <class Tag>
class Int
{
   int i;
   public:
   Int(int i):i(i){}                //implicit conversion from int
   int value() const {return i;}
   operator int() const {return i;} //implicit convertion to int
};

class foo_tag{};
class bar_tag{};

typedef Int<foo_tag> Foo;
typedef Int<bar_tag> Bar;

void f(Foo x, Bar y) {...}
int main()
{
   Foo x = 4;
   Bar y = 10;
   f(x, y); // OK
   f(y, x); // Error
}

---

You are correct, that you cannot do it with typedef. However, you can wrap them in a struct-enum pair or int encapsuled inside struct.

template<int N>
struct StrongType {  // pseudo code
  int i;
  StrongType () {}
  StrongType (const int i_) : i(i_) {}
  operator int& () { return i; }
  StrongType& operator = (const int i_) {
    i = i_;
    return *this;
  }
  //...
};

typedef StrongType<1> foo;
typedef StrontType<2> bar;

C++0x solution:

enum class foo {};
enum class bar {};