写了2天才写出来的还有些瑕疵的大数类

先贴头文件：类的声明

#ifndef GUARD_Bignum_h
#define GUARD_Bignum_h
#include<cstring>
#include<string>
#include<iostream>
#define MAX 500

class Bignum
{
private:
	int num[MAX];
public:
	//构造函数，初始化为0
	Bignum(){  memset(num,sizeof(num));  }
	//复制构造函数
	Bignum( const Bignum& p )
	{
		memcpy(num,p.num,sizeof(p.num));
	}
	//重载=
	Bignum operator =(const std::string& s);
	Bignum operator =(const long d);
	//构造函数（这里我试过Bignum a=0;这样来初始化，但是失败了，还不知道为什么会这样）
	Bignum(std::string s) { (*this)=s;}
	Bignum(long d) { (*this)=d; }
	//重载<<
	friend std::ostream& operator <<(std::ostream& os,const Bignum& p);
	//重载>>
	friend std::istream& operator >>(std::istream& is,Bignum& p);
	//重载+
	Bignum operator +(const Bignum& b) const;
	//重载-
	Bignum operator -(const Bignum& b) const;//还要针对结果是负数的情况没处理
	//重载*
	Bignum operator *(const Bignum& b) const;
	//移位函数
	void shift(int bit);
	//重载/
	Bignum operator /(const Bignum& b) const;
	//返回大数的位数
	int len() const;
	//重载<
	bool operator <(const Bignum& b) const;
	//重载>
	bool operator >(const Bignum& b) const;
	//重载<=
	bool operator <=(const Bignum& b) const;
	//重载>=
	bool operator >=(const Bignum& b) const;
	//重载!=
	bool operator !=(const Bignum& b) const;
	//重载==
	bool operator ==(const Bignum& b) const;

};


#endif

再贴源文件：各函数的实现

#include"Bignum.h"
#include<iostream>
#include<cstdio>
#include<string>
#include<stdexcept>
using std::cout;  using std::endl;
using std::string;  using std::ostream;
using std::istream;


//重载=
Bignum Bignum::operator =(const std::string &s)
{
	int len=s.size(),i,j=0;
	for(i=len-1;i>=0;i--)
	{
		num[j++]=s[i]-'0';
	}
	return *this;
}


//重载=
Bignum Bignum::operator =(const long d)
{
	char str[MAX];
	sprintf(str,"%ld",d);
	*this=str;
	return *this;
}


//重载<<
ostream& operator <<(ostream& os,const Bignum& p)
{
	int i;
	for(i=MAX-1;i>=0;i--)
	{
		if(p.num[i]!=0)
			break;
	}
	if(i<0)
		os<<0;
	else
	{
		for(i;i>=0;i--)
			os<<p.num[i];
	}
	return os;
}

//重载>>
istream& operator >>(istream& is,Bignum& p)
{
	string s;
	is>>s;
	p=s;
	return is;
}

//重载+
Bignum Bignum::operator +(const Bignum& b) const
{
	Bignum c;
	int i;
	for(i=0;i<MAX;i++)
	{
		c.num[i]=c.num[i]+num[i]+b.num[i];
		if(c.num[i]>9)
		{
			c.num[i+1]=c.num[i]/10;
			c.num[i]=c.num[i]%10;
		}
	}
	return c;
}


//重载-
Bignum Bignum::operator -(const Bignum& b) const
{
	Bignum c,a=*this;
	int i;
	for(i=0;i<MAX;i++)
	{
		if(num[i]<b.num[i])
		{
			a.num[i]+=10;
			a.num[i+1]--;
		}
		c.num[i]=a.num[i]-b.num[i];
	}
	return c;
}

//重载*
Bignum Bignum::operator *(const Bignum& b) const
{
	int i,j;
	Bignum c;
	for(i=0;i<MAX;i++)
	{
		for(j=0;j<MAX;j++)
		{
			c.num[i+j]+=num[i]*b.num[j];
		}
	}
	for(i=0;i<MAX;i++)
	{
		if(c.num[i]>9)
		{
			c.num[i+1]+=c.num[i]/10;
			c.num[i]=c.num[i]%10;
		}
	}
	return c;
}

//移位函数
void Bignum::shift(int bit)
{
	int i,len=(*this).len();
	if(bit>=0) // >=右移
	{
		for(i=len+bit-1;i>=0;i--)
			num[i]=(i>=bit)?num[i-bit]:0;
	}
	else if(bit<0) // <0左移
	{
		for(i=0;i<len;i++)
			num[i]=(i-bit<len)?num[i-bit]:0;//这里-bit是因为bit是负数，减去才得正数
	}
}

//重载/
Bignum Bignum::operator /(const Bignum& b) const
{
	Bignum did=*this;//除数
	Bignum dir=b;    //被除数
	Bignum res;      //结果
	Bignum zero;
	zero=0;
	if(dir==zero)
		throw std::logic_error ("can't divide zero");
	if(did<dir)
		return zero;
	int m=did.len()-dir.len();
	dir.shift(m);
	while(m>=0)
	{
		if(dir<=did)
		{
			did=did-dir;
			res.num[m]++;
		}
		else if(dir>did)
		{
			m--;
			dir.shift(-1);
		}
	}
	return res;
}
	


//返回大数的位数
int Bignum::len() const
{
	int i;
	for(i=MAX-1;i>=0;i--)
	{
		if(num[i]!=0)
			break;
	}
	if(i<0)
		return 1;
	return i+1;
}



//重载<
bool Bignum::operator <(const Bignum& b) const
{
	int lena=(*this).len();
	int lenb=b.len();
	if(lena!=lenb)
		return lena<lenb;
	else
	{
		for(int i=lena-1;i>=0;i--)
		{
			if(num[i]!=b.num[i])
				return num[i]<b.num[i];
		}
	}
	return false;
}

//重载>
bool Bignum::operator >(const Bignum& b) const
{
	return b<(*this);
}


//重载<=
bool Bignum::operator <=(const Bignum& b) const
{
	return !(b<(*this));
}


//重载>=
bool Bignum::operator >=(const Bignum& b) const
{
	return !((*this)<b);
}


//重载!=
bool Bignum::operator !=(const Bignum& b) const
{
	return (*this<b) || (*this>b);
}


//重载==
bool Bignum::operator ==(const Bignum& b) const
{
	return !(*this<b) && !(*this>b);
}

仅供个人复习用，还有些负数方面没处理