大整数计算类（浮点类未完成）

#include<iostream>
#include<list>
#include<string>
#include<cstdio>
#include<cctype>
#include<cmath>
using namespace std;
/*****************************************************************************
*类名称：InterCalc
*类描述：大整数计算 可以和基本类型运算
*类功能：+,-,>,<,=,>=,<=,==,*,/,*=,/=,+=,-=,++,--和正负号;
*可以实现和能自动转换成long long类型的基本数据运算 左操作数必须为大整数类型
*类参考：算法来源于网络加以修正BUG
*编写人：十二年 710055071
*编写时间：2015-03-25至2015-03-31
******************************************************************************/
class FloatCalc; //向前声明
class InterCalc{
list<char> num;										      //存储大整数的变量
friend void buwei(InterCalc& left,InterCalc& right);	  //对齐两个大整数的位数 声明友元  非成员函数
//void buwei(InterCalc& Left,InterCalc& Right);
friend void xsbuwei(FloatCalc& Left,FloatCalc& Right);
public:
//构造函数 注：去空位输入 除去前面多余的零  省略第一个点以后的数据
//用string类型初始化 大整数对象
InterCalc( const    string& Input );
InterCalc( const InterCalc& Input );    				  //复制构造函数
InterCalc( const long long Input ); 					  //用long long 类型初始化
InterCalc(){}											  //默认构造函数
friend class FloatCalc;									  //声明为友元  FloatCalc 类中可以访问 InterCalc 私有成员
void Print() const;										  //去空位输出输出数据
friend ostream& operator<<(ostream& out,const InterCalc& Output);//输出
friend istream& operator>>(istream& cin,const InterCalc& Input);//输入
bool iszero() const;									  //判断大整数是否为零

bool operator>( const InterCalc& Right ) const;			  //大于操作符
bool operator<( const InterCalc& Right ) const;			  //小于操作符
bool operator>=(const InterCalc& Right ) const;			  //大于等于操作符
bool operator<=(const InterCalc& Right ) const;			  //小于等于操作符
bool operator==(const InterCalc& Right ) const;			  //判断数值是否相等
const InterCalc& operator+() const;					 	  //
const InterCalc& operator-();							  //
const InterCalc& operator++();							  //前置操作
const InterCalc  operator++(int);					 	  //后置操作
const InterCalc& operator--();							  //
const InterCalc  operator--(int);						  //
const InterCalc operator+( const InterCalc& Right ) const;//加法运算
const InterCalc operator-( const InterCalc& Right ) const;//除法运算
const InterCalc operator*( const InterCalc& Right ) const;//乘法运算
const InterCalc operator/( const InterCalc& Right ) const;//除法运算
const InterCalc operator%( const InterCalc& Right ) const;//求余运算
//实际上 有的是在函数内部进行了传值操作
const InterCalc& operator= ( const InterCalc& Right );	  //赋值操作符  注意 没做自身赋值的检查
const InterCalc& operator+=( const InterCalc& Right );	  // += 运算
const InterCalc& operator-=( const InterCalc& Right );	  // -= 运算
const InterCalc& operator*=( const InterCalc& Right );	  // *= 运算
const InterCalc& operator/=( const InterCalc& Right );	  // /= 运算
};
istream& operator>>(istream& cin,InterCalc& Input)
{
string str;
cin>>str;
Input=str;
return cin;
}
ostream& operator<<(ostream& out,const InterCalc& Output)
{
if(Output.iszero())
{
cout<<0;
}
else
{
list<char>::const_iterator iter=Output.num.begin();
if(*iter=='-'){ cout<<*iter++; }
while(*iter=='0')
{
++iter;
}
for(;iter!=Output.num.end();++iter)
{
cout<<*iter;
}
}
return out;
}
InterCalc::InterCalc(const long long Input )
{
long long input=Input;
int flag=0;
if(input<0)
{
flag=1;
input=-input;
}
while(input/10!=0)
{
num.push_front(input%10+'0');
input/=10;
}
num.push_front(input+'0');
if(flag)
num.push_front('-');
}
InterCalc::InterCalc( const InterCalc& Input )//复制构造函数
{
num = Input.num;
}
InterCalc::InterCalc( const string& Input ) //使用字符串初始化
{
int err=0,i=0,sign=0;
if(Input[0]=='+') ++i;
if(Input[0]=='-')
{
sign=1;
++i;
}
while(Input[i]=='0')
++i;
for(; i<Input.length() ; ++i )
{
if(Input[i]!='.')
{
if(Input[i] >= '0' && Input[i] <= '9' )
{
num.push_back( Input[i] );
}
else
{
cout<<i+1<<"位输入数据有误"<<endl;
err+=1;
}
}
else
{
break;
}
}
if(sign)
num.push_front('-');
if(err)
{
cout<<"一共有"<<err<<"处错误"<<endl;
cout<<"请忽略结果重新输入数据"<<endl;
num.clear();
//num.push_front('0');
}
}
void InterCalc::Print() const//打印自己
{
/*if(this->iszero())
{
cout<<0;
}
else
{
list<char>::const_iterator iter=num.begin();
if(*iter=='-'){ cout<<*iter++; }
while(*iter=='0')
{
++iter;
}
for(;iter!=num.end();++iter)
{
cout<<*iter;
}
}*/
//cout<<endl;
list<char>::const_iterator iter=num.begin();
for(;iter!=num.end();++iter)
cout<<*iter;
}
bool InterCalc::iszero() const
{
list<char>::const_iterator iter=num.begin();
int flag=1;
if(*iter=='-'||*iter=='+'){ *iter++; }
for(;iter!=num.end();++iter)
{
if(*iter=='0'&&flag)
{
continue;
}
else
{
flag=0;
return false;
}
}
if(flag==1)
{
return true;
}
}
void buwei(InterCalc& Left,InterCalc& Right)//补齐两个大整数的位数  非成员函数 类内部声明为友元 才能访问私有数据
//void InterCalc::buwei(InterCalc& Left,InterCalc& Right)
{
int len1,len2;
len1=Left.num.size();
len2=Right.num.size();
if( len1 >= len2 )
{
for(int i=0 ; i<len1-len2 ; ++i )
Right.num.push_front('0');
}
else
{
for(int i=0 ; i<len2-len1 ; ++i)
Left.num.push_front('0');
}
}
const InterCalc& InterCalc::operator+() const
{
return *this;
}
const InterCalc& InterCalc::operator-()
{
*(this->num.begin())=='-'? this->num.pop_front():this->num.push_front('-');
return *this;
}
const InterCalc& InterCalc::operator++()
{
return (*this)+=1;//s 自动发生了转换成InterCalc 因为有string 参数的构造函数
}
const InterCalc InterCalc::operator++(int)
{
InterCalc ans(*this);
(*this)+=1;
return ans;
}
const InterCalc& InterCalc::operator--()
{
return (*this)-=1;
}
const InterCalc InterCalc::operator--(int)
{
InterCalc ans(*this);
(*this)-=1;
return ans;
}
const InterCalc& InterCalc::operator=( const InterCalc& Right )//赋值操作符重载
{
num = Right.num;
return *this;
}
bool InterCalc::operator>(const InterCalc& Right ) const
{
InterCalc left(*this);
InterCalc right(Right);
list<char>::iterator iter1,iter2;
iter1=left.num.begin();
iter2=right.num.begin();
if( (*iter1) == '-' && (*iter2) == '-')//如果两个数都是负数
{
left.num.pop_front();
right.num.pop_front();
buwei(left,right);//定义成成员函数式 必须left right 调用 不能用this
return !(left.num>=right.num);
}
else if( (*iter1) == '-' && (*iter2) != '-')//如果一个是负数 一个是正数
{
return false;
}
else if( (*iter1) != '-' && (*iter2) == '-')//如果一个是正数 一个是负数
{
return left.iszero() &&right.iszero()?false:true;
}
else//两个正数
{
buwei(left,right);
return left.num>right.num;
}
}
bool InterCalc::operator<(const InterCalc& Right ) const
{
InterCalc left(*this);
InterCalc right(Right);
list<char>::iterator iter1,iter2;
iter1=left.num.begin();
iter2=right.num.begin();
if( (*iter1) == '-' && (*iter2) == '-')//如果两个数都是负数
{
left.num.pop_front();
right.num.pop_front();
buwei(left,right);
return !(left.num<=right.num);
}
else if( (*iter1) == '-' && (*iter2) != '-')//如果一个是负数 一个是正数
{
return left.iszero() &&right.iszero()?false:true;
}
else if( (*iter1) != '-' && (*iter2) == '-')//如果一个是正数 一个是负数
{
return false;
}
else//两个正数
{
buwei(left,right);
return left.num<right.num;
}
}
bool InterCalc::operator>=(const InterCalc& Right ) const
{
InterCalc left(*this);
InterCalc right(Right);
list<char>::iterator iter1,iter2;
iter1=left.num.begin();
iter2=right.num.begin();
if( (*iter1) == '-' && (*iter2) == '-')//如果两个数都是负数
{
left.num.pop_front();
right.num.pop_front();
buwei(left,right);
return !(left.num>right.num);
}
else if( (*iter1) == '-' && (*iter2) != '-')//如果一个是负数 一个是正数
{

return left.iszero() &&right.iszero()?true:false;
}
else if( (*iter1) != '-' && (*iter2) == '-')//如果一个是正数 一个是负数
{
return true;
}
else//两个正数
{
buwei(left,right);
return left.num>=right.num;
}
}
bool InterCalc::operator<=(const InterCalc& Right ) const
{
InterCal
f202
c left(*this);
InterCalc right(Right);
list<char>::iterator iter1,iter2;
iter1=left.num.begin();
iter2=right.num.begin();
if( (*iter1) == '-' && (*iter2) == '-')//如果两个数都是负数
{
left.num.pop_front();
right.num.pop_front();
buwei(left,right);
return !(left.num<right.num);
}
else if( (*iter1) == '-' && (*iter2) != '-')//如果一个是负数 一个是正数
{
return true;
}
else if( (*iter1) != '-' && (*iter2) == '-')//如果一个是正数 一个是负数
{
return left.iszero() &&right.iszero()?true:false;
}
else//两个正数
{
buwei(left,right);
return left.num<=right.num;
}
}
bool InterCalc::operator==(const InterCalc& Right )	const
{
InterCalc left(*this),right(Right);
list<char>::iterator iter1,iter2;
iter1=left.num.begin();
iter2=right.num.begin();
if( (*iter1) == '-' && (*iter2) == '-')//如果两个数都是负数
{
left.num.pop_front();
right.num.pop_front();
buwei(left,right);
return left.num==right.num;
}
else if( (*iter1) == '-' && (*iter2) != '-')//如果一个是负数 一个是正数
{
return left.iszero() &&right.iszero()?true:false;
}
else if( (*iter1) != '-' && (*iter2) == '-')//如果一个是正数 一个是负数
{
return left.iszero() &&right.iszero()?true:false;
}
else//两个正数
{
buwei(left,right);
return left.num==right.num;
}
}
const InterCalc InterCalc::operator+( const InterCalc& Right ) const
{
InterCalc ans;
InterCalc left(*this);
InterCalc right(Right);
if(left.iszero()&&right.iszero())
{
return ans;
}
list<char>::iterator iter1;
list<char>::const_iterator iter2;
iter1 = left.num.begin();
iter2 = right.num.begin();
int sign = 0;
if( (*iter1) == '-' && (*iter2) == '-')//如果两个数都是负数
{
left.num.pop_front();
right.num.pop_front();
sign=1;//标记结果符号 1表示负数
ans=left+right;
ans.num.push_front('-');
}
else if( (*iter1) == '-' && (*iter2) != '-')//如果一个是负数 一个是正数
{
left.num.pop_front();
ans=right-left;
}
else if( (*iter1) != '-' && (*iter2) == '-')//如果一个是正数 一个是负数
{
right.num.pop_front();
ans=left-right;
}
else								//如果都为正
{
buwei(left,right);
int carry=0,i;
iter1 = left.num.end();
iter2 = right.num.end();
--iter1;
--iter2;
for( ; (iter1 != left.num.begin()) && (iter2 != right.num.begin()) ; --iter1,--iter2 )
{
i=(*iter1-'0')+(*iter2-'0')+carry;
ans.num.push_front((i%10)+'0');
carry=i/10;
}
i=(*iter1-'0')+(*iter2-'0')+carry;
ans.num.push_front((i%10)+'0');
carry=i/10;
if( carry )
{
ans.num.push_front(carry+'0');
}
}
return ans;
}
const InterCalc InterCalc::operator-( const InterCalc& Right ) const
{
InterCalc ans;
InterCalc left(*this);
InterCalc right(Right);
int sign=0;
list<char>::iterator iter1,iter2;
list<char>::iterator iterb1,iterb2;
int len1,len2;
iter1 = left.num.begin();
iter2 = right.num.begin();
if( (*iter1) == '-' && (*iter2) == '-')//两个负数
{
left.num.pop_front();
right.num.pop_front();
ans=right-left;
}
else if( (*iter1) == '-' && (*iter2) != '-' )//一负一正
{
left.num.pop_front();
ans=left+right;
ans.num.push_front('-');
}
else if( (*iter1) != '-' && (*iter2) == '-' )//一正一负
{
right.num.pop_front();
ans=left+right;
}
else
{
buwei(left,right);
int carry=0,i;
//需要判断大小
if(left>=right)
{
iter1 =left.num.end();
iterb1=left.num.begin();
iter2 =right.num.end();
iterb2=right.num.begin();
}
else
{
iter2 =left.num.end();
iterb2=left.num.begin();
iter1 =right.num.end();
iterb1=right.num.begin();
sign=1;
}
--iter1;
--iter2;
//上面交换迭代器时 下面如果不交换判断 造成不同容器迭代器的比较  时间长了 耗尽资源 电脑卡死
//算不算病毒的一种啊
for( ; ( iter1 != iterb1 ) && ( iter2 != iterb2 ); --iter1,--iter2 )
{
i=(*iter1-'0'-carry)-(*iter2-'0');
carry=0;
if(i<0)
{
i += 10;
carry = 1;
}
ans.num.push_front((i%10)+'0');
}
i=(*iter1-'0'-carry)-(*iter2-'0');
if(i) ans.num.push_front(i+'0');
if(sign) ans.num.push_front('-');
}
return  ans;
}
const InterCalc& InterCalc::operator+=( const InterCalc& Right )
{
return *this=*this+Right;
}
const InterCalc& InterCalc::operator-=( const InterCalc& Right )
{
return *this=*this-Right;
}
const InterCalc InterCalc::operator*( const InterCalc& Right) const //乘法
{
InterCalc left(*this),right(Right),ans;
int sign=0;
int len1,len2,len;
list<char>::iterator iter1,iter2,iter;
InterCalc high,low;
InterCalc anshigh,anslow;
int th,tl;
int i,j,k;
if(left.num.size()==1&&right.num.size()==1)
{
th=*(left.num.begin())-'0';
tl=*(right.num.begin())-'0';
th*=tl;
ans.num.push_front(th%10+'0');
ans.num.push_front(th/10+'0');
return ans;
}
else if(left.num.size()==1&&right.num.size()>1)
{
if(*(right.num.begin())=='-')
{
sign=1;
right.num.pop_front();
}
len2=right.num.size();
if(len2==1)
{
ans=left*right;
if(sign)
ans.num.push_front('-');
}
else
{
for(iter=right.num.begin(),i=0;i<len2/2;++i,++iter)
{
high.num.push_back(*iter);
}
for( ;iter!=right.num.end();++iter)
{
low.num.push_back(*iter);
}
len=low.num.size();
anshigh=left*high;
anslow=left*low;
for(i=0;i<len;++i)
anshigh.num.push_back('0');
ans=anshigh+anslow;
if(sign)
ans.num.push_front('-');
}
return ans;
}
else if(right.num.size()==1&&left.num.size()>1)
{
if(*(left.num.begin())=='-')
{
sign=1;
left.num.pop_front();
}
len2=left.num.size();
if(len2==1)
{
ans=left*right;
if(sign)
ans.num.push_front('-');
}
else
{
for(iter=left.num.begin(),i=0;i<len2/2;++i,++iter)
{
high.num.push_back(*iter);
}
for( ;iter!=left.num.end();++iter)
{
low.num.push_back(*iter);
}
len=low.num.size();
anshigh=right*high;
anslow=right*low;
for(i=0;i<len;++i)
anshigh.num.push_back('0');
ans=anshigh+anslow;
if(sign)
ans.num.push_front('-');
}
return ans;
}
else
{
InterCalc lefthigh,leftlow,righthigh,rightlow;
int flag1=0,flag2=0;
if(*(left.num.begin())=='-')
{
flag1=1;
left.num.pop_front();
}
if(*(right.num.begin())=='-')
{
flag2=1;
right.num.pop_front();
}
if((flag1==1&&flag2==0)||(flag1==0&&flag2==1))
{
sign=1;
}
len1=left.num.size();
len2=right.num.size();
if(len1==1||len2==1)
{
ans=left*right;
if(sign)
ans.num.push_front('-');
}
else
{
for(iter=left.num.begin(),i=0;i<len1/2;++iter,++i)
lefthigh.num.push_back(*iter);
for( ; iter!=left.num.end();++iter)
leftlow.num.push_back(*iter);
for(iter=right.num.begin(),i=0;i<len2/2;++iter,++i)
righthigh.num.push_back(*iter);
for( ; iter!=right.num.end();++iter)
rightlow.num.push_back(*iter);
int a=(len1+1)/2;
int b=(len2+1)/2;
InterCalc AC,AD,BC,BD;
AC=lefthigh*righthigh;
AD=lefthigh*rightlow;
BC=leftlow*righthigh;
BD=leftlow*rightlow;
for(i=0;i<a+b;++i)
AC.num.push_back('0');
for(i=0;i<a;++i)
AD.num.push_back('0');
for(i=0;i<b;++i)
BC.num.push_back('0');
ans=AC+AD;
ans=ans+BC;
ans=ans+BD;
while(*ans.num.begin()=='0')
{
ans.num.pop_front();
}
if(sign)
ans.num.push_front('-');
}
return ans;
}
}
const InterCalc InterCalc::operator/( const InterCalc& Right) const//除法
{
InterCalc left(*this),right(Right);
//先判断 除数与被除数为零的情况
if(right.iszero())
{
cout<<"除数不能为零！！！"<<endl;
cout<<"请遵守规则哦！！！"<<endl;
return InterCalc();
}
InterCalc ans,temp;
int len1,len2,len;
int i,j,k;
int sign=0;
int flag1=0,flag2=0;
list<char>::iterator iter;
if(*(left.num.begin())=='-')
{
flag1=1;
left.num.pop_front();
}
if(*(right.num.begin())=='-')
{
flag2=1;
right.num.pop_front();
}
if((flag1==1&&flag2==0)||(flag1==0&&flag2==1))
sign=1;
len1=left.num.size();
len2=right.num.size();
if(len1<len2)
{
ans.num.push_front('0');
temp=right;
return ans;
}
else
{
for(iter=left.num.begin(),i=0;i<len2;++i,++iter)
{
temp.num.push_back(*iter);
}
InterCalc digit,res;
for(j=0;j<10;++j)
{
digit.num.clear();
digit.num.push_back(j+'0');
res=right*digit;
res=temp-res;
if(*(res.num.begin())=='-')
break;
}
j-=1;
if(j>0)
{
digit.num.clear();
digit.num.push_back(j+'0');
res=right*digit;//后添加的
temp=temp-res;//原来是temp=temp+right
ans.num.push_back(j+'0');
}
for( ;iter!=left.num.end();++iter)
{
temp.num.push_back(*iter);
for(j=0;j<10;++j)
{
digit.num.clear();
digit.num.push_back(j+'0');
res=right*digit;
res=temp-res;
if(*(res.num.begin())=='-')
break;
}
j-=1;
digit.num.clear();
digit.num.push_back(j+'0');
res=right*digit;
temp=temp-res;
ans.num.push_back(j+'0');
}
if(sign)
{
temp.num.push_front('-');//改后添加的代码
ans.num.push_front('-');
}
}
//ans 是商  temp是余数
return  ans;
}
const InterCalc InterCalc::operator%( const InterCalc& Right ) const
{
InterCalc left(*this),right(Right);
//先判断 除数与被除数为零的情况  改后添加代码
if(right.iszero())
{
cout<<"除数不能为零！！！"<<endl;
cout<<"请遵守规则哦！！！"<<endl;
return InterCalc();
}
InterCalc ans,temp;
int len1,len2,len;
int i,j,k;
int sign=0;
int flag1=0,flag2=0;
list<char>::iterator iter;
if(*(left.num.begin())=='-')
{
flag1=1;
left.num.pop_front();
}
if(*(right.num.begin())=='-')
{
flag2=1;
right.num.pop_front();
}
if((flag1==1&&flag2==0)||(flag1==0&&flag2==1))
sign=1;
len1=left.num.size();
len2=right.num.size();
if(len1<len2)
{
ans.num.push_front('0');
temp=right;
return ans;
}
else
{
for(iter=left.num.begin(),i=0;i<len2;++i,++iter)
{
temp.num.push_back(*iter);
}
InterCalc digit,res;
for(j=0;j<10;++j)
{
digit.num.clear();
digit.num.push_back(j+'0');
res=right*digit;
res=temp-res;
if(*(res.num.begin())=='-')
break;
}
j-=1;
if(j>0)
{
digit.num.clear();
digit.num.push_back(j+'0');
res=right*digit;//后添加的
temp=temp-res;//原来是+
ans.num.push_back(j+'0');
}
for( ;iter!=left.num.end();++iter)
{
temp.num.push_back(*iter);
for(j=0;j<10;++j)
{
digit.num.clear();
digit.num.push_back(j+'0');
res=right*digit;
res=temp-res;
if(*(res.num.begin())=='-')
break;
}
j-=1;
digit.num.clear();
digit.num.push_back(j+'0');
res=right*digit;
temp=temp-res;
ans.num.push_back(j+'0');
}
if(sign)
{
temp.num.push_front('-');
ans.num.push_front('-');
}
}
//ans 是商  temp是余数
//ans.Print();
//temp.Prin
//不明原因多个零待解注意
while(*temp.num.begin()=='0')
temp.num.pop_front();
return temp;
}
const InterCalc& InterCalc::operator*=( const InterCalc& Right )
{
return (*this)=(*this)*Right;
}
const InterCalc& InterCalc::operator/=( const InterCalc& Right )
{
return (*this)=(*this)/Right;
}

