hugeint.cpp

将大数看作一个n进制数组

//与另一个大数做乘法,并把结果给自己
HugeInt& HugeInt::operator*=(HugeInt& A)
{
	HugeInt X = *this;
	X = X * A;
	*this= X;
	return *this;
}

//与long做乘法,并把结果给自己
HugeInt&  HugeInt::operator*=(long A)
{
	HugeInt X = *this;
	X = X * A;
	*this= X;
	return *this;
}

//与字符串做乘法,并把结果给自己
HugeInt&  HugeInt::operator*=(CString& A)
{
	HugeInt X = *this;
	X = X * A;
	
	*this= X;
	return *this;
}

//计算两个大数的商
HugeInt HugeInt::operator/(HugeInt& A)
{
	HugeInt X,Y,Z;
	int len;
	unsigned __int64 num,div;
	unsigned long carry = 0;
	//Y为被除数
	Y=(*this);
	//商只为整数,如果Y<A那么＝0,如果Y=A那么＝1,否则计算
	while(Y.Cmp(A)>0)
	{
		//比较最大位数值
		if(Y.m_ulValue[Y.m_nLength-1] > A.m_ulValue[A.m_nLength-1])
		{
			len = Y.m_nLength - A.m_nLength;
			div = Y.m_ulValue[Y.m_nLength-1]/(A.m_ulValue[A.m_nLength-1]+1);
		}
		//如果Y的最大位数值小于A的最大位数值,并且Y的位数大于A的位数
		else if(Y.m_nLength>A.m_nLength)
		{
			len = Y.m_nLength-A.m_nLength-1;
			num = Y.m_ulValue[Y.m_nLength-1];
			//mun借一位
			num = (num<<32) + Y.m_ulValue[Y.m_nLength-2];
			//做除法
			if(A.m_ulValue[A.m_nLength-1]==0xffffffff)
				div = (num>>32);
			else
				div = num/(A.m_ulValue[A.m_nLength-1]+1);
		}
		else
		{
			X=(X + (1));
			break;
		}
		Z= div;
		Z.m_nLength += len;
		//为Z移位
		for(int i=Z.m_nLength-1; i>=len; i--)
			Z.m_ulValue[i] = Z.m_ulValue[i-len];
		for(i=0; i<len;i++)
			Z.m_ulValue[i] =0;
		//为X赋值
		X=X+Z;
		Z=Z*A;
		Y=Y-Z;
	}
	if(Y.Cmp(A) == 0)
		X=X + 1;
	if(m_nSign * A.m_nSign==-1)
		X.m_nSign=-1;
	else 
		X.m_nSign=1;
	
	return X;
}

//计算大数和long相除
HugeInt HugeInt::operator/(long A)
{
	//利用operator/(HugeInt& A)完成操作
	HugeInt X = *this;
	HugeInt hiA(A);

	return (X/hiA);
}

//计算大数和字符串相除
HugeInt HugeInt::operator/(CString& A)
{
	//利用operator/(HugeInt& A)完成操作
	HugeInt X = *this;
	HugeInt hiA(A);

	return (X/hiA);
}

//与另一个大数做除法,并把结果给自己
HugeInt& HugeInt::operator/=(HugeInt& A)
{
	HugeInt X = *this;
	X = X / A;
	*this= X;
	return *this;
}

//与long做除法,并把结果给自己
HugeInt& HugeInt::operator/=(long A)
{
	HugeInt X = *this;
	X = X / A;
	*this= X;
	return *this;
}

//与字符串做除法,并把结果给自己
HugeInt& HugeInt::operator/=(CString& A)
{
	HugeInt X = *this;
	X = X / A;
	*this= X;
	return *this;
}

