自定义大整数类（初次版本）

最新推荐文章于 2024-05-30 16:17:47 发布
最新推荐文章于 2024-05-30 16:17:47 发布
阅读量194 收藏
点赞数 3
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42944928/article/details/138263337
版权

例子：

#include "X:\Work\Share\CCode\CPlatform\MathExt\_MathExt_out.h"
 
using namespace lf;
using namespace std;
 
 

int main()
{
    
    _Integer i1 = _t("12345678989764581381214575686787987979234234354364");

        
    _Integer  i2 = _t("1234567898976458138121");

    _pcn(i1 / i2);


    _Integer i3 = 6, i4 = -9, i5 = 234;

    _pcn(i3);

    if (i3 > i4)
    {
        std::cout << "i3 > i4" << "\n";
    }
    if (i3 > i5)
    {
        std::cout << "i3 > i5" << "\n";
      
    }

 
    for (_Integer i = 0; i < 10; i++)
    {
        _pcn(i);
    }

  

    for (_Integer i = 10; i > 0;  --i)
    {
        _pcn(i);
    }
 
   return 0;
     
}

运行结果：

_Integer.h

/*******************************************************************************************
文件名			： _Integer.h

作者				： 李锋

手机				： 13828778863

Email			： ruizhilf@139.com

功能				： 可以表示无限整数的类

创建时间			： 2024-04-15

最后一次修改时间	:  2024-04-28


********************************************************************************************/ 
#pragma once

#include "_MathExt_in.h"

_LF_BEGIN_


/// <summary>
/// 用链接表示的十进制数整数
/// </summary>
/// 创建时间：2024-04-15    最后一次修改时间：2024-04-15
class _Integer : public _Object
{
private:
	/// <summary>
	/// 表示当前数字字符串
	/// </summary>
	_string _num;

	/// <summary>
	/// 是否为负数
	/// </summary>
	bool  _IsNegative;

	void _InitData();

public:

 

	/// <summary>
	/// 【中文】：充许的书写格式
	/// 【英文】：Allowed writing format
	/// 001 不可以
	/// -1  不可以
	/// +5  不可以
	/// 3a  不可以
	/// 318，000 不可以
	/// </summary>
	/// <param name="sNum"></param>
	/// <returns></returns>
	/// 创建时间：2024-04-26    最后一次修改时间：2024-04-26   
	static bool IsAllowedWritingFormat(const _string& sNum);


	static void Check(const _string& sNum);


	/// <summary>
	/// 无符号的两个整数相加 (参考自星飞星火）
	/// </summary>
	/// <param name="num1"></param>
	/// <param name="num2"></param>
	/// <returns></returns>
	/// 创建时间：2024-04-21    最后一次修改时间：2024-04-21   
	static _string Add(const _string& num1, const _string& num2);


	/// <summary>
	/// 无符号的两个整数相减，部分算法参考自星飞星火，但星火
	/// 算的结果只有同位数相减才正确，注意：这里是假定是无符
	/// 号两个整数相减。
	/// 【中文】：两个数相减
	/// 【英文】：Subtract two numbers
	/// 百度文心一言和星飞星火结果不对。
	/// </summary>
	/// <param name="num1"></param>
	/// <param name="num2"></param>
	/// <returns></returns>
	/// 创建时间：2024-04-21    最后一次修改时间：2024-04-25 （已测试）
	static _string Subtract(const _string& num1, const _string& num2, bool isCheckForamt = true);

	/// <summary>
	/// 无符号的两个整数相减（使用标准库）
	/// </summary>
	/// <param name="num1"></param>
	/// <param name="num2"></param>
	/// <returns></returns>
	static std::string Subtract_std(const std::string& num1, const std::string& num2);

	/// <summary>
	/// 无符号的两个整数相剩 (参考自星飞星火）
	/// 【中文】：两个数相乘
	/// 【英文】：Multiplication of two numbers
	/// </summary>
	/// <param name="sNum1"></param>
	/// <param name="sNum2"></param>
	/// <returns></returns>
	/// 创建时间：2024-04-21    最后一次修改时间：2024-04-21  （已测试）
	static _string Multiplication(const _string& sNum1, const _string& sNum2, bool isCheckForamt = true);



	/// <summary>
	/// sNum1 / sNum2 ，sNum1 的倍数受制于int所能表达的最大值
	/// </summary>
	/// <param name="sNum1"></param>
	/// <param name="sNum2"></param>
	/// <param name="isCheckForamt"></param>
	/// <returns></returns>
	/// 创建时间：2024-04-26    最后一次修改时间：2024-04-27  （已测试）
	static _Pair<int, _string> SmallDiv(const _string& sNum1, const _string& sNum2, bool isCheckForamt = true);


