caculate.h

能够进行大数运算

#include<iostream>
using namespace std;
static int f;
#define N 40
template<class T>
class Array1D
{
	public:
		Array1D(int sz=0);
		Array1D(const Array1D<T> &x);
		~Array1D(){delete []element;}
		T &operator[](int i) const;
		int max(const Array1D<T> &x)const ;
		Array1D<T> operator+(const Array1D<T> &x) const;
		Array1D<T> operator-(const Array1D<T> &x) const;
		Array1D<T> operator*(const Array1D<T> &x) const;
		Array1D<T>& operator=(const Array1D<T> &x) ;
		Array1D<T> operator-() const;
		Array1D<T> operator*(int a) const;
		int Size() {return size;}
		void Output(ostream &out) const;
	private:
		int size;
		T *element;
};

template<class T>
Array1D<T>::Array1D(int sz)
{
	if(sz<0) throw BadInitializers();
	size=sz;
	element=new T[sz];
	for(int i=0;i<sz;i++)
		element[i]=0;
}

template<class T>
Array1D<T>::Array1D(const Array1D<T> &x)
{
	size=x.size;
	element=new T[size];
	for(int i=0;i<size;i++)
		element[i]=x.element[i];
}

template<class T>
void Array1D<T>::Output(ostream &out) const
{
	bool begin=0,flag=0;
	if (f==1) 
	{
		cout<<'-';
		f=0;
	}
	for(int i=size-1;i>=0;i--)
	{
		if(!begin)
		{	if(element[i]!=0) 
			{
				begin=1;
				flag=1;
				out<<element[i];
			}
			
		}
		else 
		{
			out<<element[i];
			flag=1;
		}
	}
	if(begin==0&&flag==0) out<<element[0];
	 
}

template<class T>
ostream &operator<<(ostream &out,const Array1D<T> &x)
{
	x.Output(out);
	return out;
}

template<class T>
int Array1D<T>::max(const Array1D<T> &x) const
{
	int maxsz=size,minsz=x.size,flag=0;
	if(x.size>size) 
	{
		maxsz=x.size;
		minsz=size;
		return 1;
	}
	else if(x.size==size)
	{
		int i=size-1;
		int j=0;
		while(i>=0)
		{
			if(	x.element[i]!=element[i]) 
				{
					return (x.element[i]>element[i]);
				}
			else if(x.element[i]==element[i])
			{
				j+=1;//cout<<j<<endl;
			}
			i--;
			
		}
		if(j==N) return 2;		
	}

	return 0;
}


template<class T>
T &Array1D<T>::operator[](int i) const
{
	if(i<0||i>=size) throw OutOfBounds();
	return element[i];
}

template<class T>
Array1D<T> Array1D<T>::operator-() const
{
	Array1D w(size);
	w.element[size-1]=-element[size-1];
	return w;
}

template<class T>
Array1D<T> &Array1D<T>::operator=(const Array1D<T> &x) 
{
	if(this!=&x)
	{
		size=x.size;
		delete[]element;
		element=new T[size];
		for(int i=0;i<size;i++)
			element[i]=x.element[i];
	}
	return *this;
}

template<class T>
Array1D<T> Array1D<T>::operator*(int a) const	
{
	Array1D<T> w(N);
	for(int j=0;j<size;j++)
		{
			w.element[j]+=element[j]*a;
			while(w.element[j]>9)//进位
			{
				w.element[j+1]+=1;
				w.element[j]-=10;
			}
		}
	
	return w;
}

template<class T>
Array1D<T> Array1D<T>::operator+(const Array1D<T> &x) const
{
	
	Array1D<T> w1(N),w2(N),w(N);
	for(int i=0;i<x.size;i++)
	{
		w1.element[i]=x.element[i];
	}
	for( i=0;i<size;i++)
	{
		w2.element[i]=element[i];
	}
	for( i=0;i<N;i++)
	{
		w.element[i]+=w1.element[i]+w2.element[i];
		while(w.element[i]>9)
		{
			w.element[i+1]+=1;
			w.element[i]-=10;
		}
	}

	return w;
}	

