c++大整数运算

已于 2023-12-27 16:47:10 修改
阅读量1k 收藏 3
点赞数 1
分类专栏： 实现与例题 文章标签： c++ 开发语言
于 2020-09-01 17:58:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/seanbill/article/details/108347482
版权

头文件

#ifndef __BIGINT__INCLUDE__
#define  __BIGINT__INCLUDE__

#include <vector>
#include <iostream>



namespace XDC{
	//大整数
	class BigInt{
	public:
		enum SIGN :char{
			NEGATIVE = -1,	//负数
			POSITIVE = 1	//正数
		};

		typedef std::vector<char> BIType;


		BigInt();
		/*explicit*/ BigInt(ll input);
		BigInt(BIType , char = 1);
		~BigInt();

		BigInt(const BigInt &input);
		BigInt(const BigInt &&input);


		BigInt operator+(const ll input)const;
		BigInt operator+(const BigInt &input)const;
		BigInt operator+(const BigInt &&input)const;


		BigInt operator-(const ll input)const;
		BigInt operator-(const BigInt &input)const;
		BigInt operator-(const BigInt &&input)const;


		BigInt operator*(const ll input)const;
		BigInt operator*(const BigInt &input)const;
		BigInt operator*(const BigInt &&input)const;

		BigInt operator/(const ll input)const;
		BigInt operator/(const BigInt &input)const;
		BigInt operator/(const BigInt &&input)const;

		BigInt operator%(const ll input)const;
		BigInt operator%(const BigInt &input)const;
		BigInt operator%(const BigInt &&input)const;

		BigInt &operator=(const ll input);
		BigInt &operator=(const BigInt &input);
		BigInt &operator=(const BigInt &&input);


		BigInt &operator+=(const ll input);
		BigInt &operator+=(const BigInt &input);
		BigInt &operator+=(const BigInt &&input);


		BigInt &operator-=(const ll input);
		BigInt &operator-=(const BigInt &input);
		BigInt &operator-=(const BigInt &&input);

		BigInt &operator*=(const ll input);
		BigInt &operator*=(const BigInt &input);
		BigInt &operator*=(const BigInt &&input);

		BigInt &operator/=(const ll input);
		BigInt &operator/=(const BigInt &input);
		BigInt &operator/=(const BigInt &&input);

		BigInt &operator%=(const ll input);
		BigInt &operator%=(const BigInt &input);
		BigInt &operator%=(const BigInt &&input);

		//前缀++
		BigInt operator++();
		//后缀++
		BigInt operator++(int);

		//前缀--
		BigInt operator--();
		//后缀--
		BigInt operator--(int);

		bool operator<(const ll input)const;
		bool operator<(const BigInt &input)const;
		bool operator<(const BigInt &&input)const;

		bool operator==(const ll input)const;
		bool operator==(const BigInt &input)const;
		bool operator==(const BigInt &&input)const;

		bool operator>(const ll input)const;
		bool operator>(const BigInt &input)const;
		bool operator>(const BigInt &&input)const;

		bool operator<=(const ll input)const;
		bool operator<=(const BigInt &input)const;
		bool operator<=(const BigInt &&input)const;

		bool operator>=(const ll input)const;
		bool operator>=(const BigInt &input)const;
		bool operator>=(const BigInt &&input)const;

		//
		//BigInt &operator>>(const ll input);
		//BigInt &operator>>(const BigInt &input);

		//BigInt &operator<<(const ll input);
		//BigInt &operator<<(const BigInt &input);

		friend std::ostream & operator<<(std::ostream &os, const BigInt &input);

		friend BigInt operator+(ll num, BigInt &bint);
		friend BigInt operator-(ll num, BigInt &bint);
		friend BigInt operator*(ll num, BigInt &bint);
		friend BigInt operator/(ll num, BigInt &bint);
		friend BigInt operator%(ll num, BigInt &bint);

		ll operator()(void);

		char GetElement(int i)const;

		//单纯比较数字 那个大
		bool IsBig(const BigInt &input)const;
		
		//零值
		bool IsZero()const;

		//1
		bool IsOne()const;

		//-1
		bool IsNegativeOne()const;
		//
		unsigned int  GetLen()const;

		//符号
		char GetSign()const;

		//
		void OppositeNum();

		//取相反数 改变原数
		BigInt & GetOppositeNum_All();

		//取相反数 不改变原数
		BigInt  GetOppositeNum_Part()const;

		//规范化 去掉前面无意义的零
		void Regular();

		ll GetValue();
	private:
		BIType			 m_element;	//数字0-9 反序存放  
		char			 m_sign;		//符号标记
		
	};
	extern const BigInt ILLEGAL;
	extern const BigInt m_outMin;
	extern const BigInt m_outMax;
};
//using namespace XDC;
#endif // __BIGINT__INCLUDE__

实现

//#include "BigInt.h"

namespace XDC{
	/
	const BigInt ILLEGAL = { {}, 2 };
	const BigInt m_outMax = { { 9, 2, 2, 3, 3, 7, 2, 0, 3, 6, 8, 5, 4, 7, 7, 5, 8, 0, 7 },  BigInt::SIGN::POSITIVE };
	const BigInt m_outMin = { { 9, 2, 2, 3, 3, 7, 2, 0, 3, 6, 8, 5, 4, 7, 7, 5, 8, 0, 8 },  BigInt::SIGN::NEGATIVE };
	