/**************************************************************************************
*类名称：FloatCalc
*类描述：大浮点数计算
*类功能：+,-,>,<,=,>=,<=,==,*,/,*=,/=,+=,-=,++,--和正负号;
*类参考：自己根据大整数计算开发大浮点数计算开发中 ······
*编写人：十二年 710055071
*编写时间：2015-03-31至2015-03-31
***************************************************************************************/

class FloatCalc{
InterCalc	zs;//整数部分
InterCalc	xs;//小数部分
//int 	  flag;//0为正数  1为负数
static int dn;//输出小数的位数 默认10位
friend void xsbuwei(FloatCalc& Left,FloatCalc& Right);
public:
FloatCalc(){}
FloatCalc(const string& input);
FloatCalc(const InterCalc& input);
FloatCalc(const FloatCalc& input);

void Print() const;//可以重载输出操作符 和输入操作符来优化输入输出 用cout cin
bool iszero() const;
static void SetPrecision( const int& dn)							//设置浮点数输出精度
{
FloatCalc::dn=dn;
}
static void RePrecision()										//恢复浮点数默认精度
{
FloatCalc::dn=10;
}
static int GetPrecision()										//输出浮点数精度
{
return FloatCalc::dn;
}
bool operator>( const FloatCalc& Right ) const;			  //大于操作符
bool operator<( const FloatCalc& Right ) const;			  //小于操作符
bool operator>=(const FloatCalc& Right ) const;			  //大于等于操作符
bool operator<=(const FloatCalc& Right ) const;			  //小于等于操作符
bool operator==(const FloatCalc& Right ) const;			  //判断数值是否相等
const FloatCalc& operator+() const;					 	  //
const FloatCalc& operator-();							  //
const FloatCalc& operator++();							  //前置操作
const FloatCalc operator++(int);					 	  //后置操作
const FloatCalc& operator--();							  //
const FloatCalc operator--(int);						  //

const FloatCalc operator+( const FloatCalc& Right ) const;//加法运算
const FloatCalc operator-( const FloatCalc& Right ) const;//除法运算
const FloatCalc operator*( const FloatCalc& Right ) const;//乘法运算 ？？？？？有问题
//const FloatCalc operator/( const FloatCalc& Right ) const;//除法运算
//实际上 有的是在函数内部进行了传值操作
const FloatCalc& operator= ( const FloatCalc& Right );	  //赋值操作符
const FloatCalc& operator+=( const FloatCalc& Right );	  // += 运算
const FloatCalc& operator-=( const FloatCalc& Right );	  // -= 运算
//const FloatCalc& operator*=( const FloatCalc& Right );	  // *= 运算
//const FloatCalc& operator/=( const FloatCalc& Right );	  // /= 运算
};
int FloatCalc::dn=10;//定义静态成员 必须在类外部定义