	/// <summary>
	/// 【单词中英文对照】：两个数相除 - Divide two numbers
	/// 
	/// 百度文心一言和星飞星火结果不对。
	/// </summary>
	/// 创建时间：2024-04-25    最后一次修改时间：2024-04-26   (已测式，这个函数用了大约1整天时间，搞死人）
	static _string Divide(const _string& sNum1, const _string& sNum2, bool isCheckForamt = true);

  
public://-----------------------------构造

	_Integer();
	_Integer(const _Integer& integer);
	_Integer(const int& iValue);
	_Integer(const _string& sNum);


	/// <summary>
	/// 
	/// </summary>
	/// <param name="pStr"></param>
	/// 创建时间：2024-04-15    最后一次修改时间：2024-04-15
	_Integer(const _char*  pStr);
public:



public: //----------------------------运算符重载


	/// <summary>
	/// 
	/// </summary>
	/// <param name="iVlue"></param>
	/// <returns></returns>
	/// 创建时间：2024-04-15    最后一次修改时间：2024-04-15
	bool  operator==(const int& iVlue);

 
	/// <summary>
	/// 
	/// </summary>
	/// <param name="right"></param>
	/// <returns></returns>
	/// 创建时间：2024-04-15    最后一次修改时间：2024-04-15
	_Integer operator*(const _Integer& r)const;


	/// <summary>
	/// 
	/// </summary>
	/// <param name="right"></param>
	/// <returns></returns>
	/// 创建时间：2024-04-15    最后一次修改时间：2024-04-15
	_Integer operator/(const _Integer& r)const;

	/// <summary>
	/// 
	/// </summary>
	/// <param name="right"></param>
	/// <returns></returns>
	/// 创建时间：2024-04-15    最后一次修改时间：2024-04-15
	_Integer operator+(const _Integer& r)const;

	/// <summary>
	/// 
	/// </summary>
	/// <param name="right"></param>
	/// <returns></returns>
	/// 创建时间：2024-04-15    最后一次修改时间：2024-04-15
	_Integer operator-(const _Integer& r)const;


	/// <summary>
	/// 前置加加
	/// </summary>
	/// <returns></returns>
	/// 创建时间：2024-04-28    最后一次修改时间：2024-04-28
	_Integer& operator++();


	/// <summary>
	/// 
	/// </summary>
	/// <returns></returns>
	/// 创建时间：2024-04-28    最后一次修改时间：2024-04-28
	_Integer& operator--();


	/// <summary>
	/// 后置加加
	/// </summary>
	/// <param name=""></param>
	/// <returns></returns>
	/// 创建时间：2024-04-28    最后一次修改时间：2024-04-28
	_Integer operator++(int);


	/// <summary>
	/// 
	/// </summary>
	/// <param name=""></param>
	/// <returns></returns>
	/// 创建时间：2024-04-28    最后一次修改时间：2024-04-28
	_Integer operator--(int);


	/// <summary>
	/// 表达式：前缀负号 (- obj)
	/// </summary>
	/// <returns></returns>
	/// 创建时间：2024-04-15    最后一次修改时间：2024-04-15
	_Integer operator-() const;

	/// <summary>
	/// 	
	/// </summary>
	/// <param name="l"></param>
	/// <param name="r"></param>
	/// <returns></returns>
	/// 创建时间：2024-04-19    最后一次修改时间：2024-04-28
	friend bool operator>(const _Integer& l, const _Integer& r);

	/// <summary>
	/// 
	/// </summary>
	/// <param name="l"></param>
	/// <param name="r"></param>
	/// <returns></returns>
	/// 创建时间：2024-04-19    最后一次修改时间：2024-04-19
	friend bool operator < (const _Integer& l, const _Integer& r);




	/// <summary>
	/// 
	/// </summary>
	/// <param name="l"></param>
	/// <param name="r"></param>
	/// <returns></returns>
	/// 创建时间：2024-04-19    最后一次修改时间：2024-04-19
	friend bool operator== (const _Integer& l, const _Integer& r);

	friend bool operator!= (const _Integer& l, const _Integer& r);

public: //----------------------------功能函数
 

	virtual _string ToSplitString(const _string& splitString) const override;
public:
  
};


_LF_END_

_Integer.cpp

#include"_Integer.h"

_LF_BEGIN_



void _Integer::_InitData()
{
	_IsNegative = false;
}

bool _Integer::IsAllowedWritingFormat(const _string& sNum)
{

	/// 001 不可以
	/// -1  不可以
	/// +5  不可以
	/// 3a  不可以
	/// 318，000 不可以

	if (!sNum.IsAllArabicDigitString())
		return false;

	//001
	if (sNum[0] == _t('0') && sNum.Length > 1) //排除0
		return false;

	return true;
}

