long_int200.cpp

实现长整数型的运算

#include "long_int200.h"
long_int::long_int()
//无参时初始化200位的长整数数组
{
	for(int i=0;i<200;i++)	{array[i]=0;}
	size=0;
}
long_int::long_int(int *p,int another_size)
//有参时初始化200位的长整数数组
{
	for(int i=1;i<=200;i++)	{array[200-i]=p[200-i];}
	size=another_size;
}
long_int::long_int(long_int& p)
//拷贝构造函数
{
	for(int i=0;i<200;i++)	{array[i]=p.array[i];}
	size=p.size;
}
long_int& long_int::operator=(const long_int& p)
//赋值函数重载	
{
	for(int i=0;i<200;i++)	{array[i]=p.array[i];}
	size=p.size;
	return *this;
}
long_int long_int::operator+(const long_int& p)
//重载加法
{
	int result[200],new_size,jinwei=0;	
	//结果存在result中,jinwei为是否有进位;
	for(int i=0;i<200;i++)	{result[i]=p.array[i]; }
	for(i=1;i<=size;i++)
	{
		result[200-i]+=array[200-i];	//两数相加
		result[200-i]+=jinwei;		//加上前一位的进位值
		if(result[200-i]>9)			//做各位上的加法
		{
			result[200-i]=result[200-i]%10;
			jinwei=1;
		}
		else {jinwei=0;}
	}
	
	if(size>=p.size)	{new_size=size;}	//判断新的数组的大小
	else	{new_size=p.size;}
	while(jinwei!=0&&i<=200)
	{
		
		result[200-i]=result[200-i]+jinwei;		//判断是否有进位
		if(result[200-i]>9)			//做各位上的加法
		{
			result[200-i]=result[200-i]%10;
			jinwei=1;
		}
		else {jinwei=0;}
		i++;
	}
	if(i==201&&jinwei==1)			//判断是否溢出
	{
		cout<<"数据溢出"<<endl;
		long_int null_a;
		return null_a;
	}
	else
	{new_size=new_size>i-1?new_size:i-1;}
	return long_int(result,new_size);
}
long_int long_int::operator++()
//重载加法
{
	int i,jinwei=0;
	for(i=1;i<=size||size==0;i++)
	{
		array[200-i]+=1;
		if(array[200-i]==10)
		{
			array[200-i]=0;
			jinwei=1;
		}
		else {jinwei=0;}
		if(jinwei==0) {break;}
	}
	
	if(i<=200||(i==201&&jinwei==0))			//判断是否溢出
	{
		if(jinwei!=0)	{array[200-i]=array[200-i]+jinwei;	size++;}	//判断最高位
		if(size==0)		{size++;}		//当长整数为0时
	}
	else 
	{
		cout<<"数据溢出"<<endl;
		size=0;
	}
	return *this;
}
long_int long_int::operator+(unsigned short i)
//重载加法,处理溢出时有问题
{
	for(unsigned short k=0;k<i;k++) 
	{
		++(*this);
		if(size==0)
		{
			return *this;	
		}
	}
	return *this;
}


