hugeinteger.cpp

一些C++的课件和实验源代码

/*********************************************************************\
* Copyright (c) 2004 by Wangtao, School of Computer and Information   *
*           Technology, Beijing Jiaotong University, Beijing.         *
*           All Rights Reserved.                                      *
*                                                                     *
* Date：2004-07-26                                                    *
*                                                                     *
* Author：王涛                                                        *
*                                                                     *
* Filename：HugeInteger.cpp                                           *
*                                                                     *
* Description：CHugeInteger类的实现文件                               *
*     支持大数运算.                                                   *
*                                                                     *
* Modify List：                                                       *
*     2004-07-26  created by wangtao                                  *
*		  实现了加减乘除及乘方,阶乘等接口.                            *
*                                                                     *
*                                                                     *
\*********************************************************************/


#include "stdafx.h"
#include "HugeInteger.h"
#include "math.h"

#define BITNUM_UINT	(sizeof(unsigned int) * 8)

/*******************************************************\
 * 函数：CHugeInteger()                                *
 * 功能：构造函数                                      *
 * 输入：无                                            *
 * 输出：无                                            *
 * 返回：无                                            *
\*******************************************************/
CHugeInteger::CHugeInteger()
{
	memset(m_ulValue, 0, sizeof(unsigned int) * HI_MAXLEN);

	m_nSign = 0;
	m_nLength = 1;
}

/*******************************************************\
 * 函数：CHugeInteger()                                *
 * 功能：构造函数                                      *
 * 输入：nNum --- 原数                                 *
 * 输出：无                                            *
 * 返回：无                                            *
\*******************************************************/
CHugeInteger::CHugeInteger(int nNum)
{
	memset(m_ulValue, 0, sizeof(unsigned int) * HI_MAXLEN);

	if(nNum > 0){
		m_nSign = 1;
		m_nLength = 1;
		m_ulValue[0] = nNum;
	}
	else if(nNum < 0){
		m_nSign = -1;
		m_nLength = 1;
		m_ulValue[0] = abs(nNum);
	}
	else{
		m_nSign = 0;
		m_nLength = 1;
	}
}

/*******************************************************\
 * 函数：CHugeInteger()                                *
 * 功能：构造函数                                      *
 * 输入：llNum --- 原数                                *
 * 输出：无                                            *
 * 返回：无                                            *
\*******************************************************/
CHugeInteger::CHugeInteger(unsigned __int64 llNum)
{
	memset(m_ulValue, 0, sizeof(unsigned int) * HI_MAXLEN);
	
	if(llNum == 0){
		m_nSign = 0;
	}
	else{
		m_nSign = 1;
	}

	m_ulValue[0] = (unsigned int)llNum;
	m_ulValue[1] = (unsigned int)(llNum >> BITNUM_UINT);

	if(m_ulValue[1] > 0){
		m_nLength = 2;
	}
	else{
		m_nLength = 1;
	}
}

/*******************************************************\
 * 函数：CHugeInteger(const CHugeInteger&)             *
 * 功能：拷贝构造函数                                  *
 * 输入：hInteger --- 原数                             *
 * 输出：无                                            *
 * 返回：无                                            *
\*******************************************************/
CHugeInteger::CHugeInteger(const CHugeInteger& hInteger)
{
	m_nSign = hInteger.m_nSign;
	m_nLength = hInteger.m_nLength;
	memcpy(m_ulValue, hInteger.m_ulValue, sizeof(unsigned int) * HI_MAXLEN);
}

CHugeInteger::~CHugeInteger()
{
}

/*******************************************************\
 * 函数：ToDouble()                                    *
 * 功能：将超大整数转换为double类型表示                *
 * 输入：无                                            *
 * 输出：无                                            *
 * 返回：*this                                         *
\*******************************************************/
double CHugeInteger::ToDouble()
{
	double dval = 0;
	for(int i = 0; i < m_nLength; i++){
		double dmatter = 0xFFFFFFFF;
		dval += m_ulValue[i] * pow(dmatter, i);
	}
	return dval;
}

//UINT CHugeInteger::ToUINT()
//{
//	return m_ulValue[0];
//}


/*******************************************************\
 * 函数：operator = ()                                 *
 * 功能：赋值操作符                                    *
 * 输入：nNum --- 原数                                 *
 * 输出：无                                            *
 * 返回：*this                                         *
\*******************************************************/
CHugeInteger& CHugeInteger::operator = (int nNum)
{
	memset(m_ulValue, 0, sizeof(unsigned int) * HI_MAXLEN);

	if(nNum > 0){
		m_nSign = 1;
		m_nLength = 1;
		m_ulValue[0] = nNum;
	}
	else if(nNum < 0){
		m_nSign = -1;
		m_nLength = 1;
		m_ulValue[0] = abs(nNum);
	}
	else{
		m_nSign = 0;
		m_nLength = 1;
	}

	return *this;
}

