float - long int c++

Derivando tipos diferentes e incomparables de int en C++

Question

Sé que no puedo derivar de un int y ni siquiera es necesario, esa fue solo una (no) solución que vino a mi mente para el problema a continuación.

Tengo un par (foo,bar) los cuales están representados internamente por un int pero quiero que typeof(foo) sea ​​incomparable con typeof(bar) . Esto es principalmente para evitar que pase (foo,bar) a una función que espera (bar, foo) . Si lo comprendo correctamente, typedef no lo hará, ya que solo es un alias. ¿Cuál sería la forma más fácil de hacer esto? Si tuviera que crear dos clases diferentes para foo y bar , sería tedioso proporcionar explícitamente todos los operadores admitidos por int . Quiero evitar eso.

Answer 1

Como alternativa a escribirlo usted mismo, puede usar la macro BOOST_STRONG_TYPEDEF disponible en el encabezado boost/strong_typedef.hpp .

// 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.

Entonces, por ejemplo

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

Answer 2

Tienes razón, que no puedes hacerlo con typedef . Sin embargo, puede envolverlos en un par struct-enum o int encapsulado dentro de 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 solución :

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

Answer 3

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
}