大数运算器

最新推荐文章于 2024-06-14 08:39:27 发布
最新推荐文章于 2024-06-14 08:39:27 发布
阅读量420 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/csdnldsg/article/details/52749604

该项目主要是对超过计算机计算范围的数字进行加减乘除运算，若被操作数都没超过计算机表示范围，且计算机都能进行相关运算，则调用计算机进行相关运算，若超过运算范围的，则调用下面相关函数就可以进行相关运算。

主要思想就是对超出存储范围的数字都以字符串的形式进行存储起来，然后模拟十进制的加减乘除运算。具体如何模拟运算则需要看下面的代码实现过程

代码如下：

头文件：BigData.h

#pragma once
#include<iostream>
#include<string>
#include<assert.h>
using namespace std;


typedef long long INT64;
#define MIN_INT64 0x8000000000000000
#define MAX_INT64 0x7FFFFFFFFFFFFFFF


class BigData
{
public:
	BigData(INT64 x);
	BigData(const char* cData);

	BigData operator+(const BigData& bigdata);
	BigData operator-(const BigData& bigdata);
	BigData operator*(const BigData& bigdata);
	BigData operator/(const BigData& bigdata);

protected:
	string Add(string left, string right);
	string Sub(string left, string right);
	string Mul(string left, string right);
	string Div(string left, string right);

	friend ostream& operator<<(ostream& out, const BigData& bigdata);
	bool isOverFlowINT64()const;
	bool IsLeftStrBig(const char* pLeft, int Lsize, const char* pRight, int Rsize);
	char subloop(char* pLeft, int Lsize, char* pRight, int Rsize);
	void _INIT64ToString();

private:
	INT64 _value;
	string _strData;
};
函数实现部分：BigData.cpp 

#include"BigData.h"

BigData::BigData(INT64 x)
   :_value(x)
{
	_INIT64ToString();
}


BigData::BigData(const char* cData)
{
	if (cData == NULL)
	{
		assert(false);
		return;
	}

	char* ptr = (char*)cData;
	char cSymbol = cData[0];   //“0000”  ""

	if (cSymbol == '-' || cSymbol == '+')
	{
		ptr++;
	}
	else if (cSymbol >= '0' && cSymbol <= '9')
	{
		cSymbol = '+';
	}
	else
	{
		return;
	}

	while (*ptr == '0')
	{
		++ptr;
	}

	_strData.resize(strlen(cData) + 1);
	_strData[0] = cSymbol;

	_value = 0;
	int iCount = 1;

	while (*ptr >= '0' && *ptr <= '9')
	{
		_value = _value * 10 + (*ptr - '0');
		_strData[iCount++] = *ptr;
		++ptr;
	}

	_strData.resize(iCount);

	if (cSymbol == '-')
	{
		_value = 0 - _value;
	}
}

void BigData::_INIT64ToString()
{
	char cSymbol = '+';
	if (_value < 0)
	{
		cSymbol = '-';
		//----------------------------------------------------
	}

	INT64 tmp = _value;
	_strData.append(1, cSymbol);

	while (tmp)
	{
		_strData.append(1, tmp % 10 + '0');
		tmp /= 10;
	}

	char* pLeft = (char*)_strData.c_str() + 1;
	char* pRight = pLeft + _strData.size() - 2;

	while (pLeft < pRight)
	{
		char cmp = *pLeft;
		*pLeft = *pRight;
		*pRight = cmp;
		pLeft++;
		pRight--;
	}
}

bool BigData::isOverFlowINT64()const
{
	string tmp("9223372036854775807");

	if (_strData[0] == '-')
	{
		tmp = "-9223372036854775808";
	}

	if (_strData.size() < tmp.size())
	{
		return true;
	}
	else if (_strData.size() == tmp.size() && _strData<tmp)
	{
		return true;
	}

	return false;
}


ostream& operator<<(ostream& out, const BigData& bigdata)
{

	if (bigdata.isOverFlowINT64())
	{
		out << bigdata._value;
		return out;
	}
	else
	{
		char* pstr = (char*)bigdata._strData.c_str();

		if (pstr[0] == '+')
		{
			pstr++;
		}
		out << pstr;
	}
	return out;
}