void _Integer::Check(const _string& sNum)
{
	if (sNum.Length == 0)
	{
		_string sErrorText = _t("sNum.Length == 0 传递空字符串。\n");

		ga.Print(sErrorText);
		assert(false);
	}
	if (!IsAllowedWritingFormat(sNum))
	{
		_string sErrorText = _t(" “") + sNum + _t("” 不是正确的书写格式！\n");
		ga.Print(sErrorText);
		assert(false);
	}
}



/// <summary>
/// 无符号的两个整数相加 (参考自星飞星火）
/// </summary>
/// <param name="num1"></param>
/// <param name="num2"></param>
/// <returns></returns>
/// 创建时间：2024-04-21    最后一次修改时间：2024-04-28 
_string _Integer::Add(const _string& num1, const _string& num2)
{
	/*
	std::string add(const std::string &num1, const std::string &num2) {
		int len1 = num1.size();
		int len2 = num2.size();
		int maxLen = std::max(len1, len2);
		std::string result(maxLen + 1, '0');

		int carry = 0;
		for (int i = 0; i < maxLen; i++) {
			int sum = carry;
			if (i < len1) {
				sum += num1[len1 - 1 - i] - '0';
			}
			if (i < len2) {
				sum += num2[len2 - 1 - i] - '0';
			}
			carry = sum / 10;
			sum %= 10;
			result[maxLen - i] = sum + '0';
		}
		if (carry > 0) {
			result[0] = carry + '0';
		} else {
			result.erase(result.begin());
		}

		return result;
	}
	*/
	 
	 
	int len1 = num1.std_size();
	int len2 = num2.std_size();
	int maxLen = _Math::Max(len1, len2);
	_string result(maxLen + 1, _t('0'));

	int carry = 0;
	for (int i = 0; i < maxLen; i++) {
		int sum = carry;
		if (i < len1) {
			sum += num1[len1 - 1 - i] - _t('0');
		}
		if (i < len2) {
			sum += num2[len2 - 1 - i] - _t('0');
		}
		carry = sum / 10;
		sum %= 10;
		result[maxLen - i] = sum + _t('0');
	}
	if (carry > 0) {
		result[0] = carry + _t('0');
	}
	else {
		//result.std_erase(result.std_begin());	 
		return result.SubStr(1, result.Length - 1);
	}

	return result;
}