//计算两个大数的余数
HugeInt HugeInt::operator%(HugeInt& A)
{
	//Y为商
	HugeInt X,Y;
	int len;
	unsigned __int64 num,div;
	unsigned long carry=0;
	X=(*this);
	//同除法
	while(X.Cmp(A)>0)
	{ 
		//X.m_nSign=1;
		if(X.m_ulValue[X.m_nLength-1]>A.m_ulValue[A.m_nLength-1])
		{
			len=X.m_nLength-A.m_nLength;
			div=X.m_ulValue[X.m_nLength-1]/(A.m_ulValue[A.m_nLength-1]+1);
		}
		else if(X.m_nLength>A.m_nLength)
		{
			len=X.m_nLength-A.m_nLength-1;
			num=X.m_ulValue[X.m_nLength-1];
			num=(num<<32)+X.m_ulValue[X.m_nLength-2];
			if(A.m_ulValue[A.m_nLength-1]==0xffffffff)
				div=(num>>32);
			else 
				div=num/(A.m_ulValue[A.m_nLength-1]+1);
		}
		else
		{
			X=(X-(A));
			break;
		}
		Y=div;
		Y=Y*A;
		Y.m_nLength+=len;
		for(int i=Y.m_nLength-1;i>=len;i--)
			Y.m_ulValue[i]=Y.m_ulValue[i-len];
		for(i=0;i<len;i++)
			Y.m_ulValue[i]=0;
		//得到临时余数
		X=(X-(Y));
	}
	if(X.Cmp(A)==0)
		X=0;
	return X;
}

//计算大数与long求余
HugeInt HugeInt::operator%(long A)
{
	//利用operator%(HugeInt& A)完成操作
	HugeInt X = *this;
	HugeInt hiA(A);

	return X%hiA;
}

//计算大数与字符串求余
HugeInt HugeInt::operator%(CString& A)
{
	//利用operator%HugeInt& A)完成操作
	HugeInt X = *this;
	HugeInt hiA(A);

	return X%hiA;
}

//与另一个大数做求余,并把结果给自己
HugeInt& HugeInt::operator%=(HugeInt& A)
{
	HugeInt X = *this;
	X = X % A;
	*this= X;
	return *this;
}

//与long做求余,并把结果给自己
HugeInt& HugeInt::operator%=(long A)
{
	HugeInt X = *this;
	X = X % A;
	*this= X;
	return *this;
}

//与字符串做求余,并把结果给自己
HugeInt& HugeInt::operator%=(CString& A)
{
	HugeInt X = *this;
	X = X % A;
	*this= X;
	return *this;	
}

//判断是否大于另一个大数
int HugeInt::operator>(HugeInt& A)
{
	HugeInt X = *this;
	if(X.Cmp(A)==1)
		return 1;
	else return 0;
}

//判断是否大于一个long型数
int HugeInt::operator>(long A)
{
	HugeInt B(A);
	HugeInt X = *this;
	if(X.Cmp(B)==1)
		return 1;
	else return 0;
}

//判断是否大于一个字符串
int HugeInt::operator>(CString& A)
{
	HugeInt B(A);
	HugeInt X = *this;
	if(X.Cmp(B)==1)
		return 1;
	else return 0;
}

//判断是否大于等于另一个大数
int HugeInt::operator>=(HugeInt& A)
{
	HugeInt X = *this;
	if((X.Cmp(A)==1) || (X.Cmp(A) == 0))
		return 1;
	else return 0;
}

//判断是否大于等于一个long型数
int HugeInt::operator>=(long A)
{
	HugeInt B(A);
	HugeInt X = *this;
	if((X.Cmp(B)==1) || (X.Cmp(B) == 0))
		return 1;
	else return 0;
}

//判断是否大于等于一个字符串
int HugeInt::operator>=(CString& A)
{
	HugeInt B(A);
	HugeInt X = *this;
	if((X.Cmp(B)==1) || (X.Cmp(B) == 0))
		return 1;
	else return 0;
}

//判断是否小于另一个大数
int HugeInt::operator<(HugeInt& A)
{
	HugeInt X = *this;
	if(X.Cmp(A)==-1) 
		return 1;
	else return 0;
}