BigData BigData::operator+(const BigData& bigdata)
{
	if (isOverFlowINT64() && bigdata.isOverFlowINT64())
	{
		if (_strData[0] != bigdata._strData[0])
		{
			return (_value + bigdata._value);
		}
		else
		{
			INT64 tmp = MIN_INT64;
			if (_value > 0 && MAX_INT64 - _value >= bigdata._value
				|| _value < 0 && tmp - _value <= bigdata._value)    //--------------
			{
				return (_value + bigdata._value);
			}
		}
	}

	if (_strData[0] == bigdata._strData[0])    //同号溢出的情况，调用加法------------------------------
	{
		return BigData(Add(_strData, bigdata._strData).c_str());   
	}

	return BigData(Sub(_strData, bigdata._strData).c_str()); //异号溢出的情况，调用减法
}

BigData BigData::operator-(const BigData& bigdata)
{
	if (isOverFlowINT64() && bigdata.isOverFlowINT64())
	{
		if (_strData[0] == bigdata._strData[0])    //同号相减肯定不会溢出
		{
			return BigData(_value - bigdata._value);
		}
		else
		{
			if ((_value > 0 && MAX_INT64 + bigdata._value >= _value) ||     //肯定不会溢出
				(_value < 0 && MIN_INT64 + bigdata._value <= _value))
			{
				return BigData(_value - bigdata._value);
			}
		}
	}

	if (_strData[0] != bigdata._strData[0])        //会溢出
	{
		return BigData(Add(_strData,bigdata._strData).c_str());
	}

	return BigData(Sub(_strData, bigdata._strData).c_str());
}

BigData BigData::operator*(const BigData& bigdata)
{
	if (_value == 0 || bigdata._value == 0)
	{
		return BigData(INT64(0));
	}
	if (isOverFlowINT64() && bigdata.isOverFlowINT64())
	{
		if (_strData[0] == bigdata._strData[0])
		{
			if ((_value > 0 && MAX_INT64 / _value >= bigdata._value) ||     //同号且不会溢出
				(_value < 0 && MIN_INT64 / _value <= bigdata._value))    //  -10 -2 = 5 
			{
				return BigData(_value * bigdata._value);
			}
		}
		else
		{
			//-10 2 -5                                                         //异号且不会溢出
			if ((_value > 0 && MIN_INT64 / _value <= bigdata._value) ||      //-10  2  = -5 <= -3 
				(_value < 0 && MIN_INT64 / _value >= bigdata._value))        //-10 -2  =  5  >= 3
			{
				return BigData(_value * bigdata._value);
			}
		}
	}

	return BigData(Mul(_strData, bigdata._strData).c_str());     //溢出调用Mul
}


BigData BigData::operator/(const BigData& bigdata)
{
	if (bigdata._strData[1] == '0')      //处理除数为0的情况
	{
		assert(false);
	}

	if (isOverFlowINT64() && bigdata.isOverFlowINT64())   //处理不溢出的情况
	{
		return BigData(_value / bigdata._value);
	}

	if (_strData.size() < bigdata._strData.size() ||    //左边小于右边的情况
		(_strData.size() == bigdata._strData.size()
		&& strcmp(_strData.c_str() + 1, bigdata._strData.c_str() + 1) < 0))
	{
		return BigData(INT64(0));
	}

	if (bigdata._strData == "-1" || bigdata._strData == "+1")    //处理除数为+1 -1的情况
	{
		string ret = _strData;

		if (_strData[0] != bigdata._strData[0])
		{
			ret[0] = '-';
		}
		return BigData(ret.c_str());
	}

	if (_strData.size() == bigdata._strData.size()              //处理除数与被除数一样的情况（除过符号位）
		&& strcmp(_strData.c_str() + 1, bigdata._strData.c_str() + 1) == 0)
	{
		string ret = "+1";

		if (_strData[0] != bigdata._strData[0])
		{
			ret[0] = '-';
		}

		return BigData(ret.c_str());
	}

	return BigData(Div(_strData, bigdata._strData).c_str());
}