/// <summary>
/// 无符号的两个整数相减，部分算法参考自星飞星火，但星火
/// 算的结果只有同位数相减才正确，注意：这里是假定是无符
/// 号两个整数相减。
/// 【中文】：两个数相减
/// 【英文】：Subtract two numbers
/// 百度文心一言和星飞星火结果不对。
/// </summary>
/// <param name="num1"></param>
/// <param name="num2"></param>
/// <returns></returns>
/// 创建时间：2024-04-21    最后一次修改时间：2024-04-25 （已测试）
_string _Integer::Subtract(const _string& num1, const _string& num2, bool isCheckForamt)
{
	if (isCheckForamt){	Check(num1);	Check(num2);}
	/*
	*   星火给出的代码：
	* 
		int len1 = num1.size();
		int len2 = num2.size();
		int maxLen = std::max(len1, len2);
		std::string result(maxLen, '0');

		int iBorrow = 0;
		for (int i = 0; i < maxLen; i++) {
			int iDiff = num1[len1 - 1 - i] - num2[len2 - 1 - i] - iBorrow;
			if (iDiff < 0) {
				iDiff += 10;
				iBorrow = 1;
			}
			else {
				iBorrow = 0;
			}
			result[maxLen - 1 - i] = iDiff + '0';
		}

		result.erase(std::find_if(result.rbegin(), result.rend(), [](char ch) { return ch != '0'; }).base(), result.end());

		return result;
	*/
	  
	int len1 = num1.Length;
	int len2 = num2.Length;

	int maxLen = _Math::Max(len1, len2);
	  
	_string sResult(_t(""), maxLen + 1);

	//这里先比较字符串长度（数字位数）的大小
	if (len1 > len2){	 //num1 > num2
		int iBorrow = 0;
		for (int i = 0; i < len2; i++) {
			int iDiff = num1[len1 - 1 - i] - num2[len2 - 1 - i] - iBorrow;		 
			if (iDiff < 0) {
				iDiff += 10;
				iBorrow = 1;
			}
			else {
				iBorrow = 0;
			}
			sResult.Add(iDiff + _t('0'));
		} 

		if (iBorrow != 0){
			bool bBorrow = false;
			for (int i = len2; i < len1; i++){
				_char c = num1[len1 - i - 1];
				if (!bBorrow){
					if (c == _t('0')) {
						sResult.Add(_t('9'));
					}else{
						sResult.Add(c - 1);
						bBorrow = true;
					}
				}else{
					sResult.Add(c);
				}
			}
		}else{
			for (int i = len2; i < len1; i++){
				_char c = num1[len1 - i - 1];
				sResult.Add(c);
			}
		}	
		 
		sResult.TrimRight(_t('0'));  //除去尾部的0
		return sResult.Reversal();		 

	}else if(len1 == len2){//字符长度相等
		if (num1 > num2){
			int iBorrow = 0;
			for (int i = 0; i < len2; i++) {
				int iDiff = num1[len1 - 1 - i] - num2[len2 - 1 - i] - iBorrow;
				if (iDiff < 0) {
					iDiff += 10;
					iBorrow = 1;
				}
				else {
					iBorrow = 0;
				}
				sResult.Add(iDiff + _t('0'));
			}
			sResult.TrimRight(_t('0')); //除去尾部的0
			return sResult.Reversal();
		}else if(num1 == num2){
			return _t("0");
		}else{
			int iBorrow = 0;
			for (int i = 0; i < len2; i++) {
				int iDiff = num2[len1 - 1 - i] - num1[len2 - 1 - i] - iBorrow;
				if (iDiff < 0) {
					iDiff += 10;
					iBorrow = 1;
				}
				else {
					iBorrow = 0;
				}
				sResult.Add(iDiff + _t('0'));
			}
			 
			sResult.TrimRight(_t('0')); //除去尾部的0
			sResult.Add(_t('-'));
			
			return sResult.Reversal();
		}

	}else{  //len1 < len2  小数减大数
		int iBorrow = 0;
		for (int i = 0; i < len1; i++) {
			int iDiff = num2[len2 - 1 - i] - num1[len1 - 1 - i] - iBorrow;
			if (iDiff < 0) {
				iDiff += 10;
				iBorrow = 1;
			}
			else {
				iBorrow = 0;
			}
			sResult.Add(iDiff + _t('0'));
		}

		if (iBorrow != 0) {  //还需借一位
			bool bBorrow = false;
			for (int i = len1; i < len2; i++) {
				_char c = num2[len2 - i - 1];
				if (!bBorrow) {
					if (c == _t('0')) {
						sResult.Add(_t('9'));
					}
					else {
						sResult.Add(c - 1);
						bBorrow = true;
					}
				}
				else {
					sResult.Add(c);
				}
			}
		}
		else {
			for (int i = len1; i < len2; i++) {
				_char c = num2[len2 - i - 1];
				sResult.Add(c);
			}
		}

	
		sResult.TrimRight(_t('0'));
		sResult.Add(_t("-"));
		return sResult.Reversal();
	}

}