	BigInt::BigInt() :m_element{}, m_sign(POSITIVE){

		//std::cout << "BigInt()" << std::endl;

	}

	BigInt::BigInt(ll input)
	{
		//std::cout << "BigInt(ll input)" << std::endl;
		m_sign = POSITIVE;
		m_element.clear();
		if (input < 0) m_sign = NEGATIVE;

		if (input == LLONG_MIN){
			//long long int 最小值 = -9223372036854775808
			m_element = { 9, 2, 2, 3, 3, 7, 2, 0, 3, 6, 8, 5, 4, 7, 7, 5, 8, 0, 8 };
			m_sign = NEGATIVE;
		}
		else{
			ll back = std::abs(input);
			int temp = 0;
			while (back){
				temp = back % 10;
				m_element.emplace_back(temp);
				back /= 10;
			}
		}
	}

	BigInt::BigInt(BIType arr, char type){
		m_element = arr;
		m_sign = type;
	}

	BigInt::~BigInt()
	{
		//std::cout << "~BigInt()" << std::endl;

		m_element.clear();
	}

	BigInt::BigInt(const BigInt &input)
	{
		//std::cout << "BigInt(const BigInt \&input)" << std::endl;

		m_sign = input.m_sign;
		m_element = input.m_element;
	}

	BigInt::BigInt(const BigInt &&input)
	{
		//std::cout << "BigInt(const BigInt \&\&input)" << std::endl;

		m_sign = input.m_sign;
		m_element = input.m_element;
	}

	BigInt  BigInt::operator+(const ll input)const
	{
		return *this + BigInt(input);
	}

	// + + - -
	BigInt  BigInt::operator+(const BigInt &input)const
	{
		if (this->IsZero()) return input;
		else if (input.IsZero()) return *this;

		//异号 转化为减法运算
		if (this->GetSign() != input.GetSign() ) return (this->GetSign() == POSITIVE) ? ((*this) - input.GetOppositeNum_Part()) : (input-this->GetOppositeNum_Part());

		//转化为大数加小数
		if ( this->GetLen() < input.GetLen()) return input + (*this);

		BigInt back = *this;

		//carry进位标记
		unsigned len = input.GetLen();
		int carry = 0;

		for (unsigned int i = 0; i < len; ++i){
			back.m_element[i] += carry + input.m_element[i];
			carry = back.m_element[i] / 10;
			back.m_element[i] %= 10;
		}

		while (carry){
			//容量不够 且有进位 扩张
			if (back.GetLen() <= len) {
				back.m_element.emplace_back(carry); carry = 0;
			}
			else{
				back.m_element[len] += carry;
				carry = back.m_element[len] / 10;
				back.m_element[len] %= 10;
				++len;
			}
		}

		return back;
	}

	// + + - -
	BigInt  BigInt::operator+(const BigInt &&input)const
	{
		//先排除0
		if (this->IsZero()) return input;
		else if (input.IsZero()) return *this;

		//异号 转化为减法运算
		if ( this->GetSign() != input.GetSign() ) return (this->GetSign() == POSITIVE) ? ((*this) - input.GetOppositeNum_Part()) : ((input)-this->GetOppositeNum_Part());

		//转化为长数加短数
		if ( this->GetLen() < input.GetLen() ) return input + (*this);

		BigInt back = *this;


		//carry进位标记
		unsigned int len = input.GetLen();
		int carry = 0;

		for (unsigned int i = 0; i < len; ++i){
			back.m_element[i] += carry + input.m_element[i];
			carry = back.m_element[i] / 10;
			back.m_element[i] %= 10;
		}

		while (carry){
			//容量不够 且有进位 扩张
			if (back.GetLen() <= len) {
				back.m_element.emplace_back(carry); carry = 0;
			}
			else{
				//是否产生新的进位
				back.m_element[len] += carry;
				carry = back.m_element[len] / 10;
				back.m_element[len] %= 10;
				++len;
			}
		}

		return back;
	}

	BigInt  BigInt::operator-(const ll input) const
	{
		return *this - BigInt(input);
	}

	BigInt  BigInt::operator-(const BigInt &input)const
	{

		//异号 把负号提进去 变成 同号相加
		if (this->GetSign() != input.GetSign()) return *this + input.GetOppositeNum_Part();
		//同号 并且是 - - - 变成 -（+ - +)
		else if (this->GetSign() == NEGATIVE) return (this->GetOppositeNum_Part() - input.GetOppositeNum_Part()).GetOppositeNum_Part();

		//只剩下 + - +了 变成大数 - 小数
		if (input > *this) return (input - *this).GetOppositeNum_Part();

		BigInt back = *this;

		//借位
		char borrow = 0;

		int len = input.GetLen();

		for (int i = 0; i < len; ++i){
			back.m_element[i] -= input.m_element[i] + borrow;
			if (back.m_element[i] < 0){
				back.m_element[i] += 10;
				borrow = 1;
			}
			else
				borrow = 0;
		}

		if (borrow){
			back.m_element[len] -= 1;
		}

		//去掉无意义的前缀零
		back.Regular();

		return back;
	}