string BigData::Add(string left, string right)
{

	int leftsize = left.size();
	int rightsize = right.size();

	if (leftsize < rightsize)
	{
		swap(left, right);
		swap(leftsize, rightsize);
	}

	string iRet;
	iRet.resize(leftsize + 1);
	iRet[0] = left[0];
    int step = 0;         //进位

	for (int i = 1; i < leftsize; i++)
	{
		char cRet = left[leftsize - i] - '0' + step;

		if (i < rightsize)
		{
			cRet += right[rightsize - i] - '0';
		}

		iRet[leftsize - i + 1] = cRet % 10 + '0';

		step = cRet/10;
	}
	iRet[1] = step + '0';

	return iRet;

}


string BigData::Sub(string left, string right)
{
	int leftsize = left.size();
	int rightsize = right.size();

	char cSymbol = '+';
	//10 - 11 = -1
	//-3 - -7 = 4
	if (leftsize < rightsize || leftsize == rightsize && left<right)
	{
		swap(left, right);
		swap(leftsize, rightsize);
		if (cSymbol == '+')
		{
			cSymbol = '-';
		}
		else
		{
			cSymbol = '+';
		}
	}

	string strRet;
	strRet.resize(left.size());
	strRet[0] = cSymbol;


	for (int Idx = 1; Idx < leftsize; ++Idx)
	{
		char cRet = left[leftsize - Idx] - '0';
		if (Idx < rightsize)
		{
			cRet -= right[rightsize - Idx] - '0';
		}

		if (cRet < 0)
		{
			left[leftsize - Idx - 1] -= 1;
			cRet += 10;
		}

		strRet[leftsize - Idx] = cRet + '0';
	}

	return strRet;
}


string BigData::Mul(string left, string right)
{
	char cSymbol = '+';
	if (left[0] != right[0])
	{
		cSymbol = '-';
	}
	int leftsize = left.size();
	int rightsize = right.size();

	if (leftsize < rightsize)
	{
		swap(left, right);
		swap(leftsize, rightsize);
	}

	string sRet;
	sRet.assign(leftsize + rightsize - 1,'0');
	sRet[0] = cSymbol;
	int iDataLen = sRet.size();
	int ioffset = 0;

	for (int iLIdx = 1; iLIdx < leftsize; iLIdx++)
	{
		char cLeft = left[leftsize - iLIdx] - '0';
		char cStep = 0;
		if (cLeft == '0')
		{
			ioffset++;
			continue;
		}

		for (int iRIdx = 1; iRIdx < rightsize; iRIdx++)
		{
			char cRet = cLeft*(right[rightsize - iRIdx] - '0') + cStep;
			cRet += sRet[iDataLen - iRIdx - ioffset] - '0';
			sRet[iDataLen - iRIdx - ioffset] = (cRet % 10 + '0');
			cStep = cRet/10;
		}
		sRet[iDataLen - rightsize - ioffset] += cStep;
		ioffset++;
	}
	return sRet;
}

string BigData::Div(string left, string right)
{
	string sRet;
	sRet.append(1, '+');
	if (left[0] != right[0])
	{
		sRet[0] = '-';
	}

	char* pLeft = (char*)(left.c_str() + 1);
	char* pRight = (char*)(right.c_str() + 1);
	int DataLen = right.size() - 1;
	int Lsize = left.size() - 1;

	for (int iIdx = 0; iIdx < Lsize;)
	{
		if (*pLeft == '0')
		{
			sRet.append(1, '0');
			pLeft++;
			iIdx++;
			continue;
		}

		if (!IsLeftStrBig(pLeft, DataLen, pRight, right.size() - 1))
		{
			sRet.append(1, '0');
			DataLen++;
			if (DataLen + iIdx > Lsize)
			{
				break;
			}
		}
		else
		{
			sRet.append(1, subloop(pLeft, DataLen, pRight, right.size() - 1));

			while (*pLeft == '0' && DataLen > 0)
			{
				pLeft++;
				iIdx++;
				DataLen--;
			}

			DataLen++;
			if (DataLen + iIdx > Lsize)
			{
				break;
			}
		}
	}
	return sRet;
}


bool BigData::IsLeftStrBig(const char* pLeft, int Lsize, const char* pRight, int Rsize)
{
	if (Lsize > Rsize || (Lsize == Rsize && strcmp(pLeft, pRight) >= 0))
	{
		return true;
	}
	else
	{
		return false;
	}
}