void xsbuwei(FloatCalc& Left,FloatCalc& Right)
{
int len1,len2;
len1=Left.xs.num.size();
len2=Right.xs.num.size();
if( len1 >= len2 )
{
for(int i=0 ; i<len1-len2 ; ++i )
Right.xs.num.push_back('0');
}
else
{
for(int i=0 ; i<len2-len1 ; ++i)
Left.xs.num.push_back('0');
}
}
FloatCalc::FloatCalc(const string& input)
{		dn=10;
int err=0,i=0,sign=0;
if(input[0]=='+') ++i;
if(input[0]=='-')
{
sign=1;
++i;
}
while(input[i]=='0')
++i;
for(; i<input.length() ; ++i )
{
if(input[i]!='.')
{
if(input[i] >= '0' && input[i] <= '9' )
{
zs.num.push_back( input[i] );
}
else
{
cout<<i+1<<"位输入数据有误"<<endl;
err+=1;
}
}
else
{
break;
}
}
++i;
for(; i<input.length() ; ++i )
{
if(input[i] >= '0' && input[i] <= '9' )
{
xs.num.push_back( input[i] );
}
else
{
cout<<i+1<<"位输入数据有误"<<endl;
err+=1;
}

}
if(sign)
zs.num.push_front('-');
if(err)
{
cout<<"一共有"<<err<<"处错误"<<endl;
cout<<"请忽略结果重新输入数据"<<endl;
zs.num.clear();
xs.num.clear();
//num.push_front('0');
}
}
FloatCalc::FloatCalc(const InterCalc& input)
{
zs=input;
}
FloatCalc::FloatCalc(const FloatCalc& input)
{
zs=input.zs;
xs=input.xs;
}
void FloatCalc::Print() const
{
if(!(* this).iszero()&&(*zs.num.begin()=='-')&&zs.iszero())
cout<<"-";
zs.Print();
cout<<".";
if(xs.iszero())
{
for(int i=0;i<dn;++i)
{
cout<<0;
}
}
else
{
list<char>::const_iterator iter=xs.num.begin();
if(dn<xs.num.size())
{
for(int i=0;i<dn;++i)
{
cout<<*iter;
}
}
else
{
int i;
for( i=0;iter!=xs.num.end();++iter,++i)
{
cout<<*iter;
}
for( ;i<dn;++i)
{
cout<<0;
}
}
}
}
bool FloatCalc::iszero() const
{
if(zs.iszero()&&xs.iszero())
{
return true;
}
else
{
return false;
}
}
const FloatCalc& FloatCalc::operator= ( const FloatCalc& Right )
{
zs=Right.zs;
xs=Right.xs;
}
const FloatCalc& FloatCalc::operator+() const
{
return *this;
}
const FloatCalc& FloatCalc::operator-()
{
zs=-zs;
return *this;
}
const FloatCalc& FloatCalc::operator++()
{
++zs;
return *this;
}
const FloatCalc FloatCalc::operator++(int)
{
FloatCalc ans(*this);
++zs;
return ans;
}
const FloatCalc& FloatCalc::operator--()
{
--zs;
return *this;
}
const FloatCalc FloatCalc::operator--(int)
{
FloatCalc ans(*this);
--zs;
return ans;
}
bool FloatCalc::operator==(const FloatCalc& Right ) const
{
return zs==Right.zs&&xs==Right.xs?true:false;
}
bool FloatCalc::operator>( const FloatCalc& Right ) const
{
FloatCalc left(*this),right(Right);
xsbuwei(left,right);
if(left.zs==Right.zs)
{
if(*left.zs.num.begin()=='-'&&*right.zs.num.begin()=='-')
{
return left.xs>=right.xs?false:true;
}
else if(*left.zs.num.begin()=='-'&&*right.zs.num.begin()!='-')
{
return false;
}
else if(*left.zs.num.begin()!='-'&&*right.zs.num.begin()=='-')
{
return true;
}
else
{
return left.xs>right.xs?true:false;
}
}
else if(left.zs>right.zs)
{
return true;
}
else
{
return false;
}
}
bool FloatCalc::operator<( const FloatCalc& Right ) const
{
FloatCalc left(*this),right(Right);
xsbuwei(left,right);
if(left.zs==right.zs)
{
if(*left.zs.num.begin()=='-'&&*right.zs.num.begin()=='-')
{
return left.xs>right.xs?true:false;
}
else if(*left.zs.num.begin()=='-'&&*right.zs.num.begin()!='-')
{
return true;
}
else if(*left.zs.num.begin()!='-'&&*right.zs.num.begin()=='-')
{
return false;
}
else
{
return left.xs>=right.xs?false:true;
}
}
else if(left.zs>right.zs)
{
return false;
}
else
{
return true;
}
}
bool FloatCalc::operator>=(const FloatCalc& Right ) const
{

FloatCalc left(*this),right(Right);
xsbuwei(left,right);
if(left.zs==Right.zs)
{
if(*left.zs.num.begin()=='-'&&*right.zs.num.begin()=='-')
{
return left.xs>right.xs?false:true;
}
else if(*left.zs.num.begin()=='-'&&*right.zs.num.begin()!='-')
{
return false;
}
else if(*left.zs.num.begin()!='-'&&*right.zs.num.begin()=='-')
{
return true;
}
else
{
return left.xs>=right.xs?true:false;
}
}
else if(left.zs>right.zs)
{
return true;
}
else
{
return false;
}
}
bool FloatCalc::operator<=(const FloatCalc& Right ) const
{
FloatCalc left(*this),right(Right);
xsbuwei(left,right);
if(left.zs==right.zs)
{
if(*left.zs.num.begin()=='-'&&*right.zs.num.begin()=='-')
{
return left.xs>=right.xs?true:false;
}
else if(*left.zs.num.begin()=='-'&&*right.zs.num.begin()!='-')
{
return true;
}
else if(*left.zs.num.begin()!='-'&&*right.zs.num.begin()=='-')
{
return false;
}
else
{
return left.xs>right.xs?false:true;
}
}
else if(left.zs>right.zs)
{
return false;
}
else
{
return true;
}
}
const FloatCalc FloatCalc::operator+( const FloatCalc& Right ) const
{
FloatCalc left(*this),right(Right);
xsbuwei(left,right);
int len=left.xs.num.size();
int flag=0;
FloatCalc ans;
if(*left.zs.num.begin()=='-'&&*right.zs.num.begin()=='-')
{
left.zs=-left.zs;
right.zs=-right.zs;
ans=left+right;
flag=1;
}
else if(*left.zs.num.begin()!='-'&&*right.zs.num.begin()=='-')
{
right.zs.num.pop_front();
ans=right-left;
}
else if(*left.zs.num.begin()=='-'&&*right.zs.num.begin()!='-')
{
left.zs.num.pop_front();
ans=right-left;
}
else
{
ans.zs=left.zs+right.zs;
ans.xs=left.xs+right.xs;
if(ans.xs.num.size()>len)
{
ans.xs.num.pop_front();
ans.zs+=1;
}
}
if(flag)
ans.zs.num.push_front('-');
return ans;
}
const FloatCalc FloatCalc::operator-( const FloatCalc& Right ) const
{
FloatCalc left(*this),right(Right);
xsbuwei(left,right);
int len=left.xs.num.size();
int flag=0;
FloatCalc ans;
if(*left.zs.num.begin()=='-'&&*right.zs.num.begin()=='-')
{
left.zs=-left.zs;
right.zs=-right.zs;
ans=right-left;
}
else if(*left.zs.num.begin()!='-'&&*right.zs.num.begin()=='-')
{
right.zs.num.pop_front();
ans=left+right;
}
else if(*left.zs.num.begin()=='-'&&*right.zs.num.begin()!='-')
{
left.zs.num.pop_front();
ans=left+right;
ans.zs.num.push_front('-');
}
else
{
if(left>right)
{
if(left.xs>=right.xs)
{
ans.zs=left.zs-right.zs;
ans.xs=left.xs-right.xs;
}
else
{
left.xs+=10;
ans.xs=left.xs-right.xs;
ans.zs=left.zs-right.zs-1;
}
}
else
{
if(right.xs>=left.xs)
{
ans.zs=right.zs-left.zs;
ans.xs=right.xs-left.xs;
ans.zs.num.push_front('-');
}
else
{
right.xs+=10;
ans.xs=right.xs-left.xs;
ans.zs=right.zs-left.zs-1;
ans.zs.num.push_front('-');
}
}
}
return ans;
}
const FloatCalc& FloatCalc::operator+=( const FloatCalc& Right )
{
return *this=*this+Right;
}
const FloatCalc& FloatCalc::operator-=( const FloatCalc& Right )
{
return *this=*this-Right;
}
const FloatCalc FloatCalc::operator*( const FloatCalc& Right ) const// 0开头的数有问题
{
FloatCalc ans;
/*	FloatCalc left(*this), right(Right);
xsbuwei(left,right);
int len=left.xs.num.size();
InterCalc sum;
int x=pow(10,len);
int y=pow(x,2);
int flag=0;
if(*left.zs.num.begin()=='-'&&*right.zs.num.begin()=='-')
{
left.zs.num.pop_front();
right.zs.num.pop_front();
sum=(left.zs*x+left.xs)*(right.zs*x+right.xs);
ans.zs=sum/y;
ans.xs=sum%y;
}
else if(*left.zs.num.begin()!='-'&&*right.zs.num.begin()=='-')
{
right.zs.num.pop_front();
flag=1;
sum=(left.zs*x+left.xs)*(right.zs*x+right.xs);
ans.zs=sum/y;
ans.xs=sum%y;
}
else if(*left.zs.num.begin()=='-'&&*right.zs.num.begin()!='-')
{
left.zs.num.pop_front();
flag=1;
sum=(left.zs*x+left.xs)*(right.zs*x+right.xs);
ans.zs=sum/y;
ans.xs=sum%y;
}
else
{
sum=(left.zs*x+left.xs)*(right.zs*x+right.xs);
ans.zs=sum/y;
ans.xs=sum%y;
}
if(flag)
ans.zs.num.push_front('-');*/
return ans;
}
/////////////////////////////////

int main()
{
while(1)
{
string str1,str2;
cin>>str1;
cin>>str2;
InterCalc a(str1),b(str2);
//FloatCalc a(str1),b(str2);
//a.Print();
(a+b).Print();
cout<<endl;

}
return 0;
}