"Ben" <be**************@zoology.ox.ac.uk> wrote in message
I'm not yet good at thinking the right way in c++ so although I could
solve this problem, I'm not sure if they way I'm thinking of is the best
way to do it. I need a data type or class or something that can hold
either an int, or a float, knows which one it is holding, and will allow
me to do comparisons with instances of it without the code which asks
for the comparison having to know which one it is. So maybe I could do
it something like this (haven't compiled it so there are probably little
errors but hopefully you get the gist):
class Int_or_float {
int i;
float f;
bool is_int;
public:
bool Int_or_float::operator==( Int_or_float &a ) {
if( this->is_int ) return this->i == a.i;
else return this->f == a.f;
}
}
I could do it more simply perhaps like this:
class Int_or_float {
public:
int i;
float f;
bool is_int;
}
bool equal( Int_or_float x, y ) {
if( x.is_int ) return x.i == y.i;
else return x.f == y.f;
}
I realise neither of these will behave well if you compare one storing
an int with one storing a float.
So what are the pros and cons of each method? Is there an even simpler
method? I hoped I might be able to use a union but I can't think how. I
suppose if I want to use the STL I have no choice but to use the first
way?
Thanks in advance,
This is actually a complicated problem. The first way is preferred as it
using private variables and encapsulation. But instead of a flag indicating
the type of an object, one should prefer to use virtual functions. The
standard solution is something like:
class Variable {
public:
virtual ~Variable() = 0;
virtual std::auto_ptr<Variable> clone() const = 0;
};
class Int : public Variable {
public:
Int(int data);
std::auto_ptr<Variable> clone() const;
private:
int d_data;
};
To handle comparing arbitrary types, one can use double dispatch. This is
when a (non-member usually) function is virtual in both its arguments. C++
does not provide native support for this, but you can build it yourself.
Look it up in the books or the internet. Here are the basics:
First, provide 4 operator== functinos, to compare Int to Int, Int to Double,
etc.
Basically you create a 2 by 2 matrix, or map, or whatever.
m["Int"]["Int"] maps to the function compare an Int to Int.
m["Int"]["Double"] maps to the function compare an Int to Double.
When the user calls operator==(variable1, variable2), look up the
appropriate function to call in the matrix map, then call it. If no
function found you throw an exception, or choose your favorite error
handling routine.
The advantage of this approach is that you can add new types, and all you
need is to derive a new class and provide the new equal functions, and store
these in the matrix.
But in your case you might not need double dispatch. Instead you could
provide a function asFloat() in the base variable class.
class Variable {
public:
virtual ~Variable() = 0;
virtual std::auto_ptr<Variable> clone() const = 0;
virtual double asDouble() const = 0;
};
inline
bool operator==(const Variable& lhs, const Variable&) {
return lhs.asDouble() == rhs.asDouble();
}
