What is wrong with the following C++ class? - c++

Question

So, basically I created a Float class to track down the range of floating point values used in the program. I just replace float in my program with Float. However, the output of my program changes when I use this class, but I can't figure out where is the problem.
#define real float
class Float
{
private:
real data;
static real minVal;
static real maxVal;
static void updateMinMax( real x )
{
if ( x < minVal )
minVal = x;
if ( x > maxVal )
maxVal = x;
}
public:
static real getMin()
{
return minVal;
}
static real getMax()
{
return maxVal;
}
Float()
{
data = 0;
}
Float(real x)
{
data = x;
updateMinMax(data);
}
void setFloat( real x )
{
data = x;
updateMinMax(data);
}
void setMaxOf( real x, real y )
{
data = (x > y)? x : y;
updateMinMax(data);
}
void setInt( int x )
{
data = x;
updateMinMax(data);
}
real getFloat() const
{
return data;
}
operator int() const { return (int)data; }
void operator=(Float x)
{
data = x.data;
updateMinMax( data );
}
Float operator+(const Float& x) const
{
updateMinMax( data + x.data );
return Float(data + x.data);
}
void operator+=(Float x)
{
data += x.data;
updateMinMax( data );
}
Float operator-(const Float& x) const
{
updateMinMax( data - x.data );
return Float(data - x.data);
}
Float operator-() const
{
updateMinMax( -data );
return Float(-data);
}
void operator-=(Float x)
{
data -= x.data;
updateMinMax( data );
}
Float operator*(const Float& x) const
{
updateMinMax( data * x.data );
return Float(data * x.data);
}
void operator*=(Float x)
{
data *= x.data;
updateMinMax( data );
}
Float operator/(const Float& x) const
{
updateMinMax( data / x.data );
return Float(data / x.data);
}
void operator/=(Float x)
{
data /= x.data;
updateMinMax( data );
}
bool operator<(const Float& x) const
{
return data < x.data;
}
bool operator<=(const Float& x) const
{
return data <= x.data;
}
bool operator>(const Float& x) const
{
return data > x.data;
}
bool operator>=(const Float& x) const
{
return data >= x.data;
}
bool operator==(const Float& x) const
{
return data == x.data;
}
friend ostream& operator<<(ostream& o, Float& x)
{
o << x.data;
return o;
}
friend istream& operator>>(istream& i, Float& x)
{
i >> x.data;
return i;
}
};

Answer 1

The following test program demonstrates at least one difference between using a float and your Float class:
void test(float x)
{
cout<<"Called with float argument"<<endl;
}
void test(int x)
{
cout<<"Called with int argument"<<endl;
}
int main() {
Float arg1;
float arg2;
test(arg1);
test(arg2);
return 0;
}
Output:
Called with int argument
Called with float argument