char BigData::subloop(char* pLeft, int Lsize, char* pRight, int Rsize)
{
	assert(pLeft && pRight);

	char cRet = '0';

	while (1)
	{
		if (!IsLeftStrBig(pLeft, Lsize, pRight, Rsize))
		{
			break;
		}

		int LDataLen = Lsize - 1;
		int RDataLen = Rsize - 1;

		while (LDataLen >= 0 && RDataLen >= 0)
		{
			char ret = pLeft[LDataLen] - '0';
			ret -= pRight[RDataLen] - '0';

			if (ret < 0)
			{
				pLeft[LDataLen - 1] -= 1;
				ret += 10;
			}

			pLeft[LDataLen] = ret + '0';
			LDataLen--;
			RDataLen--;
		}

		while (*pLeft == '0' && Lsize > 0 )
		{
			pLeft++;
			Lsize--;
		}
		cRet++;
	}
	return cRet;
}
3.函数调用部分：main.cpp 

#include"BigData.h"


void Test1()  //除法
{
	BigData b1("222222222222222222222222222222222222222222222222222222222222");
	BigData b2("33");
	          //8898989898989899989898990
	BigData b3("06734006734006734006734006734006734006734006734006734006734");
	cout << b3 << endl;

	cout << b1 << endl;
	cout << b2 << endl;
	cout << b1/b2 << endl;
}


void Test2()  //减法/加法
{
	/*BigData b1("1234567890123456789");
	BigData b2("-9999");
	cout << b1 - b2 << endl;*/

	/*BigData b1("1234567890123456789");
	BigData b2("9999");
	cout << b1 + b2 << endl;*/


	/*BigData b1("1234567890123456789");
	BigData b2("9999");
	cout << b1 - b2 << endl;*/

	BigData b1(1234567890123456789);
	BigData b2("9999");
	cout << b1 - b2 << endl;
}


void Test3()    //乘法
{
	BigData b1("123456789012349999");
	BigData b2("9999");
	cout << b1 * b2 << endl;
}


void FunTest1()
{
	BigData b1("999999999999999999999999999999999999999999999");       // BigData(const char* cData);
	BigData b2(99);         //BigData(INT64 x);
	cout << b1 << endl;
	cout << b2 << endl;          //	friend ostream& operator<<(ostream& out, const BigData& bigdata);
	cout << b1 / b2 << endl;

}


void FunTest2()
{
	BigData b1(12345678);       
	BigData b2(12345678);
	cout << b1 + b2 << endl;   //BigData BigData::operator+(const BigData& bigdata);
}

int main()
{
	//Test1();
	//Test2();
	//Test3();
	//FunTest1();
	FunTest1();
	system("pause");
	return 0;
}





