自己写的大整数类

#include<iostream>


using namespace std;




class IntegerNumber
{
public:


/*
*Default constructor
*Usage: IntegerNumber A;
*/
IntegerNumber();


/*
Constructor
Usage: IntegerNumber("123456789012345678");
*/
IntegerNumber(const char *s);


/*
Copy constructor
Usage:
IntegerNumber A("1234567890123");
IntegerNunber B(A);
*/
IntegerNumber(const  IntegerNumber &i);


//Destructor
//~IntegerNumber();




//Get the length of a IntegerNumber object
int Length() const;


/*
Assignment operator
Usage: 
IntegerNuber A("1234567890123");
IntegerNumber B;
B=A;
*/
const IntegerNumber& operator=( const IntegerNumber &rhsObject);


/*
Usage：
IntegerNuber A("1234567890123");
IntegerNumber B("987654321054321");
B+=A; the same as B=B+A;
A-=B; the same as A=A-B;
*/
friend IntegerNumber operator+=( IntegerNumber &lhs,const IntegerNumber &rhs);
friend IntegerNumber operator-=(IntegerNumber &lhs,const IntegerNumber &rhs);


/*
Plus/Minus two positive number
Usage:
be called by operator +/-
*/
friend IntegerNumber UnsignPlus(const IntegerNumber &lhs, const IntegerNumber &rhs);
friend IntegerNumber UnsignMinus(const IntegerNumber &lhs, const IntegerNumber &rhs);


//Friend function for +
friend IntegerNumber operator+(const IntegerNumber &lhs, const IntegerNumber &rhs);
//Friend function for -
friend IntegerNumber operator-(const IntegerNumber &lhs, const IntegerNumber &rhs);


//Compare two positive number, return true if first number less than the second
friend bool compareLess(const IntegerNumber &lhsObject,const IntegerNumber &rhsObject);


friend bool operator <(const IntegerNumber &lhsObject,const IntegerNumber &rhsObject);
friend bool operator >=(const IntegerNumber &lhsObject,const IntegerNumber &rhsObject);
friend bool operator ==(const IntegerNumber &lhsObject,const IntegerNumber &rhsObject);
friend bool operator !=(const IntegerNumber &lhsObject,const IntegerNumber &rhsObject);




//Friend function for output
//Usage:cout<<aIntegerNumberObj;
friend ostream& operator<<(ostream &out,const IntegerNumber &obj);




private:
char *rep; //store the IntegerNumber
int len;  //store the length of the IntegerNumber
};




//Default constructor
IntegerNumber::IntegerNumber(){
rep= new char[1];
rep[0]='0';
len=1;

}


//Constructor
IntegerNumber::IntegerNumber(const char *s){
len=0;
const char *temp=s;
while(*temp)
{
++len;
++temp;
}
//now len is the same as the length of i.rep
rep=new char[len+1];
for(int i=0;i<=len;i++)
rep[i]=s[i];


}


//Copy constructor
IntegerNumber::IntegerNumber(const IntegerNumber &i){
len=0;
char *temp=i.rep;
while(*temp)
{
++len;
++temp;
}
//now len is the same as the length of i.rep
rep=new char[len+1];
for(int j=0;j<=len;++j)
rep[j]=i.rep[j];
}


//Assignment operator
const IntegerNumber& IntegerNumber::operator=(const IntegerNumber &rhs){
if(this!=&rhs){
len=0;
char *tmp=rhs.rep;
while(*tmp)
{
++len;
++tmp;
}
//now len is the same as the length of obj.rep
delete []rep;
rep=new char[len+1];
for(int j=0;j<=len;++j)
rep[j]=rhs.rep[j];
}
return *this;
}


//Get the length
int IntegerNumber::Length() const{
return len;
}