std::string _Integer::Subtract_std(const std::string& num1, const std::string& num2)
{
	int len1 = num1.size();
	int len2 = num2.size();
	int maxLen = std::max(len1, len2);
	std::string result(maxLen, '0');

	int iBorrow = 0;
	for (int i = 0; i < maxLen; i++) {
		int iDiff = num1[len1 - 1 - i] - num2[len2 - 1 - i] - iBorrow;
		if (iDiff < 0) {
			iDiff += 10;
			iBorrow = 1;
		}
		else {
			iBorrow = 0;
		}
		result[maxLen - 1 - i] = iDiff + '0';
	}

	result.erase(std::find_if(result.rbegin(), result.rend(), [](char ch) { return ch != '0'; }).base(), result.end());

	return result;
}
  
 
/// <summary>
/// 无符号的两个整数相剩 (参考自星飞星火）
/// 【中文】：两个数相乘
/// 【英文】：Multiplication of two numbers
/// </summary>
/// <param name="sNum1"></param>
/// <param name="sNum2"></param>
/// <returns></returns>
/// 创建时间：2024-04-21    最后一次修改时间：2024-04-21  （已测试）
_string _Integer::Multiplication(const _string& sNum1, const _string& sNum2,  bool isCheckForamt)
{
	if (isCheckForamt) { Check(sNum2);	Check(sNum2); }

	  /*
		int len1 = num1.size();
		int len2 = num2.size();
		std::vector<int> result(len1 + len2, 0);

		for (int i = len1 - 1; i >= 0; i--) {
			for (int j = len2 - 1; j >= 0; j--) {
				int product = (num1[i] - '0') * (num2[j] - '0');
				int sum = result[i + j + 1] + product;
				result[i + j + 1] = sum % 10;
				result[i + j] += sum / 10;
			}
		}

		std::string res;
		for (int num : result) {
			if (!res.empty() || num != 0) {
				res.push_back(num + '0');
			}
		}

		return res.empty() ? "0" : res;
	  */
	 
	size_t len1 = sNum1.Length;
	size_t len2 = sNum2.Length;

	_Array<_byte> result(len1 + len2);   //设置缓冲长度为 len1 + len2
	result.ZeroBufferAll();            //把缓冲区初始为0
	result.ResetLength(len1 + len2);  //重设长度

	/*
	123
	 11

		33    (3)  i = 2 j = 1（个位+3） i + j = 3 刚好是第4位 (3) i = 2 j = 0  （十位加3）
	   22
	  11	
	________
	  1353 
	*/
	for (int i = len1 - 1; i >= 0; i--) {
		for (int j = len2 - 1; j >= 0; j--) {
			int product = (sNum1[i] - '0') * (sNum2[j] - '0'); //总量 n * n
			int sum = result[i + j + 1] + product;  //
			result[i + j + 1] = sum % 10; 
			result[i + j] += sum / 10;
		}
	}

	_string sTmp(_t(""), result.Length);
	
	/*
	//15*15 = 0225  (第一位是0）
	size_t nStart = (*result.Data == 0) ? 1 : 0;
 
	for(size_t n = nStart; n < result.Length; ++n)		 
		sTmp.Add( *(result.Data + n) + 48);
	*/

	for (_byte b : result) {
		if (sTmp.Length > 0 || b != 0) {  //如果前面有非零的数字，则添加 
			sTmp.Add(b + 48);
		}
	}

	return sTmp.Length == 0 ? _t("0") : sTmp;
}

 
/// <summary>
/// sNum1 / sNum2 ，sNum1 的倍数受制于int所能表达的最大值
/// </summary>
/// <param name="sNum1"></param>
/// <param name="sNum2"></param>
/// <param name="isCheckForamt"></param>
/// <returns></returns>
/// 创建时间：2024-04-26    最后一次修改时间：2024-04-27  （已测试）
_Pair<int, _string> _Integer::SmallDiv(const _string& sNum1, const _string& sNum2, bool isCheckForamt)
{
	if (isCheckForamt) { Check(sNum1);	Check(sNum2); }

	if (sNum2 == _t("0"))
	{
		
		d.PrintError(_t("除数不能为零"), _t("_Integer::SmallDiv"));
		assert(false);
	}

	if (sNum1.Length < sNum2.Length)
		return _Pair<int, _string>(0, sNum1);

	if (sNum1.Length == sNum2.Length)
	{
		if (sNum1 > sNum2)
		{
			int nNear = (sNum1[0] - 48) / (sNum2[0] - 48 ) + 1;
		
			for (int n = nNear; n > 0; --n)
			{
				_string sn = ga.intToString(n);
				_string s = _Integer::Multiplication(sNum2, sn, false); //乘积
				_string r = _Integer::Subtract(sNum1, s, false); //余数


				if (r[0] == _t('-'))
				{

				}
				else if (r == _t("0"))
				{
					return _Pair<int, _string>(n, _t("0"));
				}	
				else
				{
					if (r.Length < sNum2.Length)
					{
						return _Pair<int, _string>(n, r);
					}
					else if (r.Length == sNum2.Length)
					{
						if (r < sNum2)
						{
							return _Pair<int, _string>(n, r);
						}
						else if (r == sNum2)
						{
							return _Pair<int, _string>(n + 1, _t("0"));
						}
					}
				}
			}
		}
		else if (sNum1 == sNum2)
		{
			return _Pair<int, _string>(1, _t("0"));
		}
		else
		{
			return _Pair<int, _string>(0, sNum1);
		}
	}
	else //sNum1.Length > sNum2.Length
	{
		int nNear =  _Math::pow(10, sNum1.Length - sNum2.Length) * (sNum1[0] -48 + 1) - 1;

		//_pin(nNear);

		for (int n = nNear; n > 0; --n)
		{
			_string sn = ga.intToString(n);
			_string s = _Integer::Multiplication(sNum2, sn, false); //乘积
			_string r = _Integer::Subtract(sNum1, s, false); //余数
				
			if (r[0] == _t('-'))
			{

			}
			else if (r == _t("0"))
			{
				return _Pair<int, _string>(n, _t("0"));
			}
			else
			{
				if (r.Length < sNum2.Length)
				{
					return _Pair<int, _string>(n, r);
				}
				else if (r.Length == sNum2.Length)
				{
					if (r < sNum2)
					{
						return _Pair<int, _string>(n, r);
					}
					else if (r == sNum2)
					{
						return _Pair<int, _string>(n + 1, _t("0"));
					}
				}

			}
		}
	}

	std::wcout <<  _t("错误：\n");
	_pcn(sNum1);
	_pcn(sNum2);

	assert(false);

	return _Pair<int, _string>(0, _t("错误！"));
}

