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

#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;
????????} ( }