template<class T>
Array1D<T> Array1D<T>::operator-(const Array1D<T> &x) const
{
	int maxsz=size,minsz=x.size,flag=0;//判断大小
	if(x.size>size) 
	{
		maxsz=x.size;
		minsz=size;
		flag=1;
	}
	f=max(x);
	Array1D<T> w(maxsz);
	for(int j=0;j<maxsz;j++)
	{
		w.element[j]=0;
	}
	if(f==1)
	{
		for(int i=0;i<minsz;i++)
		{
			w.element[i]+=x.element[i]-element[i];
			while(w.element[i]<0)//退位
			{
				w.element[i+1]-=1;
				w.element[i]+=10;
			}
		}
		for(i=minsz;i<maxsz;i++)
		{
		w.element[i]+=x.element[i];

		}
		
	}
	else 	
	{
		for(int i=0;i<minsz;i++)
		{
			w.element[i]+=element[i]-x.element[i];
			while(w.element[i]<0)
			{
				w.element[i+1]-=1;
				w.element[i]+=10;
			}
		}
		for(i=minsz;i<maxsz;i++)
		w.element[i]+=element[i];
		
	}
	return w;	
}	

template<class T>
Array1D<T> Array1D<T>::operator*(const Array1D<T> &x) const
{
	
	Array1D<T> w(N);
	Array1D<T> sum(N);
	for(int j=0;j<N;j++)
	{
		sum.element[j]=0;
	}
	for(int i=x.size-1;i>=0;i--)
	{
		for(int j=0;j<N;j++)
		{
			w.element[j]=0;
		}
		for(j=0;j<size;j++)
		{
			w.element[j]+=element[j]*x.element[i];
			while(w.element[j]>9)
			{
				w.element[j+1]+=1;
				w.element[j]-=10;
			}
		}
		for( j=sum.size-1;j>0;j--)//向前移位，扩大十陪
			sum.element[j]=sum.element[j-1];
		sum.element[0]=0;
		sum=sum+w;
	}
	
	return sum;
}
//除法
template<class T>
Array1D<T> div(Array1D<T> a,Array1D<T> x)
{
	Array1D<T> w0(1);
	if(a.Size()<x.Size()) return w0 ;
	Array1D<T>  w(N);
	Array1D<T> m(N);
	
	for(int i=a.Size()-1;i>=0;i--)//从第1位开始求商一直到最后一位
	{
		Array1D<T>  r(N);
		for(int p=i;p<=a.Size()-1;p++)
		{
			r[p-i]=a[p];
		}
		for(int s=0;s<10;s++)
		{
			Array1D<T>  r1(N),r2(N);
			r1=x*s;
			r2=x*(s+1);
		//	cout<<r1<<' '<<r<<' '<<r2<<endl;
			if(r1.max(r)==1&&r.max(r2)==1)
				{
					m[i]=s;
					//cout<<s<<endl;
				
					break;
				}
			else if(r1.max(r)==2)
			{
				m[i]=s;
			//	cout<<endl<<endl<<s<<endl;
				break;
			}
		}
		if(m[i]!=0) 
		{	
		
			w=x*m[i];
			for(s=0;s<i;s++)
				  w=w*10;
		for(s=0;s<a.Size();s++)
			{
				a[s]-=w[s];
				while(a[s]<0)
				{
					a[s+1]-=1;
					a[s]+=10;
				}
			
			}
		}
		
	}
	return m;	
}
//取余
template<class T>
Array1D<T> mod(Array1D<T> a,Array1D<T> b)
{
	Array1D<T> w,c,r;
	c=a;
	w=div(a,b);//求商
	w=b*w;
	for(int s=0;s<a.Size();s++)
			{
				c[s]-=w[s];
				while(c[s]<0)
				{
					c[s+1]-=1;
					c[s]+=10;
				}
				}
	return c;
}