补码表示的大数加减乘除运算程序设计

#include   <deque>
<vector>
<iostream>
<string>
<algorithm>
using   namespace  std;

class  DividedByZeroException{};
 BigInteger
{
private :
     vector< char > digits; 
      bool  sign;           //   true for positive,false for negitive
void  trim();           remove zeros in tail,but if the value is 0,keep only one:)
public      BigInteger( int );      construct with a int integer string &) ;
     BigInteger();
     BigInteger ( const  BigInteger&);
     BigInteger  operator =(  BigInteger& op2);
     BigInteger      abs()  ;
     BigInteger    pow(  a);
      binary operators         
friend  BigInteger  +=(BigInteger&, -=(BigInteger&,Monaco">*=(BigInteger&,Monaco">/=(BigInteger&,Monaco"> BigInteger&)  throw (DividedByZeroException);
%=(BigInteger&,Monaco">(DividedByZeroException);       
+(  BigInteger&,Monaco">-( *( /( %(    
uniary operators  BigInteger&);    negative

++(BigInteger&);         ++v ++(BigInteger&,Monaco">v++ --(BigInteger&);         --v --(BigInteger&,Monaco">v-- >( <( ==( !=( >=( <=(  ostream&  <<(ostream&,Monaco"> BigInteger&);     print the BigInteger  istream&  >>(istream&,BigInteger&);           input the BigInteger static  BigInteger ZERO;
 BigInteger ONE;
 BigInteger TEN;
};
 BigInteger BigInteger::ZERO=BigInteger( 0 );
 BigInteger BigInteger::ONE =BigInteger( 1  BigInteger BigInteger::TEN =BigInteger( 10 BigInteger::BigInteger()
    sign= true ; 
}
BigInteger::BigInteger(  val){      if  (val >=  )
        sign =  else false         val *= (-     }
do         digits.push_back( ( )(val% ) );
        val /=      }  while  ( val !=   );
& def){
for  (  ::reverse_iterator iter = def.rbegin() ; iter < def.rend();  iter++){
          ch = (*iter);
 (iter == def.rend()- ){
              ( ch ==  ' + '  )
                 break (ch ==  -  ){
                sign =              }
        }
)((*iter) -  0  ) );
    trim();
 BigInteger::trim(){
    vector< >::reverse_iterator iter = digits.rbegin();
(!digits.empty() && (*iter) ==          digits.pop_back();
        iter=digits.rbegin();
( digits.size()==         digits.push_back(  BigInteger& op2){
    sign = op2.sign;
    digits=op2.digits;
BigInteger BigInteger::     digits = op2.digits;
return  (* this BigInteger BigInteger::abs()   {
(sign)    *         -(* BigInteger BigInteger::pow(  a) 
    BigInteger res( (  i= ; i<a; i++)
        res*=(*  res;
BigInteger  +=(BigInteger& op1,Monaco">( op1.sign == op2.sign ){      只处理相同的符号的情况，异号的情况给-处理         vector< >::iterator iter1;
>::const_iterator iter2;
        iter1 = op1.digits.begin();
        iter2 = op2.digits.begin();
 to_add =  ;         进位  ( iter1 != op1.digits.end() && iter2 != op2.digits.end()){
            (*iter1) = (*iter1) + (*iter2) + to_add;
            to_add = ((*iter1) >  9  大于9进一位             (*iter1) = (*iter1) %              iter1++; iter2++;
 ( iter1 != op1.digits.end() ){                  (*iter1) = (*iter1) + to_add;
            to_add = ( (*iter1) >              (*iter1) %=              iter1++;
 ( iter2 != op2.digits.end() ){
 val = (*iter2) + to_add;
            to_add = (val >  ) ;
            val %=              op1.digits.push_back(val);
            iter2++;
( to_add !=              op1.digits.push_back(to_add);
 op1;
 (op1.sign)
 op1 -= (-op2);
else
 op1= op2 - (-op1);
-=(BigInteger& op1,Monaco">( op1.sign == op2.sign ){
(op1.sign) { 
(op1 < op2)
  op1=-(op2 - op1);
        } 
(-op1 > -op2) 
 op1=-((-op1)-(-op2));
            
 op1= (-op2) - (-op1);
 to_substract =  ;  
            (*iter1) = (*iter1) - (*iter2) - to_substract;
            to_substract =  ( (*iter1) <                  to_substract=                 (*iter1) +=   ( iter1 != op1.digits.end() ){
            (*iter1) = (*iter1) - to_substract;
        op1.trim();
 (op1 > BigInteger::ZERO)
 op1 += (-op2);
 op1 = -(op2 + (-op1));
*=(BigInteger& op1,Monaco">    BigInteger result(  (op1 == BigInteger::ZERO || op2==BigInteger::ZERO)
        result = BigInteger::ZERO;
>::const_iterator iter2 = op2.digits.begin();
( iter2 != op2.digits.end() ){
(*iter2 !=                  deque< > temp(op1.digits.begin(),op1.digits.end());
>::iterator iter1 = temp.begin();
( iter1 != temp.end() ){
                    (*iter1) *= (*iter2);
                    (*iter1) += to_add;
                    to_add = (*iter1) /                      (*iter1) %=                      iter1++;
                }
                    temp.push_back( to_add );
 num_of_zeros = iter2 - op2.digits.begin();
(  num_of_zeros--)
                    temp.push_front(                 BigInteger temp2;
                temp2.digits.insert( temp2.digits.end(),temp.begin(),temp.end() );
                temp2.trim();
                result = result + temp2;
        result.sign = ( (op1.sign && op2.sign) || (!op1.sign && !op2.sign) );
    op1 = result;
/=(BigInteger& op1,   BigInteger& op2 )  (DividedByZeroException) {
( op2 == BigInteger::ZERO )
 DividedByZeroException();
    BigInteger t1 = op1.abs(),t2 = op2.abs();
 ( t1 < t2 ){
        op1 = BigInteger::ZERO;
  
    deque< > temp;
>::reverse_iterator iter = t1.digits.rbegin();
    BigInteger temp2( ( iter != t1.digits.rend() ){
        temp2 = temp2 * BigInteger::TEN + BigInteger( ( )(*iter) );
 s =  ( temp2 >= t2 ){
            temp2 = temp2 - t2;
            s = s +          temp.push_front( s );
        iter++;
    op1.digits.clear();
    op1.digits.insert( op1.digits.end(),Monaco">    op1.trim();
    op1.sign = ( (op1.sign && op2.sign) || (!op1.sign && !op2.sign) );
%=(BigInteger& op1,Monaco"> BigInteger& op2)   op1 -= ((op1 / op2)*op2);
 BigInteger& op1,Monaco">    BigInteger temp(op1);
    temp += op2;
 temp;
    temp -= op2;
    temp *= op2;
    temp /= op2;
    temp %= op2;
 BigInteger& op){ 
    BigInteger temp = BigInteger(op);
    temp.sign = !temp.sign;
++(BigInteger& op){   
    op += BigInteger::ONE;
 op;
++(BigInteger& op,Monaco"> x){
    BigInteger temp(op);
    ++op;
--(BigInteger& op){   
    op -=  BigInteger::ONE;
--(BigInteger& op,Monaco">    --op;
( op1.sign != op2.sign )
 !op1.sign;
(op1.digits.size() != op2.digits.size())
 (op1.sign && op1.digits.size()<op2.digits.size())
        || (!op1.sign && op1.digits.size()>op2.digits.size());
>::const_reverse_iterator iter1,iter2;
        iter1 = op1.digits.rbegin();iter2 = op2.digits.rbegin();
( iter1 != op1.digits.rend() ){
(  op1.sign &&  *iter1 < *iter2 )  (  op1.sign &&  *iter1 > *iter2 )  ( !op1.sign &&  *iter1 > *iter2 )  ( !op1.sign &&  *iter1 < *iter2 )  ( op1.sign != op2.sign  || op1.digits.size() != op2.digits.size() )
>::const_iterator iter1,Monaco">    iter1 = op1.digits.begin();
    iter2 = op2.digits.begin();
( iter1!= op1.digits.end() ){
( *iter1 != *iter2 )           iter1++;
        iter2++;
 !(op1==op2);
 (op1>op2) || (op1==op2);
 (op1<op2) || (op1==op2);
 !(op1<=op2);
ostream&  <<(ostream& stream,Monaco"> BigInteger& val){      (!val.sign)
        stream <<  " "  ( vector< >::const_reverse_iterator iter = val.digits.rbegin(); iter != val.digits.rend() ; iter++)
        stream << ( )((*iter) +   stream;
istream&  >>(istream& stream,BigInteger& val){     Input the BigInteger  str;
    stream >> str;
    val=BigInteger(str);
BigInteger gcd (BigInteger m,BigInteger n)
( m < n )
                std::swap(m,n);
 ( n == BigInteger( ))
 m;
 gcd(n,m%n);
BigInteger lcm(BigInteger m,Monaco"> m * n /gcd(m,Monaco"> main()
        std::  b1,b2;
do
        {
                std:: cin >>b1>>b2;
 ( b1 == b2 && b1 ==                                           BigInteger ret = lcm(BigInteger(b1),BigInteger(b2));
cout <<ret<<std::endl;
        } ( }