#include<iostream>
#include<bitset>
#include<cmath>
#include<climits>
using namespace std;
class Number
{
bool sign_;
int exponent_;
float mantissa_;
public:
Number (char,int,float);
Number (float);
void ConvertFromFloat(const float&);
float ConvertFromNumber() const;
Number operator+=(const Number& toAdd) const
{
return Number(ConvertFromNumber()+toAdd.ConvertFromNumber());
}
Number operator-=(const Number& toAdd)
{
return Number(ConvertFromNumber()-toAdd.ConvertFromNumber());
}
friend ostream &operator<<(ostream &os,const Number &toShow);
};
Number operator+(const Number &toAdd1,const Number &toAdd2)
{
return Number(toAdd1.ConvertFromNumber()+toAdd2.ConvertFromNumber());
}
Number operator-(const Number &toAdd1,const Number &toAdd2)
{
return Number(toAdd1.ConvertFromNumber()-toAdd2.ConvertFromNumber());
}
ostream &operator<<(ostream &os,const Number &toShow)
{
os << toShow.ConvertFromNumber();
return os;
}
float Number::ConvertFromNumber() const
{
int negative=1;
if (sign_==false)
{
negative=0;
}
return pow(-1,negative)*pow(2,exponent_-127)*mantissa_;
}
void Number::ConvertFromFloat(const float& ieee)
{
union
{
float input;
int output;
} data;
data.input=ieee;
std::bitset<sizeof(float) * CHAR_BIT> number(data.output);
for (int i=0;i<32;i++)
{
if (i==0)
{
if (number[31-i]==1)
{
sign_=true;
}
}
else if (i>0 && i<9)
{
if (number[31-i]==1)
{
exponent_+=pow(2,8-i);
}
}
else
{
if (number[31-i]==1)
{
mantissa_+=pow(2,8-i);
}
}
}
}
Number::Number (char sign,int exponent,float mantissa)
: sign_(sign), exponent_(exponent), mantissa_(mantissa)
{
if (sign=='-')
{
sign_=true;
}
if (sign=='+')
{
sign_=false;
}
}
Number::Number (float ieee)
: mantissa_(1), exponent_(0)
{
ConvertFromFloat(ieee);
}
using namespace std;
int main()
{
char sign;
int exponent;
float mantissa;
cin >> sign >> exponent >> mantissa;
Number num1(sign,exponent,mantissa);
cin >> sign >> exponent >> mantissa;
Number num2(sign,exponent,mantissa);
num1 += num2;
}
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