大数运算

#ifndef BIG_DATA_H
#define BIG_DATA_H

#include <iostream>
using namespace std;
#include <string>

#define UN_INIT 0xcccccccccccccccc
#define MAX_INT64 0x7fffffffffffffff
#define MIN_INT64 0x8000000000000000

typedef long long INT64;

class BigData
{
public:
BigData(INT64 data = UN_INIT);
BigData(const char *pData);

BigData operator+(BigData& bigData);
BigData operator-(const BigData& bigData);
BigData operator*(const BigData& bigData);
BigData operator/(const BigData& bigData);
friend ostream& operator<<(ostream& _cout, 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);
void INT64ToString();//把数据进行字符串的存储
bool IsINT64Overflow()const;//以字符串形式给出的数据，转化为数值时，是否会溢出
bool IsLeftStrBig(char *pLeft, size_t LSize, char *pRight, size_t RSize);//
char SubLoop(char *pLeft, size_t LSize, char *pRight, size_t RSize);//循环相减

private:
INT64 m_llValue;  //可转化为数值 long long value
string m_strData; //数字大小已经溢出了，被放置到字符串中操作
};
#endif

<strong><span style="font-size:18px;">#include<iostream>
#include "Bigdata.h"
#include <assert.h>

BigData::BigData(INT64 data) //在构造函数中要同时对传入的数据做两种类型的处理，一个是数值，另一个是字符串
: m_llValue(data)
, m_strData("")
{
INT64ToString();
}

BigData::BigData(const char *_pData)
{
// "-12345789"  "1234567" "+" "12457aaa123" "000001234567"
// "a23456789"
// atoi
assert(NULL != _pData);//检查指针

char cSybom = _pData[0];//拿下所给出的字符串的第0位
char* pData = (char*)_pData;
if ('+' == cSybom || '-' == cSybom)//给定的数字字符串是带有符号位的
{
pData++;
}
else if (*pData >= '0' && *pData <= '9')
{
cSybom = '+';
}
else //当给定的字符串的第0位既不是符号（‘+’/‘-’），也不是数字时，它就不能去模拟数字的运算
{
m_llValue = 0; //在函数 atoi 中，对这样的字符串进行数字转换时，该函数会返回0，所以在模拟时，就直接赋为0
m_strData = "0";
return;
}

// 去掉前置0  "000001234567"
while ('0' == *pData)
pData++;

m_strData.resize(strlen(pData) + 1);//调整字符串m_strData的大小（刚好够存储给定的字符串）
m_llValue = 0;
m_strData[0] = cSybom;
int iCount = 1;
while (pData)
{
if (*pData >= '0' && *pData <= '9')
{
m_llValue = m_llValue * 10 + *pData - '0';
m_strData[iCount++] = *pData++;
}
else
{    //可能中间会被截断的情况： "12457aaa123"，则只需对前面出现的数字进行操作就可以了
break;
}
}
//再次重置空间大小，是因为若遇到中间被不合法字符阶段时，刚刚第一次设置的空间大小就会有一些被浪费。
m_strData.resize(iCount);

if ('-' == cSybom)
{//前面在转存为数字时，是抛开了符号位的，所以得到的结果是正数
m_llValue = 0 - m_llValue;
}
}

BigData BigData::operator+(BigData& bigData)
{
// 8 + -2  10
if (!IsINT64Owerflow() && !bigData.IsINT64Owerflow())//两者本身都没有溢出
{
if (m_strData[0] != bigData.m_strData[0])//两者异号，便可直接用算术的运算方法
{
return BigData(m_llValue + bigData.m_llValue);
}
else //同号
{
// 2 + 8  10 - 6 > 2
// -3 + -8  -10 - (-6) = -4 < -3
/*当两者都是正数的时候，假设所能表示的最大正数是10，再给定其中一个值 2，那么另一个数必须<=10-2,才能保证
两者相加的结果是小于 10 的。例：5 < 10 -2 ,那5+2肯定不会超过10，；相反，9 > 10-2,那么2+9>10,溢出*/
/*负数同理*/

// 同号,但相加结果没有溢出，也可直接用算术的运算方法
if (('+' == m_strData[0] && (INT64)(MAX_INT64 - m_llValue) >= bigData.m_llValue) ||
('-') == m_strData[0] && (INT64)(MIN_INT64 - m_llValue) <= bigData.m_llValue)
{
return BigData(m_llValue + bigData.m_llValue);
}
}
}

/*2 + 2 / -2 + -2 == -(2+2)
2 + -1
至少有一个溢出
计算结果溢出*/
string strRet;
if (m_strData[0] == bigData.m_strData[0])
{
strRet = Add(m_strData, bigData.m_strData);
}
else
{
strRet = Sub(m_strData, bigData.m_strData);
}

return BigData(strRet.c_str());
}