IntegerNumber UnsignPlus(const IntegerNumber &lhs, const IntegerNumber &rhs){
int one,two,less,more;
one=lhs.Length();
two=rhs.Length();
if(one<=two) 
{less=one;more=two;}
else
{less=two;more=one;}
char *tmp;
tmp=new char[more+1];
int partResult;
int j,promote;
for(j=0, promote=0;j<more;j++)
{
partResult=promote;
if(j<one) partResult+=lhs.rep[one-1-j]-'0';
if(j<two) partResult+=rhs.rep[two-1-j]-'0';
promote=(partResult)/10;
tmp[more-j]=(partResult)%10+'0';
}
if(promote)
tmp[0]='1';
else
{
for(int k=0;k<more;k++)
tmp[k]=tmp[k+1];
tmp[more]='\0';
}
IntegerNumber retNum(tmp);
delete []tmp;
return retNum;


}


IntegerNumber UnsignMinus(const IntegerNumber &lhs, const IntegerNumber &rhs){

int borrow;
int first=lhs.len;
int second=rhs.len;
int less,more;
char *tmp;
int partResult;
int firstNotZero;


if(first>=second)
{less=second;more=first;}
else
{less=first;more=second;}


borrow=0;
tmp= new char[more];
for(int i=0;i<more;i++){
partResult=borrow;
if(i<first) partResult+=lhs.rep[first-1-i]-'0';
if(i<second) partResult-=rhs.rep[second-1-i]-'0';

if(partResult>=0){tmp[more-1-i]=partResult+'0';borrow=0;}
else {tmp[more-1-i]=partResult+10+'0';borrow=-1;}
}
firstNotZero=more;
for(int i=0;i<more;i++)
{
if(tmp[i]!='0'){
firstNotZero=i;
break;
}
}
if(firstNotZero<more)
{
int j;
for(j=0;j<=(more-1-firstNotZero);j++)
{
tmp[j]=tmp[j+firstNotZero];
}
tmp[j]='\0';
}
else{
tmp[1]='\0';
}
IntegerNumber retNum(tmp);
//delete []tmp;
return retNum;


}
//Friend function for IntegerNumber +
IntegerNumber operator+(const IntegerNumber &lhs, const IntegerNumber &rhs){
IntegerNumber retNum;
char *tmp;
char *tmp1;
char *tmp2;
if(lhs.rep[0]!='-'&&rhs.rep[0]!='-')
{
retNum=UnsignPlus(lhs,rhs);
}
else if(lhs.rep[0]=='-'&&rhs.rep[0]!='-'){
tmp=new char[lhs.len-1];
for(int i=0;i<lhs.len;i++){
tmp[i]=lhs.rep[i+1];
}
IntegerNumber unsignNum(tmp);
retNum=rhs-unsignNum;
}
else if(lhs.rep[0]!='-'&&rhs.rep[0]=='-'){
tmp=new char[rhs.len-1];
for(int i=0;i<rhs.len;i++){
tmp[i]=rhs.rep[i+1];
}
IntegerNumber unsignNum(tmp);
retNum=lhs-unsignNum;
}
else{
tmp1=new char[lhs.Length()-1];
tmp2=new char[rhs.Length()-1];




for(int i=0;i<lhs.len;i++){
tmp1[i]=lhs.rep[i+1];
}
for(int i=0;i<rhs.len;i++){
tmp2[i]=rhs.rep[i+1];
}
IntegerNumber unsignNum1(tmp1);
IntegerNumber unsignNum2(tmp2);
retNum=unsignNum1+unsignNum2;
tmp=new char[retNum.len+1];
tmp[0]='-';
for(int i=0;i<=retNum.len;i++)//i=retNum.len retNum.rep[i]='\0'
{
tmp[i+1]=retNum.rep[i];
}
IntegerNumber tmpNum(tmp);
retNum=tmpNum;
}
//delete tmp;
return retNum;


}