/// <summary>
/// 【单词中英文对照】：两个数相除 - Divide two numbers
/// 
/// 百度文心一言和星飞星火结果不对。
/// </summary>
/// 创建时间：2024-04-25    最后一次修改时间：2024-04-26   (已测式，这个函数用了大约1整天时间，搞死人）
_string _Integer::Divide(const _string& sNum1, const _string& sNum2,bool isCheckForamt)
{	 
	if (isCheckForamt) { Check(sNum1);	Check(sNum2); }

	 
	if (sNum2 == _t("0"))
	{
		_string sError = _t("_string _Integer::Divide: 除数 sNum2 不能为零不能为 0  ！");

		_cout << sError <<"\n";

		assert(false);		 
	}


	_string sResult(_t(""), sNum1.Length);
 
	//2024/4 nPos =  4-1 = 3     sSub = 24  Point = 2 - 1 - 1(2<4) = 0   s = sSub ""
	//2124/4 nPos =  4-1 = 3
	//2124/23 nPos = 4-2 - 1 = 1
	 
	_string sSub = sNum1.SubStr(0, sNum2.Length); //除数

	auto p = SmallDiv(sSub, sNum2, false);

	int nStart = sNum2.Length;

	//获取第一位，确保第一次 p.Fist不等于0
	if (p.First == 0) {

		sSub = sNum1.SubStr(0, sNum2.Length + 1);
	 
		p = SmallDiv(sSub, sNum2, false);

		nStart = sNum2.Length + 1;
	}
		

	for( int i = nStart; i <=  sNum1.Length; ++i){

		if (p.First > 0) {//商不为0 

			sResult.Add(_tostr(p.First));

			if (p.Second == _t("0")) { //商不为0，余数为0

				sSub = sNum1.SubStr(i, 1);		

			}else{	 //商不为0，余数不为0

				sSub = p.Second + sNum1.SubStr(i, 1);	
			}

			if(sSub.Length > 0)
				p = SmallDiv(sSub, sNum2, false);

		}else {     //--------------------------------商为零

			sResult.Add(_t("0"));

			if (p.Second == _t("0")) { //--------------商为0，余数为0
				sSub = sNum1.SubStr(i, 1); 
			}
			else {	//----------------------------商为0，余数不为0			
				sSub = p.Second + sNum1.SubStr(i, 1);
			}

			if (sSub.Length > 0)
				p = SmallDiv(sSub, sNum2, false);
		}		
	}
	
	return sResult;
	 
}

_Integer::_Integer()
{
	_InitData();

	_num = "0";
}

_Integer::_Integer(const _Integer& integer)
{
	_num = integer._num;

	_IsNegative = integer._IsNegative;
}

_Integer::_Integer(const int& iValue)
{
	if (iValue < 0){
		_IsNegative = true;
		_num = _tostr(-iValue);
	}else{
		_IsNegative = false;
		_num = _tostr(iValue);
	} 
}
 
_Integer::_Integer(const _string& sNum)
{
	assert(sNum.Length > 0);

	if (sNum[0] == _t('-')){
		_IsNegative = true;

		_num = sNum.SubStr(1, sNum.Length - 1);

	}else{
		_IsNegative = false;

		_num = sNum;
	}

	Check(_num);
}
 
_Integer::_Integer(const _char* pStr)
{
	assert(pStr != null);

	_string sNum(pStr);

	assert(sNum.Length != 0);


	if (sNum[0] == _t('-')) {
		_IsNegative = true;

		_num = sNum.SubStr(1, sNum.Length - 1);

	}
	else {
		_IsNegative = false;

		_num = sNum;
	}

	Check(_num);
}



bool _Integer::operator==(const int& iVlue)
{
	if (iVlue > 0) {
		_string sNum = _tostr(iVlue);
		return _num == sNum && _IsNegative == false;
	}else {
		_string sNum = _tostr(-iVlue);
		return _num == sNum && _IsNegative == true;
	} 
}


 

_Integer _Integer::operator*(const _Integer& right) const
{
	_Integer sum;

	sum._num = Multiplication(_num, right._num);

	sum._IsNegative = !((_IsNegative && right._IsNegative) || (!_IsNegative && !right._IsNegative));

	return sum;
}

_Integer _Integer::operator/(const _Integer& r) const
{
	_Integer tmp;

	tmp._num = _Integer::Divide(_num, r._num);

	tmp._IsNegative = (_IsNegative != r._IsNegative);

	return tmp;
}