BigData BigData::operator-(const BigData& bigData)
{
if (!IsINT64Owerflow() && !bigData.IsINT64Owerflow())
{
if (m_strData[0] == bigData.m_strData[0])//同号相减，结果肯定不会溢出，直接进行算术运算
{
return BigData(m_llValue - bigData.m_llValue);
}
else//异号相减
{
// 10 + (-8) = 2 > 1// 3 - (-8); 1 - (-8)
// -10  -8  3    -8  2  -10 + 3 = -7 <=
if (('+' == m_strData[0] && (INT64)(MAX_INT64 + bigData.m_llValue)>= m_llValue) ||
('-' == m_strData[0] && (INT64)(MIN_INT64 + bigData.m_llValue) <= m_llValue))
{
return BigData(m_llValue - bigData.m_llValue);
}
}
}

// 1、至少有一个操作数溢出
// 2、相减的结果一定会溢出
// "999999999" "-111111"  "-9999999" "1111111"
string strRet;
if (m_strData[0] != bigData.m_strData[0])
{
strRet = Add(m_strData, bigData.m_strData);
}
else
{
strRet = Sub(m_strData, bigData.m_strData);
}
return BigData(strRet.c_str());
}

BigData BigData::operator*(const BigData& bigData)
{
if (0 == m_llValue || 0 == bigData.m_llValue)//只要一个为0，则结果必为0
{
return BigData(INT64(0));
}

if (!IsINT64Owerflow() && !bigData.IsINT64Owerflow())//两者都没有溢出
{
if (m_strData[0] == bigData.m_strData[0])//两者同号
{
// 10 /2 = 5 >= 1 2 3 4 5
// 10 /-2 = -5 <= -5 -4 -3 -2 -1
if (('+' == m_strData[0] && MAX_INT64 / m_llValue >= bigData.m_llValue) ||
('-' == m_strData[0] && MAX_INT64 / m_llValue <= bigData.m_llValue))
{
return BigData(m_llValue*bigData.m_llValue);
}
}
else
{
// -10 /2 = -5 <=
// -10/-2 = 5 >
if (('+' == m_strData[0] && MIN_INT64 / m_llValue <= bigData.m_llValue) ||
('-' == m_strData[0] && MIN_INT64 / m_llValue >= bigData.m_llValue))
{
return BigData(m_llValue*bigData.m_llValue);
}
}
}

return BigData(Mul(m_strData, bigData.m_strData).c_str());
}

BigData BigData::operator/(const BigData& bigData)
{
if (0 == bigData.m_llValue)
{
assert("除数不能为0！");
return BigData(INT64(0));
}

if (!IsINT64Owerflow() && !bigData.IsINT64Owerflow())
{
return BigData(m_llValue / bigData.m_llValue);
}

return BigData(Div(m_strData, bigData.m_strData).c_str());
}

// +
// +=
string BigData::Add(string left, string right)
{
int iLSize = left.size();
int iRSize = right.size();
if (iLSize < iRSize)//保证左串比右串的 size 大
{
swap(left, right);
swap(iLSize, iRSize);
}

string strRet;
strRet.resize(iLSize + 1); //考虑两者相加最高位产生进位，则结果的size比iLSize大1
strRet[0] = left[0];
char cStep = 0; //进位

//left = "+9999999"  size = 9
// right="1"   "+10000000"
for (int iIdx = 1; iIdx < iLSize; ++iIdx)
{
char cRet = left[iLSize - iIdx] - '0' + cStep;

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

strRet[iLSize - iIdx + 1] = (cRet % 10 + '0');
cStep = cRet / 10;
}

strRet[1] = (cStep + '0');

return strRet;
}