//判断是否小于一个long型数
int HugeInt::operator<(long A)
{
	HugeInt B(A);
	HugeInt X = *this;
	if(X.Cmp(B)==-1) 
		return 1;
	else return 0;
}

//判断是否小于一个字符串
int HugeInt::operator<(CString& A)
{
	HugeInt B(A);
	HugeInt X = *this;
	if(X.Cmp(B)==-1) 
		return 1;
	else return 0;
}

//判断是否小于等于另一个大数
int HugeInt::operator<=(HugeInt& A)
{
	HugeInt X = *this;
	if((X.Cmp(A)==-1) || (X.Cmp(A) == 0))
		return 1;
	else return 0;
}

//判断是否小于等于一个long型数
int HugeInt::operator<=(long A)
{
	HugeInt B(A);
	HugeInt X = *this;
	if((X.Cmp(B)==-1) || (X.Cmp(B) == 0))
		return 1;
	else return 0;
}

//判断是否小于等于一个字符串
int HugeInt::operator<=(CString& A)
{
	HugeInt B(A);
	HugeInt X = *this;
	if((X.Cmp(B)==-1) || (X.Cmp(B) == 0))
		return 1;
	else return 0;
}

//判断是否等于另一个大数
int HugeInt::operator==(HugeInt& A)
{
	HugeInt X = *this;
	if(X.Cmp(A) == 0)
		return 1;
	else return 0;
}

//判断是否等于一个long型数
int HugeInt::operator==(long A)
{
	HugeInt B(A);
	HugeInt X = *this;
	if(X.Cmp(B) == 0)
		return 1;
	else return 0;
}

//判断是否等于一个字符串
int HugeInt::operator==(CString& A)
{
	HugeInt B(A);
	HugeInt X = *this;
	if(X.Cmp(B) == 0)
		return 1;
	else return 0;
}

//判断是否不等于等于另一个大数
int HugeInt:: operator!=(HugeInt& A)
{
	HugeInt X = *this;
	if(X.Cmp(A)!=0)
		return 1;
	else return 0;
}

//判断是否不等于一个long型数
int HugeInt::operator!=(long A)
{
	HugeInt B(A);
	HugeInt X = *this;
	if(X.Cmp(B)!=0)
		return 1;
	else return 0;
}

//判断是否不等于一个字符串
int HugeInt::operator!=(CString& A)
{
	HugeInt B(A);
	HugeInt X = *this;
	if(X.Cmp(B)!=0)
		return 1;
	else return 0;
}

//++在前
HugeInt& HugeInt::operator++()
{
	HugeInt X = *this;
	X += 1;
	HugeInt Y = X;
	*this = X;
	return Y;
}

//++在后
HugeInt& HugeInt::operator++(int)
{

	HugeInt X = *this;
	HugeInt Y = X;
	X += 1;
	*this = X;
	return Y ;
}

//--在前
HugeInt& HugeInt:: operator--()
{
	HugeInt X = *this;
	X -= 1;
	HugeInt Y = X;
	*this = X;
	return Y;
}

//--在后
HugeInt& HugeInt::operator--(int)
{
	HugeInt X = *this;
	HugeInt Y = X;
	X -= 1;
	*this = X;
	return Y ;
}

//输出运算符<<
ostream& HugeInt::operator<<(ostream& out)
{
	CString result;

	char temp[20] = "";
	for(int i=m_nLength-1; i>=0;i--)
	{
		
		result += _i64toa(m_ulValue[i],temp,10);
		result += ",";
	}
	result = result.Left(result.GetLength()-1);
	
	return (out<< result);
        
}

//输出字符串
CString HugeInt::toString()
{
	//HugeInt A(m_nSign,m_nLength,m_ulValue);
	CString result;

	char temp[20] = "";
	for(int i=m_nLength-1; i>=0;i--)
	{
		
		result += _i64toa(m_ulValue[i],temp,10);
		result += ",";
	}
	result = result.Left(result.GetLength()-1);
	return result;
}