模块计算器（大整数运算）
xiaolaji551的博客
04-03 677
问题：这一任务为余数的核心属性提供了实践，在算术中进行运算–通过加法和乘法对余数进行持久化。这个重要的属性通常用于检查计算结果、竞争编程、计算校验和，特别是用于加密。 看见模算法彻底的解释。 我们这里有一种长的算术计算，我们被问到一些数模的结果。result % M(以多种语言编写)。 （取自codeabbey，机翻） 输入例子： input data: 5 +3 *7 +10 *2 *3 +1...
大数运算计算器
11-24
用顺序表实现大数的加减法运算，以及顺序表的各种运用和一些功能！
大数计算器
03-12
windows 自带的计算器，不能进行大数计算。在加解密时，经常涉及到大数计算，这个工具就是进行大数计算。
大数计算器（加减乘除）
最新发布
SHARK_ddd的博客
06-14 461
高精度加，减，乘，除，阶乘的实现
密码学 大数运算计算器 大数软件 HugeCalc
02-01
密码学 大数运算计算器 可以计算成万位 大数软件
大数运算器支持逆运算功能
综上所述，文件中提到的“大数运算器 可做逆运算”、“加，减，乘，模，逆运算，在进行大数运算时会比较方便”以及“大数 可求逆运算”的标签指向了一个专门用于处理大数运算，特别是模逆运算的实用工具。...
简易大数运算器C程序课设工具
大数运算器是一种能够处理超出标准数据类型如int或long long范围数值运算的工具。在C语言编程中，实现大数运算通常需要借助特殊的数据结构和算法。本知识点将围绕大数运算器的核心概念、运算实现、C语言相关的技术点...
Visual C++实现的10000位大数运算器
在进行大数运算器开发时，Visual C++提供了一个便捷的开发环境，可以使用其中的各种调试和性能分析工具来优化程序。 2. 大数运算基础 在计算机科学中，大数运算指的是那些超出标准数据类型（如int、long等）处理...
超大数计算器
08-10
用于计算超大数据并将计算结果打印到文档的程序，本程序只提供计算和打印可能的梅森质数。公式为2^P-1。数字最大长度支持到1亿位。
最大整数计算器
04-09
C++ 计算器
超大整数计算工具
10-10
这是一个用java实现的计算大整数的工具，必须先安装好java开发环境，方可运行。运行命令：java -jar BigNumberCalculate.jar
大整数计算器1.0版
10-14
收集自网络的 大整数计算器1.0版功能： 1.支持长达10000位10进制数运算 2.支持计算结果存储到变量 按'Store'按钮，再按'a','b'...等按钮，就将计算结果存储到 a,b...等变量。如要调出这些变量值，直接按'a','b'等按钮即可。 例：如果输出窗口中为25，按'Store'按钮，再按'a'，25就被 存到变量a,以后在任何时刻按下'a'按钮,25将被调至输出窗口参与 运算。 3.支持2，8，10，16，256进制并可相互转换 小技巧： 256进制下输入'a' ,'b'等字符，转换为10或16进制， 你就可以看到'a','b',等字符的ascII码，反之亦然。 4.正式版支持脱离鼠标操作 数据在输入区直接输入， 快捷键 alt +，alt -， alt *，alt / 即 + - * /运算， 回车键 即 = ，
C语言 大数运算（无限大小）头文件
12-04
C语言 大数运算(无限大小)头文件 支持 + , - , * , / , % ,> , =,>,流输出<<.
大整数计算器
追光者
12-06 1742
具有si加、减、乘、除si typedef int status; typedef char Elem; #define OK 0 #define ERROR -1 #define MAXN 25000 #include <iostream> #include <cstdio> #include <cstdlib> #include <cstring&g...
大整数运算器 c语言思路,大整数相加的实现思路
weixin_39765057的博客
05-24 489
在计算机中，由于处理器位宽限制，只能处理有限精度的十进制整数加减法，比如在32位宽处理器计算机中，参与运算的操作数和结果必须在-231~231-1之间。如果需要进行更大范围的十进制整数加法，需要使用特殊的方式实现，比如使用字符串保存操作数和结果，采取逐位运算的方式。比如下面问题：9876543210 + 1234567890 =？让字符串 num1 = "9876543210"，字符串 num2 ...
大数加法器
okkil的博客
02-24 118
#include<stdio.h> #include<string.h> struct bignum { int digit[1001]; int size; void init() { for (int i = 0; i <= 1000; i++) digit[i] = 0; size = 0; } void tiqu(char str[]...
C++实现大整数计算器（高精度加减乘除）——————极易理解，源码直用
Main666的博客
11-14 1481
C++语言不像python等语言，由于其天然的特性，可以支持超大整数的计算。C++的最大整型long long范围仅有-9223372036854775808到9223372036854775807这显然无法满足某些情况下的需要，但是我们可以将超大整数存入数组，模拟加减乘除的过程，进而计算结果。以上就是今天要讲的内容，本文仅仅简单介绍了C++高精度计算的一种实现方法，后续可以开发C++专属的大整数类来进一步方便使用。
大数加法
准备23考研。不定期更新考研知识
12-24 486
题目描述 实现一个加法器，使其能够输出a+b的值。 输入 输入包括两个数a和b，其中a和b的位数不超过1000位。 输出 可能有多组测试数据，对于每组数据， 输出a+b的值。 样例输入 6 8 2000000000 30000000000000000000 样例输出 14 30000000002000000000 #include <stdio.h> #include<string.h> int main() { char a[1010],b[1010]; int s
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值