	BigInt  BigInt::operator-(const BigInt &&input)const
	{
		//异号 把负号提进去 变成 同号相加
		if (this->GetSign() != input.GetSign()) return *this + input.GetOppositeNum_Part();
		//同号 并且是 - - - 变成 -（+ - +)
		else if (this->GetSign() == NEGATIVE) return (this->GetOppositeNum_Part() - input.GetOppositeNum_Part()).GetOppositeNum_Part();

		//只剩下 + - +了 变成大数 - 小数
		if (input > *this) return (input - *this).GetOppositeNum_Part();

		BigInt back = *this;

		//借位
		char borrow = 0;

		int len = input.GetLen();

		for (int i = 0; i < len; ++i){
			back.m_element[i] -= input.m_element[i] + borrow;
			if (back.m_element[i] < 0){
				back.m_element[i] += 10;
				borrow = 1;
			}
			else
				borrow = 0;
		}

		if (borrow){
			back.m_element[len] -= 1;
		}

		back.Regular();

		return back;
	}

	BigInt  BigInt::operator*(const ll input)const
	{
		return *this * BigInt(input);
	}

	BigInt  BigInt::operator*(const BigInt &input)const
	{
		//自己乘自己 是否需要特殊处理

		//排除0
		if (this->IsZero() || input.IsZero()) return BigInt(0);

		//排除1 -1
		if (this->IsOne()) { return input; }
		else if (input.IsOne()) return *this;
		else if (this->IsNegativeOne()) {
			BigInt ret = input;
			ret.OppositeNum();
			return ret;
		}
		else if (input.IsNegativeOne()){
			BigInt ret = *this;
			ret.OppositeNum();
			return ret;
		}

		//变成长数 乘短数
		if (this->GetLen() < input.GetLen()) return input * *this;

		BigInt ret, back, _back = *this;

		//保存符号
		char _tempSign = this->GetSign() * input.GetSign();

		//排除符号对加法的影响
		_back.m_sign = POSITIVE;
		ret.m_sign = POSITIVE;


		unsigned char carry = 0, temp = 0;
		for (unsigned int i = 0; i < input.GetLen(); ++i)
		{
			//向前 个位 -> 十位 -> 百位 -> 千位 ... ,把被乘数的0 转移到乘数上(因为0乘以任何数都是0 没必要计算) 
			//每次取一位 乘以 乘数
			if (i) _back.m_element.insert(_back.m_element.begin(), 1, 0);

			back = _back;

			carry = 0; temp = input.m_element[i];

			for (unsigned int j = i; j < back.GetLen(); ++j){
				back.m_element[j] = back.m_element[j] * temp + carry;
				carry = back.m_element[j] / 10;
				back.m_element[j] %= 10;
			}
			if (carry){
				back.m_element.push_back(carry);
				carry = 0;
			}
			//和每一位相乘得到的结果相加
			ret += back;
		}

		//恢复符号
		ret.m_sign = _tempSign;

		return ret;
	}

	BigInt  BigInt::operator*(const BigInt &&input)const
	{
		//自己乘自己 是否需要特殊处理

		//排除0
		if (this->IsZero() || input.IsZero()) return BigInt(0);

		//排除1 -1
		if (this->IsOne()) { return input; }
		else if (input.IsOne()) return *this;
		else if (this->IsNegativeOne()) {
			BigInt ret = input;
			ret.OppositeNum();
			return ret;
		}
		else if (input.IsNegativeOne()){
			BigInt ret = *this;
			ret.OppositeNum();
			return ret;
		}

		//变成长数 乘短数
		if (this->GetLen() < input.GetLen()) return input * *this;

		BigInt ret, back, _back = *this;

		//保存符号
		char _tempSign = this->GetSign() * input.GetSign();

		//排除符号对加法的影响
		_back.m_sign = POSITIVE;
		ret.m_sign = POSITIVE;

		unsigned char carry = 0, temp = 0;
		for (unsigned int i = 0; i < input.GetLen(); ++i)
		{
			//向前 个位 -> 十位 -> 百位 -> 千位 ... ,把被乘数的0 转移到乘数上(因为0乘以任何数都是0 没必要计算) 
			//每次取一位 乘以 乘数
			if (i) _back.m_element.insert(_back.m_element.begin(), 1, 0);

			back = _back;

			carry = 0; temp = input.m_element[i];

			for (unsigned int j = i; j < back.GetLen(); ++j){
				back.m_element[j] = back.m_element[j] * temp + carry;
				carry = back.m_element[j] / 10;
				back.m_element[j] %= 10;
			}
			if (carry){
				back.m_element.push_back(carry);
				carry = 0;
			}
			//和每一位相乘得到的结果相加
			ret += back;
		}

		//恢复符号
		ret.m_sign = _tempSign;

		return ret;
	}

	BigInt BigInt::operator/(const ll input)const
	{
		return *this / BigInt(input);
	}

	BigInt BigInt::operator/(const BigInt &input)const
	{
		if (input.IsZero()) { 
			std::cout << "BigInt / error,dividend is zero" << std::endl;
			return ILLEGAL; 
		}

		if (input.IsBig(*this)) return BigInt(0);

		if (input.GetSign() == NEGATIVE) return (*this / input.GetOppositeNum_Part()).GetOppositeNum_Part();

		int len = this->GetLen(),left = 1,right = 10,mid = 0;

		BigInt back = 0, ret,temp;

		int iLen = input.GetLen();

		back.m_element.insert(back.m_element.end(), m_element.rbegin(), m_element.rbegin() + iLen - 1);

		std::reverse(back.m_element.begin(), back.m_element.end());

		for (int i = len - iLen; i >= 0; --i){

			back = back * 10 + m_element[i];

			if (back.GetLen() < input.GetLen() || back < input) { ret *= 10; continue; }

			//二分查找确定系数
			//1-10之间
			left = 1, right = 9;
			while (left < right){
				mid = (left + right + 1) >> 1;
				temp = input * mid;
				if (temp > back){
					right = mid - 1;
				}
				else
					left = mid;
			}

			ret = ret * 10 + left;
			back -= input * left;
		}

		//确定符号
		ret.m_sign = this->m_sign * input.m_sign;

		return ret;
	}