_Integer _Integer::operator+(const _Integer& right) const
{
	if (_IsNegative == false && right._IsNegative == false) {//丙个正数相加
		_Integer tmp;

		tmp._num = Add(_num, right._num); 

		return tmp;
	}
	else if (_IsNegative == false && right._IsNegative == true) { //正数+负数
		return  *this - (-right);
	}
	else if (_IsNegative == true && right._IsNegative == false) { //负数+正数
		return right - (-*this);
	}
	else if (_IsNegative == true && right._IsNegative == true) { //两个负数相加
		return -((-*this) + (-right));
	}
}



_Integer _Integer::operator-(const _Integer& right) const
{
	if (*this < right)
	{
		return -(right - *this);
	}else{

		if (_IsNegative == false && right._IsNegative == false) {//丙个正数相减
 
			return Subtract(_num, right._num);
		}
		else if (_IsNegative == false && right._IsNegative == true) { //正数-负数
			return  *this + (-right);
		}
		else if (_IsNegative == true && right._IsNegative == false) { //负数-正数
			return -((-*this) + right);
		}
		else if (_IsNegative == true && right._IsNegative == true) { //两个负数相减
			return (-right) - *this;
		}
	}

}



/// <summary>
/// 前置加加
/// </summary>
/// <returns></returns>
_Integer& _Integer::operator++()
{	 
	_num = Add(_num, "1");
	 
	return *this;
}

_Integer& _Integer::operator--()
{
	_num = Subtract(_num, "1");

	return *this;
}

_Integer _Integer::operator++(int)
{
	_string sNum = _num;

	_num = Add(_num, "1");

	return sNum;	 
}


_Integer _Integer::operator--(int)
{
	_string sNum = _num;

	_num = Subtract(_num, "1");

	return sNum;
}

_Integer _Integer::operator-() const
{
	//前缀负号
	_Integer iResult = *this;
	iResult._IsNegative = !iResult._IsNegative;

	return iResult;
}

 
 


_string _Integer::ToSplitString(const _string& splitString) const
{
	if (_IsNegative)
		return _t("-") + _num;
	else 
		return _num;
   
}


bool operator>(const _Integer& l, const _Integer& r)
{ 
	if (l._IsNegative == true && r._IsNegative == true) // - - 两个负数
	{
		if (l._num.Length > r._num.Length)
			return false;
		else if (l._num.Length == r._num.Length)
			return l._num < r._num;
		else
			return true;
	}
	else if (l._IsNegative == true && r._IsNegative == false) //- +
	{  
		return false;
	}
	else if (l._IsNegative == false && r._IsNegative == true)  //+ -
	{
		if (l._num != _t("") || r._num != _t(""))
			return true;
		else
			return false;
	}
	else if (l._IsNegative == false && r._IsNegative == false) //+ +
	{
		if (l._num.Length > r._num.Length)
			return true;
		else if (l._num.Length == r._num.Length)
			return l._num  > r._num;
		else
			return false;
	}

	return false;
}


bool operator<(const _Integer& l, const _Integer& r)
{
	if (l > r)
		return false;
	if (l == r)
		return false;

	return true;
}



bool operator==(const _Integer& l, const _Integer& r)
{
	return l._IsNegative == r._IsNegative && l._num == r._num;
}

bool operator!=(const _Integer& l, const _Integer& r)
{
	if (l == r)
		return false;

	return true;
}

_LF_END_

