how to make a simple class that is either an int or a float

[Ben]

Hi all,

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:perator==( 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,

Ben

 

[Siemel Naran]

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:perator==( 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();
}

 

[Dave Vandervies]

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.

There's an easier way to do double dispatch (especially for small sets
of possible types) that avoids having to explicitly determine the type
of objects by having a general method invoked on one class invoke a more
specific method in the other:

--------
class Value
{
public:
/*Return greater than, less than, or equal to 0 depending on whether
other's value is greater than, less than, or equal to ours
*/
virtual int compare(const Value& other) const =0;
protected:
virtual int compareWithInt(int other) const =0;
virtual int compareWithDouble(double other) const =0;
};

class IntValue
{
private:
int myInt;
public:
IntValue(int i):myInt(i) {}
virtual int compare(const Value& other) const
{return -other.compareWithInt(myInt);}
protected:
virtual int compareWithInt(int other) const
{return other<myInt?-1myInt==other?0:1);}
virtual int compareWithDouble(double other) const
{return other<myInt?-1myInt==other?0:1);}
};

class DoubleValue
{
private:
double myDouble;
public:
DoubleValue(int i):myDouble(i) {}
virtual int compare(const Value& other) const
{return -other.compareWithDouble(myDouble);}
protected:
virtual int compareWithInt(int other) const
{return other<myDouble?-1myDouble==other?0:1);}
virtual int compareWithDouble(double other) const
{return other<myDouble?-1myDouble==other?0:1);}
};

--------

(But for your specific problem, the idea upthread of just implementing
asDouble and calling that in the comparison is probably better than
using double dispatch.)


dave

 

[Denis Remezov]

Hi all,

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:perator==( 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?

If you want a minimalistic class and lightweight objects,
here is one sketch:

class Value {
enum Type {
type_int,
type_flt
};

union {
int v_int_;
float v_flt_;
};
int type_;

bool cmp_equal_type(Value const& rhs) const {
bool ret;
switch(type_) {
case type_int:
ret = v_int_ == rhs.v_int_;
break;
case type_flt:
ret = v_flt_ == rhs.v_flt_;
break;
default:
ret = false;//assert() or remove the option
}
return ret;
}

typedef double promote_t; //system-dependent

promote_t get_promoted() const {
promote_t ret;
switch(type_) {
case type_int:
ret = v_int_;
break;
case type_flt:
ret = v_flt_;
break;
default:
ret = 0;//assert() or remove the option
}
return ret;
}

public:
Value(int v) : v_int_(v), type_(type_int) {}
Value(float v) : v_flt_(v), type_(type_flt) {}

bool operator ==(Value const& rhs) const {
return rhs.type_ == type_? cmp_equal_type(rhs) :
(get_promoted() == rhs.get_promoted());
}

//...
};


Denis

 

[JKop]

Denis Remezov posted:

class Value {
enum Type {
type_int,
type_flt
};

union {
int v_int_;
float v_flt_;
};

What's the story with that? You haven't declared any variables/objects.

-JKop

 

[Ben]

Thanks very much for your suggestions folks...

I can just about get my head round the second suggestion. The first
suggestions is making me realise I have plenty more to learn - so I'll try!

Cheers,

Ben

 

[John Harrison]

Denis Remezov posted:



What's the story with that? You haven't declared any variables/objects.

-JKop

It's called an anonymous union, v_int_ and v_flt_ are member variables of
class Value.

john

 

[Siemel Naran]

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.

There's an easier way to do double dispatch (especially for small sets
of possible types) that avoids having to explicitly determine the type
of objects by having a general method invoked on one class invoke a more
specific method in the other:

--------
class Value
{
public:
/*Return greater than, less than, or equal to 0 depending on whether
other's value is greater than, less than, or equal to ours
*/
virtual int compare(const Value& other) const =0;
protected:
virtual int compareWithInt(int other) const =0;
virtual int compareWithDouble(double other) const =0;
};

But this approach still suffers the disadvantage of not being as extensible.
Suppose you want to add a new type like Complex or String. With my proposed
code you just add your classes, new comparison functions, register these in
the double dispatch registry. With your approach we have to change the base
class to add new functions compareWithComplex and compareWithString.

(But for your specific problem, the idea upthread of just implementing
asDouble and calling that in the comparison is probably better than
using double dispatch.)

Right, in certain special cases we don't need the full blown double
dispatch.

Though who knows. There's a case for a special function here. Maybe to
compare two doubles we want to compare for approximatley equal, because two
doubles calculated through different formula may be slightly different
thanks to imperfect floating point math, example (1.0) and (1.0/3)*3.0 are
really both 1 but may be 1.0 and 0.9999* because of floating point math.