	BigInt BigInt::operator/(const BigInt &&input)const
	{
		if (input.IsZero()) {
			std::cout << "BigInt / error,dividend is zero" << std::endl;
			return BigInt(0);
		}

		if (input.GetSign() == NEGATIVE) return (*this / input.GetOppositeNum_Part()).GetOppositeNum_Part();

		if (input.IsBig(*this)) return BigInt(0);

		int len = this->GetLen(), left = 1, right = 10, mid = 0;

		BigInt back = 0, ret, temp;

		int iLen = input.GetLen();

		back.m_element.insert(back.m_element.end(), m_element.rbegin(), m_element.rbegin() + iLen - 1);

		std::reverse(back.m_element.begin(), back.m_element.end());

		for (int i = len - iLen; i >= 0; --i){

			back = back * 10 + m_element[i];
			
			if (back.GetLen() < input.GetLen() || back < input) { ret *= 10; continue; }

			//二分查找确定系数
			//1-10之间
			left = 1, right = 9;
			while (left < right){
				mid = (left + right + 1) >> 1;
				temp = input * mid;
				if (temp > back){
					right = mid - 1;
				}
				else
					left = mid;
			}

			ret = ret * 10 + left;
			back -= input * left;
		}

		//确定符号
		ret.m_sign = this->m_sign * input.m_sign;

		return ret;
	}

	BigInt BigInt::operator%(const ll input) const
	{
		return *this % BigInt(input);
	}

	BigInt BigInt::operator%(const BigInt &input) const
	{
		//排除0
		if (input.IsZero()) {
			std::cout << "BigInt / error,dividend is zero" << std::endl;
			return BigInt(0);
		}
		else if (this->IsZero())
			return BigInt(0);

		//input 不影响结果的符号
		if (input.GetSign() == NEGATIVE) return *this % input.GetOppositeNum_Part();

		//小数 % 大数 直接输出小数
		if (input.IsBig(*this)) return *this;

		int len = this->GetLen(), left = 1, right = 10, mid = 0;

		//默认所有操作都是正数的情况下进行
		BigInt back = 0, ret, temp;

		int iLen = input.GetLen();

		back.m_element.insert(back.m_element.end(), m_element.rbegin(), m_element.rbegin() + iLen - 1);

		std::reverse(back.m_element.begin(), back.m_element.end());

		for (int i = len - iLen; i >= 0; --i){

			back = back * 10 + m_element[i];

			if (back.GetLen() < input.GetLen() || back < input) { ret *= 10; continue; }

			//二分查找确定系数
			//1-10之间
			left = 1, right = 9;
			while (left < right){
				mid = (left + right + 1) >> 1;
				temp = input * mid;
				if (temp > back){
					right = mid - 1;
				}
				else
					left = mid;
			}

			ret = ret * 10 + left;
			back -= input * left;
		}

		//确定符号
		back.m_sign = this->m_sign;

		return back;
	}

	BigInt BigInt::operator%(const BigInt &&input) const
	{
		//排除0
		if (input.IsZero()) {
			std::cout << "BigInt / error,dividend is zero" << std::endl;
			return BigInt(0);
		}
		else if (this->IsZero())
			return BigInt(0);

		//input 不影响结果的符号
		if (input.GetSign() == NEGATIVE) return *this % input.GetOppositeNum_Part();

		//小数 % 大数 直接输出小数
		if (input.IsBig(*this)) return *this;

		int len = this->GetLen(), left = 1, right = 10, mid = 0;

		//默认所有操作都是正数的情况下进行
		BigInt back = 0, ret, temp;

		int iLen = input.GetLen();

		back.m_element.insert(back.m_element.end(), m_element.rbegin(), m_element.rbegin() + iLen - 1);

		std::reverse(back.m_element.begin(), back.m_element.end());

		for (int i = len - iLen; i >= 0; --i){

			back = back * 10 + m_element[i];

			if (back.GetLen() < input.GetLen() || back < input) { ret *= 10; continue; }

			//二分查找确定系数
			//1-10之间
			left = 1, right = 9;
			while (left < right){
				mid = (left + right + 1) >> 1;
				temp = input * mid;
				if (temp > back){
					right = mid - 1;
				}
				else
					left = mid;
			}

			ret = ret * 10 + left;
			back -= input * left;
		}

		//确定符号
		back.m_sign = this->m_sign;

		return back;
	}

	BigInt & BigInt::operator=(const ll input)
	{
		return *this = BigInt(input);
	}

	BigInt & BigInt::operator=(const BigInt &input)
	{
		m_sign = input.m_sign;
		m_element = input.m_element;
		return *this;
	}

	BigInt & BigInt::operator=(const BigInt &&input)
	{
		m_sign = input.m_sign;
		m_element = input.m_element;
		return *this;
	}

	BigInt & BigInt::operator+=(const ll input)
	{
		return *this += BigInt(input);
	}

