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

#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
{
	    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 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;
}