/*******************************************************\
 * 函数：operator = ()                                 *
 * 功能：赋值操作符                                    *
 * 输入：llNum --- 原数                                *
 * 输出：无                                            *
 * 返回：*this                                         *
\*******************************************************/
CHugeInteger& CHugeInteger::operator = (unsigned __int64 llNum)
{
	memset(m_ulValue, 0, sizeof(unsigned int) * HI_MAXLEN);
	
	if(llNum == 0){
		m_nSign = 0;
	}
	else{
		m_nSign = 1;
	}

	m_ulValue[0] = (unsigned int)llNum;
	m_ulValue[1] = (unsigned int)( llNum >> BITNUM_UINT );

	if(m_ulValue[1] > 0){
		m_nLength = 2;
	}
	else{
		m_nLength = 1;
	}

	return *this;
}

/*******************************************************\
 * 函数：operator = ()                                 *
 * 功能：赋值操作符                                    *
 * 输入：right --- 原数                                *
 * 输出：无                                            *
 * 返回：*this                                         *
\*******************************************************/
CHugeInteger& CHugeInteger::operator = (const CHugeInteger& right)
{
	m_nSign = right.m_nSign;
	m_nLength = right.m_nLength;
	memcpy(m_ulValue, right.m_ulValue, sizeof(unsigned int) * HI_MAXLEN);

	return *this;
}

/*******************************************************\
 * 函数：operator == ()                                *
 * 功能：比较两个数是否相等                            *
 * 输入：right --- 被比较数                            *
 * 输出：无                                            *
 * 返回：true  --- *this == right                      *
 *       false --- *this != right                      *
\*******************************************************/
bool CHugeInteger::operator == (CHugeInteger& right)
{
	if(Compare(right) == 0){
		return true;
	}
	else{
		return false;
	}
}

bool CHugeInteger::operator == (int right)
{
	CHugeInteger hnright = right;
	return *this == hnright;
}

/*******************************************************\
 * 函数：operator != ()                                *
 * 功能：比较两个数是否不等                            *
 * 输入：right --- 被比较数                            *
 * 输出：无                                            *
 * 返回：true  --- *this != right                      *
 *       false --- *this == right                      *
\*******************************************************/
bool CHugeInteger::operator != (CHugeInteger& right)
{
	if(Compare(right) != 0){
		return true;
	}
	else{
		return false;
	}
}

bool CHugeInteger::operator != (int right)
{
	CHugeInteger hnright = right;
	return *this != hnright;
}

/*******************************************************\
 * 函数：operator > ()                                 *
 * 功能：比较两个数大小                                *
 * 输入：right --- 被比较数                            *
 * 输出：无                                            *
 * 返回：true  --- *this > right                       *
 *       false --- *this <= right                      *
\*******************************************************/
bool CHugeInteger::operator >  (CHugeInteger& right)
{
	if(Compare(right) > 0){
		return true;
	}
	else{
		return false;
	}
}

bool CHugeInteger::operator >  (int right)
{
	CHugeInteger hnright = right;
	return *this > hnright;
} 

/*******************************************************\
 * 函数：operator >= ()                                *
 * 功能：比较两个数大小                                *
 * 输入：right --- 被比较数                            *
 * 输出：无                                            *
 * 返回：true  --- *this >= right                      *
 *       false --- *this < right                       *
\*******************************************************/
bool CHugeInteger::operator >= (CHugeInteger& right)
{
	if(Compare(right) >= 0){
		return true;
	}
	else{
		return false;
	}
}

bool CHugeInteger::operator >= (int right)
{
	CHugeInteger hnright = right;
	return *this >= hnright;
}

/*******************************************************\
 * 函数：operator < ()                                 *
 * 功能：比较两个数大小                                *
 * 输入：right --- 被比较数                            *
 * 输出：无                                            *
 * 返回：true  --- *this < right                       *
 *       false --- *this >= right                      *
\*******************************************************/
bool CHugeInteger::operator <  (CHugeInteger& right)
{
	if(Compare(right) < 0){
		return true;
	}
	else{
		return false;
	}
}

bool CHugeInteger::operator <  (int right)
{
	CHugeInteger hnright = right;
	return *this < hnright;
}

/*******************************************************\
 * 函数：operator <= ()                                *
 * 功能：比较两个数大小                                *
 * 输入：right --- 被比较数                            *
 * 输出：无                                            *
 * 返回：true  --- *this <= right                      *
 *       false --- *this > right                       *
\*******************************************************/
bool CHugeInteger::operator <= (CHugeInteger& right)
{
	if(Compare(right) <= 0){
		return true;
	}
	else{
		return false;
	}
}
    

bool CHugeInteger::operator <= (int right)
{
	CHugeInteger hnright = right;
	return *this <= hnright;
}

/*******************************************************\
 * 函数：operator += ()                                *
 * 功能：计算两个数相加的和                            *
 * 输入：right --- 加数                                *
 * 输出：无                                            *
 * 返回：和                                            *
\*******************************************************/
CHugeInteger CHugeInteger::operator + (CHugeInteger& right)
{
	CHugeInteger result;

	if(m_nSign == 0){
		result = right;
		return result;
	}
	if(right.m_nSign == 0){
		result = *this;
		return result;
	}

	if(m_nSign == right.m_nSign)
	{
		int carry = 0;