	BigInt & BigInt::operator+=(const BigInt &input)
	{
		*this = *this + (input);

		return *this;
	}

	BigInt & BigInt::operator+=(const BigInt &&input)
	{
		*this = *this + (input);

		return *this;
	}

	BigInt & BigInt::operator-=(const ll input)
	{
		return *this -= BigInt(input);
	}

	BigInt & BigInt::operator-=(const BigInt &input)
	{
		*this = *this - (input);

		return *this;
	}


	BigInt & BigInt::operator-=(const BigInt &&input)
	{
		*this = *this - (input);

		return *this;
	}


	BigInt & BigInt::operator*=(const ll input)
	{
		return *this *= BigInt(input);
	}

	BigInt & BigInt::operator*=(const BigInt &input)
	{
		//排除0
		if (this->IsZero() || input.IsZero()) {
			*this = 0;
			return *this;
		}

		//排除1 -1
		if (this->IsOne()) { *this = input; return *this; }
		else if (input.IsOne()) return *this;
		else if (this->IsNegativeOne()) {
			*this = input;
			this->OppositeNum();
			return *this;
		}
		else if (input.IsNegativeOne()){
			this->OppositeNum();
			return *this;
		}

		BigInt ret, back, _back = *this;

		//保存符号
		char _tempSign = this->GetSign() * input.GetSign();

		//排除符号对加法的影响
		_back.m_sign = POSITIVE;
		ret.m_sign = POSITIVE;

		unsigned char carry = 0, temp = 0;
		for (unsigned int i = 0; i < input.GetLen(); ++i)
		{
			//向前 个位 -> 十位 -> 百位 -> 千位 ... ,把被乘数的0 转移到乘数上(因为0乘以任何数都是0 没必要计算) 
			//每次取一位 乘以 乘数
			if (i) _back.m_element.insert(_back.m_element.begin(), 1, 0);

			back = _back;

			carry = 0; temp = input.m_element[i];

			for (unsigned int j = i; j < back.GetLen(); ++j){
				back.m_element[j] = back.m_element[j] * temp + carry;
				carry = back.m_element[j] / 10;
				back.m_element[j] %= 10;
			}
			if (carry){
				back.m_element.push_back(carry);
				carry = 0;
			}
			//和每一位相乘得到的结果相加
			ret += back;
		}

		*this = ret;

		//恢复符号
		this->m_sign = _tempSign;

		return *this;
	}

	BigInt & BigInt::operator*=(const BigInt &&input)
	{
		//排除0
		if (this->IsZero() || input.IsZero()) {
			*this = 0;
			return *this;
		}

		//排除1 -1
		if (this->IsOne()) { *this = input; return *this; }
		else if (input.IsOne()) return *this;
		else if (this->IsNegativeOne()) {
			*this = input;
			this->OppositeNum();
			return *this;
		}
		else if (input.IsNegativeOne()){
			this->OppositeNum();
			return *this;
		}

		BigInt ret, back, _back = *this;

		//保存符号
		char _tempSign = this->GetSign() * input.GetSign();

		//排除符号对加法的影响
		_back.m_sign = POSITIVE;
		ret.m_sign = POSITIVE;

		unsigned char carry = 0, temp = 0;
		for (unsigned int i = 0; i < input.GetLen(); ++i)
		{
			//向前 个位 -> 十位 -> 百位 -> 千位 ... ,把被乘数的0 转移到乘数上(因为0乘以任何数都是0 没必要计算) 
			//每次取一位 乘以 乘数
			if (i) _back.m_element.insert(_back.m_element.begin(), 1, 0);

			back = _back;

			carry = 0; temp = input.m_element[i];

			for (unsigned int j = i; j < back.GetLen(); ++j){
				back.m_element[j] = back.m_element[j] * temp + carry;
				carry = back.m_element[j] / 10;
				back.m_element[j] %= 10;
			}
			if (carry){
				back.m_element.push_back(carry);
				carry = 0;
			}
			//和每一位相乘得到的结果相加
			ret += back;
		}

		*this = ret;

		//恢复符号
		this->m_sign = _tempSign;

		return *this;
	}

	BigInt & BigInt::operator/=(const ll input)
	{
		return *this /= BigInt(input);
	}

	BigInt & BigInt::operator/=(const BigInt &input)
	{
		BigInt back = *this;

		*this = back / input;

		return *this;
	}

	BigInt & BigInt::operator/=(const BigInt &&input)
	{
		BigInt back = *this;

		*this = back / input;

		return *this;
	}

	BigInt & BigInt::operator%=(const ll input)
	{
		return *this %= BigInt(input);
	}

	BigInt & BigInt::operator%=(const BigInt &input)
	{
		BigInt back = *this;

		*this = back % input;

		return *this;
	}

	BigInt & BigInt::operator%=(const BigInt &&input)
	{
		BigInt back = *this;

		*this = back % input;

		return *this;
	}

	BigInt  BigInt::operator++()
	{
		*this += 1;
		return *this;
	}

	BigInt  BigInt::operator++(int)
	{
		BigInt back = *this;
		*this += 1;
		return back;
	}

	BigInt  BigInt::operator--()
	{
		*this -= 1;
		return *this;
	}

	BigInt BigInt::operator--(int)
	{
		BigInt back = *this;
		*this -= 1;
		return back;
	}

	bool BigInt::operator<(const ll input)const
	{
		return *this < BigInt(input);
	}