long_int long_int::operator-(const long_int& p)
//重载减法
{
	int result[200],new_size=0,jiewei=0,last=0,judge=0,i=0;	
	//结果存在result中,jiewei为是否有借位,last为其个位值,judge判断够不够减;
	if(size>p.size)		{judge=1;}
	else if(size==p.size)
	{
		for(i=1;i<=size;i++)
		{
			if(array[200-i]==p.array[200-i])	
			{
				if(i==size)	{judge=0;}
				continue;
			}
			else if(array[200-i]>p.array[200-i])	{judge=1;	break;}
			else {judge=-1;	break;}
		}	
	}
	else {judge=-1;}
	switch(judge)
	{
	case 1:
		for(i=0;i<200;i++)		{result[i]=array[i];}
		for(i=1;i<=p.size;i++)
		{
			result[200-i]-=p.array[200-i];	//两数相减
			result[200-i]-=jiewei;		//减去借位的值
			if(result[200-i]<0)			//做各位上的减法
			{
			result[200-i]+=10;
			jiewei=1;
			}
			else {jiewei=0;}
		}

		while(jiewei!=0)
		{
			result[200-i]=result[200-i]-jiewei;		//判断是否有借位
			if(result[200-i]<0)			//做各位上的减法
			{
				result[200-i]=result[200-i]+10;
				jiewei=1;
			}
			else {jiewei=0;}
			i++;
		}
		if(i==size+1&&result[200-size]==0)		{new_size=size-1;}
		else {new_size=size;}
		break;
	case -1:
		cout<<"不够减!"<<endl;
		break;
	case 0:
		for(i=0;i<200;i++)	{result[i]=0;	new_size=0;}
		break;
	}
	return long_int(result,new_size);
}
long_int long_int::operator--()
//重载减法
{
	if(size==0)		{cout<<"不够减!"<<endl;		return *this;}
	for(int i=1;i<=200;i++)
	{
		if(array[200-i]==0)		
		{
			array[200-i]=9;	
		}
		else {array[200-i]=array[200-i]-1;	break;}
	}
	if(size==i&&array[200-size]==0)	{size-=1;}
	return *this;
}
long_int long_int::operator-(unsigned short i)
//重载减法
{
	for(unsigned short k=0;k<i;k++) 
	{
		--(*this);
		if(size==0)	{cout<<"不够减!"<<endl;	break;}
	}
	return *this;
}

long_int long_int::operator*(const long_int& p)
//重载乘法
{
	long_int result(*this),count;
	int judge=0;
	if(size==0||p.size==0)	{return count;}
	for(int i=0;i<200;i++)	{count.array[i]=p.array[i];	}
	count.size=p.size;
	for(i=0;;i++)
	{
		--count;
		if(count.size==0)	{break;}
		result=result+(*this);
		if(result.size>size)		{judge=1;}
		else if(result.size==size)
		{
			for(int j=1;j<=size;j++)
			{
				if(result.array[200-j]==array[200-j])	{continue;}
				else if(result.array[200-j]>array[200-j])	{judge=1;}
				else {judge=-1;}
			}	
		}
		else {judge=-1;}
		if(judge<=0) {break;}
	}
	return result;
}
long_int long_int::operator*(unsigned short i)
//重载乘法,没考虑出界
{	
	long_int p;
	if(i==0||(*this).size==0)	{return p;}
	for(unsigned short k=0;k<i;k++)
	{
		p=(*this)+p;
	}
	return p;
}

long_int long_int::operator/(const long_int& p)
//重载除法
{
	long_int result,last_result;			
	//result用来做被除数,last_result储存最后结果,add做加1 的作用
	int judge=0;	//判断是否已经结束

	result=*this;
	if(p.size==0) {cout<<"除数为0,无法除!"<<endl;	return last_result;}
	while(1)
	{
		if(result.size>p.size)		{judge=1;}
		else if(result.size==p.size)
		{
			for(int i=1;i<=result.size;i++)
			{
				if(result.array[200-i]==p.array[200-i])	
				{
					if(i==result.size)		{judge=0;}
					continue;
				}
				else if(result.array[200-i]>p.array[200-i])	{judge=1;	break;}
				else {judge=-1;	break;}
			}	
		}
		else {judge=-1;}
		if(judge==1)
		{
			result=result-p;
		}
		else break;
		++last_result;
	}
	if(judge==0)	{++last_result;}
	return last_result;
}

istream& operator>>(istream& ist,long_int& p)
//重载输入符号
{
	char char_int[200];
	int result[200];
	for(int i=0;i<200;i++)	{char_int[i]='\0';}
	ist>>char_int;
	for(i=0;i<200;i++)
	{
		if(char_int[i]!='\0')
		{
			result[i]=char_int[i]-'0';
		}
		else {break;}
	}
	p.size=i;
	if(i==1&&char_int[0]=='0')	{p.size=0;}
	for(int k=1;k<=i;k++)
	{
		p.array[200-k]=result[i-k];
	}
	return ist;
}

ostream& operator<<(ostream& ost,long_int p)
//重载输出符号
{
	if(p.size>0)
	{
		int i=0;
		for(i=p.size;i>0;i--)
		{
			if(p.array[200-i]!=0)	{break;}
		}
		for(;i>0;i--)
		{
			ost<<p.array[200-i];
		}
	}
	else {ost<<'0';}
	ost<<endl;
	return ost;
}