//Friend function for IntegerNumber -
IntegerNumber operator-(const IntegerNumber &lhs, const IntegerNumber &rhs){
IntegerNumber retNum;
char *tmp;
if(lhs.rep[0]!='-'&&rhs.rep[0]!='-')
{
if(lhs>=rhs)
retNum=UnsignMinus(lhs,rhs);
else{

retNum=UnsignMinus(rhs,lhs);
tmp=new char[retNum.len+1];
tmp[0]='-';
for(int i=0;i<=retNum.len;i++) //tmp[retNum.len+1]='\0'
{
tmp[i+1]=retNum.rep[i];
}
retNum=IntegerNumber(tmp);
}
}
else if(lhs.rep[0]=='-'&&rhs.rep[0]!='-'){
tmp=new char[lhs.len];
for(int i=0;i<lhs.len;i++)
{
tmp[i]=lhs.rep[i+1];
}
IntegerNumber T(tmp);
IntegerNumber T2;
retNum=rhs+T;
retNum=T2-retNum;
}
else if(lhs.rep[0]!='-'&&rhs.rep[0]=='-'){
tmp=new char[rhs.len];
for(int i=0;i<rhs.len;i++)
{
tmp[i]=rhs.rep[i+1];
}
IntegerNumber T(tmp);
retNum=lhs+T;
}
else {
tmp=new char[rhs.len];
for(int j=0;j<rhs.len;j++)
{
tmp[j]=rhs.rep[j+1];
}
IntegerNumber T(tmp);
retNum=T+lhs;
}
return retNum;
}


IntegerNumber operator+=(IntegerNumber &lhs,const IntegerNumber &rhs){
IntegerNumber T;
T=lhs+rhs;
lhs=T;
return lhs;
}
IntegerNumber operator-=(IntegerNumber &lhs,const IntegerNumber &rhs){
IntegerNumber T;
T=lhs-rhs;
lhs=T;
return lhs;
}


bool compareLess(const IntegerNumber &lhsObject,const IntegerNumber &rhsObject)
{
if(lhsObject.len!=rhsObject.len) return lhsObject.len<rhsObject.len;
for(int i=lhsObject.len-1;i>=0;i--)
{
if(lhsObject.rep[i]!=rhsObject.rep[i]) return lhsObject.rep[i]<rhsObject.rep[i];
}
return false;
}


bool operator <(const IntegerNumber &lhsObject,const IntegerNumber &rhsObject) 
{
bool resultOfCompare;
if(lhsObject.rep[0]!='-'&&rhsObject.rep[0]!='-'){
resultOfCompare=compareLess(lhsObject,rhsObject);
}
else if(lhsObject.rep[0]=='-'&&rhsObject.rep[0]!='-'){
resultOfCompare=true;
}
else if(lhsObject.rep[0]!='-'&&rhsObject.rep[0]=='-'){
resultOfCompare=false;
}
else{
if(!(compareLess(rhsObject,lhsObject))&&!(compareLess(lhsObject,rhsObject)))
resultOfCompare=false;
else
resultOfCompare=!compareLess(lhsObject,rhsObject);
}


return resultOfCompare;


}


bool operator >(const IntegerNumber &lhsObject,const IntegerNumber &rhsObject) {return rhsObject<lhsObject;}
bool operator >=(const IntegerNumber &lhsObject,const IntegerNumber &rhsObject) {return !(lhsObject<rhsObject);}
bool operator !=(const IntegerNumber &lhsObject,const IntegerNumber &rhsObject) {return rhsObject<lhsObject||lhsObject<rhsObject;}
bool operator ==(const IntegerNumber &lhsObject,const IntegerNumber &rhsObject) {return !(rhsObject<lhsObject)&&!(lhsObject<rhsObject);}


// Friend function for output
ostream& operator<<(ostream &out,const IntegerNumber &obj){
return out<<obj.rep;
}




int main()
{
IntegerNumber A;
IntegerNumber B("-12345678954688709764347890");
IntegerNumber C="5678954688709764347890";
IntegerNumber D(B);
IntegerNumber E(B);
A=B;
cout<<A<<" "<<B<<endl;
C=B+C;
cout<<C<<endl;  //-1234000000000000
D=B-C;
cout<<D<<endl; //-B
if(A<B){
E+=B;
cout<<E<<endl;
}
if(A>=B){
E-=B;
cout<<E<<endl;  //0
}
if(A==B||C!=D){
cout<<A<<E<<D<<endl;
}
system("pause");
return 0;
}