	bool BigInt::operator<(const BigInt &input) const
	{
		//排除 0 不小于 0
		if (this->IsZero() && input.IsZero()) return false;

		//异号 正数大 (只有正0 没有负0的情况，可以直接由符号判断)
		if (this->GetSign() != input.GetSign()) return this->GetSign() != POSITIVE;

		//下面都是同号

		//长度是否一致
		//正数长的大 负数相反
		if (this->GetLen() != input.GetLen()) {
			if (GetSign() == POSITIVE) return this->GetLen() < input.GetLen();
			else return this->GetLen() > input.GetLen();
		}

		//下面都是一样长 一个一个比较

		int len = this->GetLen();
		for (int i = len - 1; i >= 0; i--){
			if (m_element[i] == input.m_element[i])  continue;
			return m_element[i] < input.m_element[i];
		}

		return false;
	}

	bool BigInt::operator<(const BigInt &&input)const
	{
		//排除 0 不小于 0
		if (this->IsZero() && input.IsZero()) return false;

		//异号 正数大 (只有正0 没有负0的情况，可以直接由符号判断)
		if (this->GetSign() != input.GetSign()) return this->GetSign() != POSITIVE;

		//下面都是同号

		//长度是否一致
		//正数长的大 负数相反
		if (this->GetLen() != input.GetLen()) {
			if (GetSign() == POSITIVE) return this->GetLen() < input.GetLen();
			else return this->GetLen() > input.GetLen();
		}

		//下面都是一样长 一个一个比较

		int len = this->GetLen();
		for (int i = len - 1; i >= 0; i--){
			if (m_element[i] == input.m_element[i])  continue;
			return m_element[i] < input.m_element[i];
		}

		return false;
	}

	bool BigInt::operator>(const ll input)const
	{
		return *this > BigInt(input);
	}

	bool BigInt::operator>(const BigInt &input)const
	{
		return input < *this;
	}

	bool BigInt::operator>(const BigInt &&input)const
	{
		return input < *this;
	}

	bool BigInt::operator<=(const ll input)const
	{
		return *this <= BigInt(input);
	}

	bool BigInt::operator<=(const BigInt &input)const
	{
		return *this < input || *this == input;
	}

	bool BigInt::operator<=(const BigInt &&input)const
	{
		return *this < input || *this == input;
	}

	bool BigInt::operator==(const ll input)const
	{
		return *this == BigInt(input);
	}

	bool BigInt::operator==(const BigInt &input)const
	{
		//排除0
		if (this->IsZero() && input.IsZero()) return true;
		else if (this->IsZero() || input.IsZero()) return false;

		//判断 符号 和 长度
		if (this->GetSign() != input.GetSign() || this->GetLen() != input.GetLen()) return false;

		int len = this->GetLen();

		//依次比较
		for (int i = 0; i < len; ++i){
			if (this->m_element[i] != input.m_element[i]) return false;
		}
		return true;
	}

	bool BigInt::operator==(const BigInt &&input)const
	{
		//排除0
		if (this->IsZero() && input.IsZero()) return true;
		else if (this->IsZero() || input.IsZero()) return false;

		//判断 符号 和 长度
		if (this->GetSign() != input.GetSign() || this->GetLen() != input.GetLen()) return false;

		int len = this->GetLen();

		//依次比较
		for (int i = 0; i < len; ++i){
			if (this->m_element[i] != input.m_element[i]) return false;
		}
		return true;
	}


	bool BigInt::operator>=(const ll input)const
	{
		return *this >= BigInt(input);
	}

	bool BigInt::operator>=(const BigInt &input)const
	{
		return *this > input || *this == input;
	}

	bool BigInt::operator>=(const BigInt &&input)const
	{
		return *this > input || *this == input;
	}

	char BigInt::GetElement(int i)const
	{
		unsigned int len = i;
		if (len >= GetLen()) return 0;

		return m_element[len];
	}

	//只比较数字 不关心符号
	bool BigInt::IsBig(const BigInt &input)const
	{
		if (IsZero() && input.IsZero()) return false;

		if (this->GetLen() > input.GetLen()) return true;
		else if (this->GetLen() < input.GetLen()) return false;

		int len = this->GetLen();
		for (int i = len - 1; i >= 0; --i){
			if (m_element[i] == input.m_element[i])continue;
			else if (m_element[i] > input.m_element[i]) return true;
			return false;
		}
		return false;
	}

	bool BigInt::IsZero()const
	{
		if (m_element.empty() || (m_element.size() == 1 && m_element.front() == 0)) return true;

		return false;
	}

	bool BigInt::IsOne() const
	{
		if (GetLen() != 1) return false;

		return m_sign == POSITIVE && m_element.front() == 1;
	}

	bool BigInt::IsNegativeOne() const
	{
		if (GetLen() != 1) return false;

		return m_sign == NEGATIVE && m_element.front() == 1;
	}

	unsigned int BigInt::GetLen()const
	{
		return m_element.size();
	}

	char BigInt::GetSign() const
	{
		return (m_sign);
	}

	//变相反数
	void BigInt::OppositeNum()
	{
		m_sign = ~m_sign + 1;
	}

	BigInt & BigInt::GetOppositeNum_All()
	{
		m_sign = ~m_sign + 1;
		return (*this);
	}

	BigInt  BigInt::GetOppositeNum_Part()const
	{
		BigInt back = *this;
		back.m_sign = ~back.m_sign + 1;
		return (back);
	}