碧海蓝天2022
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
[Python从零到壹] 十四.机器学习之分类算法五万字总结全网首发（决策树、KNN、SVM、分类对比实验）
杨秀璋的专栏
07-09 1万+
分类（Classification）属于有监督学习（Supervised Learning）中的一类，它是数据挖掘、机器学习和数据科学中一个重要的研究领域。分类模型类似于人类学习的方式，通过对历史数据或训练集的学习得到一个目标函数，再用该目标函数预测新数据集的未知属性。本章主要讲述分类算法基础概念，并结合决策树、KNN、SVM分类算法案例分析各类数据集，从而让读者学会使用Python分类算法分析自己的数据集，研究自己领域的知识，从而创造价值。 19.1 分类 19.1.1 分类模型 与前面讲述的聚类模型类似
自定义View的流程总结学习
后知后觉者！
10-02 360
自定义View是一个老生常谈的问题，对于一个Android开发者来说是必须掌握的知识点，也是Android开发进阶的必经之路。 要想安卓理解自定义View的流程，首先我们要了解View的绘制流程。分析之前，我们先来看底下面这张图： View的绘制流程 DecorView是一个应用窗口的根容器，它本质上是一个FrameLayout。DecorView有唯一一个子View，它是一个垂直LinearL...
基于ERNIR3.0的文本多分类
wangqiaowq的博客
03-01 1411
110M参数通用模型ERNIE 3.0 Base280M参数重量级通用模型ERNIE 3.0 XBase74M轻量级通用模型ERNIE 3.0 Medium文档链接： https://github.com/PaddlePaddle/ERNIEERNIE模型汇总ERNIE模型汇总。
【 kmeans实现遥感图像分类（matlab实现）】
weixin_42183989的博客
01-15 2823
kmeans实现遥感图像分类matlab实现
python init函数传入类实例_Python new 类方法和 init 实例方法以及单例模式的简单讨论...
weixin_39902608的博客
02-19 124
“Python 中的类都是单例模式？” 一天，一同事问我这样一个问题。这是一个奇怪的问题，可能你也这么认为。这里先不做解释，我们先来看看 __new__ 和 __init__ 方法。new 与 init__new__ 方法属于新式类，即属于 object 类。它是一个静态方法，但是其第一个参数必须是一个类(cls)，这有点像一个 classmethod，其实将其看成是一个类方法也可以。该特殊方法被...
【C语言进阶】 详解自定义类型：结构体，枚举，联合
m0_71731682的博客
07-12 1697
位段，C语言允许在一个结构体中以位为单位来指定其成员所占内存长度，这种以位为单位的成员称为“位段”或称“位域”( bit field)。利用位段能够用较少的位数存储数据。位段和结构体其实是非常相似的，但是有两个不同点：1. 位段的成员必须是或signed int。2. 位段的成员名后边有一个冒号和一个数字。举个例子struct Aint _a : 2;int _b : 5;首先我们要明白位段中的这个“位”字其实指的是二进制位。我们知道一个二进制位就是1个比特位。所以，A中。
7.串口通信uart编写思路及自定义协议
weixin_62622990的博客
12-21 1546
*更改变量 BEGIN-- *///引入该.h可使用//引入该.h可使用//引入该.h可使用//从索引2开始赋值/*更改变量 END-- */协议头0x2c,0x12协议尾0x5b，想要让协议数据位变多，只需要修改变量RxBuffer1[]的定义即可//解析接收的数据 最多11哥，两个帧头，一个帧尾，其他是数据位uint8_t i;//计数u8 pi=0;//打印调试if(RxState==0&&com_data==0x2C) //0x2c帧头 RxCounter1==1。
自定义类型（结构体）
m0_70236468的博客
03-26 31
如上代码块，其中跟在结构体定义之后的S，L和main函数中的i , n都属于结构体变量，两者不同的是在main函数外的S,L属于全局变量，而i,n属于局部变量。
【git】(task1)git基础和常用命令
发现问题，并解决问题，批判性思维
05-17 1302
git add是个多功能命令，可以理解为“精确地将内容添加到下一次提交中”而不是“将一个文件添加到项目中”要更加合适。： 可以用它开始跟踪新文件， 把已跟踪的文件放到暂存区， 合并时把有冲突的文件标记为已解决状态等。 如果修改了跟踪中的CONTRIBUTING.md文件，再git status可以发现文件 CONTRIBUTING.md 出现在 Changes not staged for commit 这行下面，说明已跟踪文件的内容发生了变化，但还没有放到暂存区。 要暂存这次更新，需要运
Bigint大整数类
07-16
包含大整数的各种运算函数，如加法、减法、乘法、除法、取余等
大整数类bigint
07-16
大整数类bigint，包含大整数的加法、乘法、除法等运算
大整数类求圆周率
11-28
自己重载了一个大整数的类，并且使用它求π，可以精确到120多位有效数字。 将代码和生产文件一并打包。
进行大型计算的大整数类
11-15
自己定义的一个大的整数类，可以进行+ - * / ^(平方) % ++ -- += -= *= /= ^= %=的算术运算和> < >= 的逻辑运算，并且可以用Print()或者用cout直接进行输出操作。 使用的时候可直接粘贴代码至CPP或.h文件，或更改...
C++大整数类
04-13
大整数，可是输入任意位数的整数，示例出100内质数之和
Leecode---347：输出前k个高频元素（使用unordered_map）
最新发布
qq_41920323的博客
05-30 244
unordered_map实现输出前k个高频元素
算法训练营day41
stmfresher的博客
05-27 328
动态规划理论基础（主要就是确定动态规划的几个步骤）
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 454
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
一千题，No.0037（组个最小数）
2301_76783671的博客
05-29 583
给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0 不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……整数间用一个空格分隔。10 个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。现给定数字，请编写程序输出能够组成的最小的数。在一行中输出能够组成的最小的数。
python大整数类
09-05
Python中没有专门的大整数类。在Python中，整数类型(int)可以无限制地表示任意大小的整数。当整数超过计算机的表示范围时，Python会自动转换为高精度计算，也称为大数计算。这意味着Python可以处理非常大的整数，而...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值