string BigData::Sub(string left, string right)
{
// 1、左操作数 > 右操作数
// 2、确定符号位
int iLSize = left.size();
int iRSize = right.size();
char cSymbol = left[0];//先把符号位初始化，与left串的符号位保持一致
if (iLSize < iRSize ||
(iLSize == iRSize && left < right)) //保证左串比右串长，且大于右串
{
swap(left, right);
swap(iLSize, iRSize);
//进到这个条件就说明，符号位应该和原right串的符号保持一致
if ('+' == cSymbol)
{
cSymbol = '-';
}
else
{
cSymbol = '+';
}
}

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

// 逐位相减
// 1、取left每一位，从后往前取
// 2、在right没有超出  取right每一位从后往前取
// 3、直接相减
// 4、 保存结果
for (int iIdx = 1; iIdx < iLSize; iIdx++)
{
char cRet = left[iLSize - iIdx] - '0';
if (iIdx < iRSize)
{
cRet -= (right[iRSize - iIdx] - '0');
}

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

strRet[iLSize - iIdx] = (cRet + '0');
}

return strRet;
}

string BigData::Mul(string left, string right)
{
int iLSize = left.size();
int iRSize = right.size();
if (iLSize > iRSize)
{
swap(left, right);
swap(iLSize, iRSize);
}

char cSymbol = '+';
if (left[0] != right[0])
{
cSymbol = '-';
}

string strRet;
//strRet.resize(iLSize + iRSize - 1);
strRet.assign(iLSize + iRSize - 1, '0');
strRet[0] = cSymbol;
int iDataLen = strRet.size();
int iOffset = 0;//乘法，分开乘后，各个是要错位相加的；只要乘数一换，ioffset就该改变

for (int iIdx = 1; iIdx < iLSize; ++iIdx)
{
char cLeft = left[iLSize - iIdx] - '0';
char cStep = 0;
if (0 == cLeft)
{
iOffset++;
continue;
}

for (int iRIdx = 1; iRIdx < iRSize; ++iRIdx)
{
char cRet = cLeft*(right[iRSize - iRIdx] - '0');
cRet += cStep;
cRet += (strRet[iDataLen - iOffset - iRIdx] - '0');
strRet[iDataLen - iOffset - iRIdx] = cRet % 10 + '0';
cStep = cRet / 10;
}

strRet[iDataLen - iOffset - iRSize] += cStep;
iOffset++;
}
return strRet;
}

string BigData::Div(string left, string right)
{
char cSymbol = '+';
if (left[0] != right[0])
{
cSymbol = '-';
}

int iLSize = left.size();
int iRSize = right.size();
if (iLSize < iRSize ||
iLSize == iRSize && strcmp(left.c_str() + 1, right.c_str() + 1) < 0) //除数大于被除数，相除结果为0
{
return "0";
}
else
{
if ("+1" == right || "-1" == right)//除数为1，结果值为被除数
{
left[0] = cSymbol;
return left;
}
}

string strRet; //返回商的串
strRet.append(1, cSymbol);
char *pLeft = (char*)(left.c_str() + 1);//指向被除数,抛开符号位
char *pRight = (char*)(right.c_str() + 1);//指向除数，抛开符号位
int iDataLen = 1;//被除数串的长度
// "2422222222"  33
for (int iIdx = 0; iIdx < iLSize-1;)
{
if ('0' == *pLeft) //990000000000099 / 33  *pLeft为0时，就直接把0作为商
{
strRet.append(1, '0');
pLeft++;
iIdx++; //pLeft与iIdx是同步走的
continue;
}

if (!IsLeftStrBig(pLeft, iDataLen, pRight, iRSize - 1))//找到可以除以除数的子串
{
strRet.append(1, '0');//不够除时，商0
iDataLen++;//再扩大子串，子串范围：pLeft--pLeft+IDataLen-1
if (iIdx + iDataLen > iLSize)//在扩子串时，扩到了最后一位
{
break;
}
continue;
}
else
{
// 循环相减
strRet.append(1, SubLoop(pLeft, iDataLen, pRight, iRSize - 1));// SubLoop的返回值即为商值

// pLeft
while ('0' == *pLeft && iDataLen > 0)//上述循环相减后，得到的余数可能会把被除数串的最前面的几位改为0，
{									 //所以再找新的子串时，要把前面的0都跳过
pLeft++;
iIdx++;
iDataLen--;
}

iDataLen++; //紧接着要从上面一位下来
if (iIdx + iDataLen > iLSize)
{
break;
}
}
}
return strRet;
}