	void BigInt::Regular()
	{
		//个位数
		if (GetLen() <= 1) return;

		for (int i = GetLen() - 1; i >= 0; i--){
			if (m_element[i] != 0) break;
			m_element.pop_back();
		}
		//0 当它为正
		if (m_element.empty()) m_sign = POSITIVE;
	}

	ll BigInt::GetValue()
	{
		ll ret = 0;

		if (this->IsZero()) return ret;

		int len = GetLen();

		BigInt temp = *this;

		if (*this > m_outMax) {
			temp %=  m_outMax;
		}
		else if (*this < m_outMin) {
			temp %= m_outMin;
		}
		else if (*this == m_outMin) {
			return LLONG_MIN;
		}

		for (int i = len - 1; i >= 0; i--)
			ret = ret * 10 + m_element[i];

		return ret*temp.m_sign;
	}

	std::ostream & operator<<(std::ostream &os, const BigInt &input){
		if (input.IsZero()) { os << 0; return os; }

		if (input.GetSign() == XDC::BigInt::NEGATIVE) os << "-";

		int len = input.GetLen();

		for (int i = len - 1; i >= 0; i--){
			os << (int)input.GetElement(i);
		}

		return os;
	}

	BigInt operator+(ll num, BigInt &bint){
		BigInt back = num;
		return back + bint;
	}

	BigInt operator-(ll num, BigInt &bint){
		BigInt back = num;
		return back - bint;
	}

	BigInt operator*(ll num, BigInt &bint){
		BigInt back = num;
		return back * bint;
	}

	BigInt operator/(ll num, BigInt &bint){
		BigInt back = num;
		return back / bint;
	}

	BigInt operator%(ll num, BigInt &bint){
		BigInt back = num;
		return back % bint;
	}

	ll BigInt::operator()(void){
		return GetValue();
	}
};

测试代码

#include "BigInt.h"
int main()
{
	BigInt a(0);

	//累加
	for (int i = 1; i <= 10000; ++i){
		a = a + i;
	}
	std::cout << "第一个 = " << a << std::endl;

	a = 0;

	//累加
	for (int i = 1; i <= 123456; ++i){
		a += -i;
	}

	std::cout << "第二个 = " << a << std::endl;

	a = 0;
	//偶数 +  奇数 -
	for (int i = 1; i <= 1000; ++i){
		if (i & 1) a -= i;
		else a = a + i;
	}

	std::cout << "第三个 = " << a << std::endl;

	a = 1;
	//累乘
	for (int i = 2; i <= 1000; ++i){
		a *= i;
	}

	std::cout << "第四个 = " << a << std::endl;

	a = 6565451;

	std::cout << "第五个 = " << a / 91 << std::endl;

	std::cout << "第六个 = " << a % 91 << std::endl;
	return 0;
}

截图
在这里插入图片描述

测试

#include <ctime>

int main()
{
	int a = 0, b = 0;
	BigInt bi = 0;
	srand(time(nullptr));

	while (true){

		a = rand() % INT_MAX  * (rand() % 2 == 1?1:-1);

		b = (rand() % (INT_MAX - 1) + 1 )* (rand() % 2 == 1 ? 1 : -1);

		bi = a;
		if (a + b != (bi + b).GetValue()){
			std::cout << "a + b = " << bi + b << std::endl;
		}else if (a - b != (bi - b).GetValue()){
			std::cout << "a - b = " << bi - b << std::endl;
		}else if (a * b != (bi * b).GetValue()){
			std::cout << "a * b = " << bi * b << std::endl;
		}
		else if (a / b != (bi / b).GetValue()){
			std::cout << "a / b = " << bi / b << std::endl;
		}
		else if (a % b != (bi % b).GetValue()){
			std::cout << "a % b = " << bi % b << std::endl;
		}
		std::cout << a << "/" << b << " = " << bi / b << std::endl;

		std::cout << a << "%" << b << " = " << bi % b << std::endl;
	}
	return 0;
}

