Question

What I’m trying to do is create a new custom data type that behaves like all other primitive types. Specifically, this data type appears like a Fixed Point fraction.
I’ve created a class to represent this data type, called “class FixedPoint”, and in it there are ways to typecast from “FixedPoint” to “int” or “double” or “unsigned int”, etc. That is fine.

Now, what if I want to cast from "int" to "FixedPoint"? Originally my solution was to have a constructor:

FixedPoint(int i) { /* some conversion from 'int' to 'FixedPoint' in here */ }

This works…but you cannot put it into a union like so:

 union {
   FixedPoint p;
 };

This will break, because “FixedPoint” does not have an implicit trivial constructor (we just defined a constructor, “FixedPoint(int i)”).

To summarize, the whole issue is “we want to cast from some type T to type FixedPoint without explicitly defining a constructor so we can use our type FixedPoint in a union”.

What I think the solution is but cannot find any evidence online:
Define an overloaded global typecast operator to cast from “int” to “FixedPoint”.

Is there a way to do this without using class constructors? I’d like to be able to use this class in a union. What I’ve tried (in global scope):

operator (FixedPoint f, int a) { ... } //compiler complains about this is not a method or non-static.

And a little example to show unions don’t like constructors (they like POD)

class bob
{
  public:
    bob(int a) { m_num = a; }
  private:
    int m_num;
};
void duck()
{
  union 
  {
    bob a;
  };
}

This error seen in Visual Studio is:

error C2620: member 'duck::<unnamed-tag>::a' of union 'duck::<unnamed-tag>' has user-defined constructor or non-trivial default constructor

Any ideas?
Thanks

Answer 1

I am having a hard time at seeing what you would try to use this for. It seems smelly to have to constantly ensure that sizeof(FixedPoint) == sizeof(int) and, assuming that, there are other hidden gotchas, like endianness. Maybe I should back up a little bit here, unions only “convert” a value from one type to another in that it takes a chunk of memory and references it as a different type. i.e.

union BadConverter
{
    int integer;
    double fraction;
};

BadConverter.fraction = 100.0/33.0;
BadConverter.integer = ?;

I am pretty sure integer is not going to be 3, it is going to whatever the memory chunk of the double is that the integer bytes share with it.

Unions don’t seem to be a very good fit for this sort of thing. I would think just defining a bunch of assignment operators from all the primitive types. i.e.

class FixedPoint
{
    FixedPoint& operator=(int value);
    FixedPoint& operator=(double value);
    ..etc..
    //Maybe something like this?
    template<typename T>
    FixedPoint& operator=(const T& value)
    {
        value = boost::lexical_cast<int>(value);
        return *this;
    }
}