bool BigData::IsLeftStrBig(char *pLeft, size_t LSize, char *pRight, size_t RSize)
{
assert(NULL != pLeft && NULL != pRight);
if (LSize > RSize ||
LSize == RSize && strncmp(pLeft, pRight, LSize) >= 0)
{
return true;
}

return false;
}

char BigData::SubLoop(char *pLeft, size_t LSize, char *pRight, size_t RSize)
{
assert(NULL != pLeft && NULL != pRight);

char cRet = '0';
while (true)
{
if (!IsLeftStrBig(pLeft, LSize, pRight, RSize))
{
break;
}

// 做-=
int iLDataLen = LSize - 1;
int iRDataLen = RSize - 1;
while (iRDataLen >= 0 && iLDataLen >= 0)
{
if (pLeft[iLDataLen] < pRight[iRDataLen])
{
pLeft[iLDataLen - 1] -= 1;
pLeft[iLDataLen] += 10;
}

pLeft[iLDataLen] = pLeft[iLDataLen] - pRight[iRDataLen] + '0';
iLDataLen--;
iRDataLen--;
}

// "990000000000000000000000000099" 剔除被改变后的被除数中的前置0
while ('0' == *pLeft && LSize > 0)
{
pLeft++;
LSize--;
}

cRet++;
}

return cRet;
}

void BigData::INT64ToString()
{
//12345
char cSymbol = '+'; //设置符号位
INT64 temp = m_llValue;
if (temp < 0)
{
cSymbol = '-';
temp = 0 - temp;
}

m_strData.append(1, cSymbol);//在字符串m_strData后，追加一个 cSymbol,那么该字符串的0位就被符号（正负）占了
int iCount = 1;//从字符串的1号位置开始填数

//填充字符串的时候，更容易先得到数的低位，这样低位就会填充到字符串的高位上去，所以最后还需要一步翻转字符串的操作
// 54321
//（1）先把数字都填充到字符串上去
while (temp)
{
m_strData.append(1, temp % 10 + '0');
temp /= 10;
}

//（2）翻转字符串
char *pLeft = (char*)(m_strData.c_str() + 1);
char *pRight = (char*)(m_strData.c_str() + m_strData.size() - 1);
while (pLeft < pRight)
{
char ctemp = *pLeft;
*pLeft++ = *pRight;
*pRight-- = ctemp;
}

// 1 符号位
// 2 m_strData = 54321
}

bool BigData::IsINT64Overflow()const
{
string strTemp;
if ('+' == m_strData[0]) //若字符串的第0位是‘+’，则说明进来的数据是一个正数；反之，即为负数
{
strTemp = "+9223372036854775807"; //最大正数 7FFFFFFFFFFFFFFF 的十进制表示的大小
}
else
{
strTemp = "-9223372036854775808"; //最小负数 8000000000000000 的十进制表示的大小
}

//（1）如果被数字填充起来的字符串的长度>能表示的最大数字的长度，那么该进入的数据在存储的时候肯定会溢出
if (m_strData.size() > strTemp.size())
{
return true;
}
//（2）当size相等时，在比较两个字符串的大小，若前者大于后者，溢出
else if (m_strData.size() == strTemp.size() && m_strData > strTemp)
{
return true;
}
//总结上述两种情况：上述两种情况必须分开考虑，不能直接比较字符串的大小；
/*以正数来举例："+95233"与"+9223372036854775807"直接比较，那么在第一个字符上就能判断出前者大于后者，但实际上
"+95233"并没有溢出*/

return false; //其余的情况，数据的存储都是不会发生溢出的
}

ostream& operator<<(ostream& _cout, const BigData& bigData)
{
if (!bigData.IsINT64Owerflow()) // 没有溢出
{
_cout<<bigData.m_llValue;
}
else
{
char* pData = (char*)bigData.m_strData.c_str();
if (pData[0] == '+')
{
pData++;
}
_cout<<pData;
}
return _cout;
}

</span></strong>