struct bignum{
	int len, num[10];
	bignum() { len = 1; for (int i = 0; i<10; i++) num[i] = 0; }//构造函数
	void equal(int x){
		if (!x) return;
		len = 0;
		while (x>0){
			num[len++] = x % 100000;
			x /= 100000;
		}
	}
	bool operator> (const bignum &x)const{
		if (len^x.len) return len>x.len;
		for (int i = len - 1; i >= 0; i--)
		if (num[i] ^ x.num[i]) return num[i]>x.num[i];
		return 0;
	}//重载大于号
	bignum operator+ (const bignum &x){
		bignum y;
		for (int i = 0; (i<len) | (i<x.len); i++){
			y.num[i] += num[i] + x.num[i];
			if (y.num[i] >= 100000) y.num[i] -= 100000, y.num[i + 1]++;
		}
		y.len = (len>x.len) ? len : x.len;
		if (y.num[y.len]) y.len++;
		return y;
	}//重载加号
	bignum operator+ (const int &x){
		bignum y;
		y.equal(x);
		return (*this) + y;
	}//重载加整数
	void print(){
		printf("%d", num[len - 1]);
		for (int i = len - 2; i >= 0; i--){
			int tmp = num[i];
			for (int j = 10000; j; j /= 10) putchar(tmp / j + '0'), tmp %= j;
		}
	}//输出函数
};
小刀刺大熊
关注
专栏目录
C++大整数运算
10-28
用C++写的大整数运算，包含加减乘除以及求余
大数运算c++
07-31
大数运算代码；写了大数运算基本的加减乘除、矩阵求逆运算及矩阵加减乘除。采用字符数组的方式实现，可以通过宏来设定所需要的精度，包括小数点后的位数。
【C++进阶】BigInt的实现(一）
最新发布
m0_62599305的博客
07-29 715
在计算机科学中，处理大整数（BigInt）是一项重要的任务，尤其是在密码学、科学计算和金融应用中。标准的整数类型在某些情况下可能不够用。例如，C语言中的int类型通常是 32 位的，可以表示的最大整数约为 2^31 - 1（2147483647）；long long类型通常是 64 位的，可以表示的最大整数约为 2^63 - 1（9223372036854775807）。然而，这些范围对某些应用来说仍然不够。因此，我们需要自定义一种数据结构和算法来处理任意大小的整数，这就是 BigInt 的实现。
C++高精度（加减乘除）
wyqxii的博客
07-28 3038
对两个的数进行计算时，int、long long等数据类型的数据范围显然不够使用时，我们就需要引入。高精度算法本质上时用字符串模拟数字进行计算。其步骤与人工演算过程一致。
大整数运算C++
weixin_33756418的博客
10-01 137
//下面的代码勉强算是bignum_beta1版本！ //实现了大整数的加减乘除四则运算,以及求两个整数的最大公约数,以及求乘法逆,miller_rabin素性检验,平方_乘法算法 //不足之处，位数还很难扩展至几千位,以及运算速度有一点慢,既然是beta1,说明bug还是挺多的 //程序缺少测试数据来测试,所以有的结果不敢保证其正确性 //由于使用c++复写了很多运算符,加入这个文件...
大数四则运算的C++实现
路雪军 Carl
04-16 9155
http://adultedu.ustc.edu.cn/img/pap/wh/大数四则运算的C++实现[摘要] 大数运算不仅仅运用在密码学中，还运用在一些物理学研究、生物学，化学等科目中。大数运算，意味着参加的值和计算结果通常是以上百位数，上千位数以及更大长度之间的整数运算。例如大家所熟知圆周率π的值，在一般的数值计算中用到圆周率的不须要多大的精度，但在计算一些星球或是星系上的体积面积时便显的
[源码和文档分享]基于C++实现的大整数计算
qq_38474647的博客
04-08 137
1、实验题目 大整数（big integer）：位数很多的整数，普通的计算机不能直接处理，如：9834975972130802345791023498570345。 对大整数的算术运算，显然常规程序语言是无法直接表示的。编程实现大整数的加、减、乘运算，需考虑操作数为0、负数、任意位等各种情况。 要求利用分治法，时间复杂度不高于O(n...
大数运算教程 c++
weixin_33929309的博客
04-09 504
由于c++的内置整型一般最大为long long，只能保存2^63次方的整数，在很多时候需求量较大时可能会发生溢出等现象 所以大数类便应运而生 1 class bigNum{ 4 private: 5 int a[maxn],len; 6 char sign;7 }; 在此分享一下大数算法 大数加法： 通过我们从小到大进行的各种...
C++ 大整数运算库(附源码)
02-15
用于运算、输出大整数的C++库，使用简便，即下即用，已重载各类运算符，支持ostream（cout）输出和字符串输出、字符串构造、最大公约数和最小公倍数计算。 具体用法、函数说明可以在文件夹中的README.txt中找到
大数运算模板（C++）
05-02
此模板只能处理正数的大数，包含四则运算、平方根、求末尾0个数、求长度等以及int型的组合排列
C++ 大数运算 加减乘除
03-16
可以进行1024位的数字加减乘除。我已经对加减乘除进行了重载。 只需把主函中C=A+B修改一下就好。
大整数的四则运算的c++代码
06-17
大整数的是这运算c++代码，其中除法优点瑕疵，其他的都还可以
C++ 大数运算库（支持BCB及VC）
04-03
本库文件支持C++下的大数运算，支持C++ builder 6及VC++ 2005（其它版本未测试），内含示例源码（sample.c),源码来源： http://mattmccutchen.net/bigint/index.html BCB库文件名： bitintbc.lib(名字取错了,没法改) VC库文件名： bigintVC.lib
C++实现的大整数四则运算
12-25
在C++中，大整数通常通过数组或向量存储，每个元素表示数字的一个位。数组或向量的长度可以动态调整，以适应任意大小的整数。大整数类可能包含以下主要成员： 1. **数据成员**：一个`std::vector<unsigned int>`或`...
C++大整数运算代码
03-11
在C++编程语言中，处理大整数运算是一项挑战，因为标准库提供的`int`、`long`或`long long`等数据类型都有其存储和计算的限制。当需要进行超出这些类型范围的大整数运算时，我们通常需要自定义数据结构和算法。标题...
C++大数运算
dqsjqian的博客
01-16 1776
#include <cstring> #include <string> #include <iostream> using namespace std; constexpr auto MAXN = 9999; constexpr auto MAXSIZE = 1000; constexpr auto DLEN = 4; class BigN { priv...
C++实现大整数运算：加减乘除
"C++ 实现大整数的加减乘除运算，通过自定义类`bign`来处理超出普通整型范围的大整数计算，包括加法、减法、乘法和除法操作。" 在C++编程中，处理大整数通常需要自定义数据结构和算法，因为标准库提供的整型类型...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值