BigData.h
#pragma once
#include<string>
#include<iostream>
using namespace std;
#include<sstream>
#include<cassert>
#include <stack>
typedef long long INT64;
class BigData
{
public:
BigData(INT64 value);
BigData(const string & strData);
friend ostream& operator<<(ostream & out,const BigData & bigdata);
BigData operator+(const BigData & b);
BigData operator-(const BigData & b);
BigData operator*(const BigData & b);
BigData operator/(const BigData & b);
BigData operator%(const BigData & b);
public:
static BigData Calculate(const string & str);//计算四则运算表达式
private:
string Add(string left,string right);
string Sub(string left,string right);
string Mul(string left,string right);
string Div(string left, string right);
bool IsINT64OverFlow()const;
bool IsLeftStrBig(const char* left,int LSize,const char* right,int RSize);
char SubLoop(char *&pLeft,int &LSize,char *pRight,int RSize); //除法时每次求商运算。
string Mod(string left,string right);
四则运算的函数//
static string GetSuffixExpression(string str); //得到后缀表达式
static string GetData( char *& ptr);
static bool IsOperator(char c);
//比较两个操作符的优先级，op1比op2高返回1，一样返回0，低返回-1
static int CompareOperatorPriority(char op1,char op2);
static BigData CalPostExp(string str); //计算后缀表达式。
private:
INT64 _value;
string _strData;
};BigData.cpp
（1）构造函数、判断溢出、重载<<
#include "BigData.h"
const INT64 UN_INT = 0xcccccccccccccccc;
const INT64 MaxValue = 9223372036854775807;
const INT64 MinValue = -9223372036854775808;
BigData::BigData(INT64 value = UN_INT):_value(value)
{
stringstream stream;
stream << value;
stream >> _strData;
if (isdigit(_strData[0]))
{
_strData = '+' + _strData;
}
}
BigData:: BigData(const string & strData):_value(0),_strData("+0")
{
/*if (_strData.empty())
{
return ;
}*/
//
" " " 1234533"
//第一步跳过空白字符
//
char *pData = (char*)strData.c_str();
while (isspace(*pData))
{
pData++;
}
if (*pData == '\0')
{
return ;
}
//
// + -
// 0~9
// 非数字字符
//
char symbol ; //符号位。
if (*pData == '+' || *pData == '-')
{
symbol = *pData;
pData++;
}
else if (isdigit(*pData))
{
symbol = '+';
}
else
return ;
//
// 跳过前置0 "000012345678" "00000000000000"
//
while (*pData == '0')
{
pData++;
}
if (*pData == '\0')
{
return ;
}
//
// "123456asdf123456"
//
_strData.resize(strData.length()+1); //+1是只保留符号位，覆盖刚开始的0.
int idx = 1;
while (*pData != '\0')
{
if (isdigit(*pData))
{
_value = _value * 10 + *pData - '0'; //这里可能会溢出，所以_value不为真。
_strData[idx++] = *pData;
}
else
break;
pData++;
}
_strData.resize(idx);
_strData[0] = symbol;
if (symbol == '-')
{
_value = 0 - _value;
}
}
ostream& operator<<(ostream & _out,const BigData & bigdata)
{
char *pData = (char*)bigdata._strData.c_str();
if (*pData == '+') //如果是正数，不需要输出符号。
{
pData++;
}
_out << pData;
return _out;
}
bool BigData:: IsINT64OverFlow()const
{
string strTemp("+9223372036854775807"); //long long所能保存的最大值。
if (_strData[0] == '-' )
{
strTemp = "-9223372036854775808"; // long long 所能保存的最小值。
}
if (_strData.size() < strTemp.size() )
{
return false; //没有溢出。
}
else if (_strData.size() == strTemp.size() && _strData <= strTemp)
{
return false;
}
return true;
}
（2）加法：
加法///
BigData BigData:: operator+(const BigData & b)
{
if (!IsINT64OverFlow() && !b.IsINT64OverFlow())
{
if (_strData[0] != b._strData[0]) //如果两个数没有溢出，且两个数是异号，直接相加没有问题。
{
return BigData(_value+b._value);
}
else //两个没溢出的数同号可能溢出。
{ //max = 10,num1 = 4,num2 = 7,num1+num2 > max 溢出。也就是num1<max-num2没溢出
if ( (_strData[0] == '+' && MaxValue - _value >= b._value )
||(_strData[0] == '-' && MinValue -_value <= b._value))
{
return BigData(_value+b._value); //没有溢出的处理。
}
}
}
//至少有一个超出或者两个相加的结果超出。999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999 + 9999999999999999999999999
if (_strData[0] == b._strData[0])
{
return BigData(Add(_strData,b._strData));
}
//9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999 + (-2222222222222)
//-9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999 + 22222222222222222222
// return BigData(Sub(_strData,b._strData)); //这个地方有坑？ 不能直接这么写。减法也是处理的是同号。
if (_strData[0] == '+')
{
string temp = b._strData;
temp[0] = '+';
return BigData(Sub(_strData,temp));
}
else
{
string temp = b._strData;
temp[0] = '-';
return BigData(Sub(_strData,temp));
}
}
//这个Add函数和Sub函数都是处理左右两边同号的情况。
string BigData:: Add(string left,string right)
{
int LSize = left.size();
int RSize = right.size();
if (LSize < RSize) //左边的数大
{
swap(left, right);
swap(LSize, RSize);
}
string strRet;
strRet.resize(LSize+1); //可能有进位
strRet[0] = left[0]; //左边的数大，结果的符号随大数
char step = 0; //进位
for (size_t idx = 1; idx < LSize; ++idx) //跳过符号位
{
char temp = left[LSize - idx] - '0' + step; //取最右边的位。也就是最小位。
if(RSize > idx )//不能Rsize-idx > 0这么写，idx是size_t，相减还是size_t。一直大于0.这里不能等于。等于的话，right[0]为符号位，乱码。
temp += right[RSize - idx] - '0';
step = temp/10;
strRet[LSize + 1 - idx] = temp%10+'0'; //最右边的位数
}
strRet[1] = step + '0'; //可能有进位。
return strRet;
}
//减法///
BigData BigData:: operator-(const BigData & b)
{
if (!IsINT64OverFlow() && !b.IsINT64OverFlow())
{
//-999999999999999 - （-5555555555） 不可能溢出。
if (_strData[0] == b._strData[0]) //两个没有溢出的数同号相减，不可能溢出。
{
return BigData(_value - b._value);
}
else
{ //-999999999999999999999999 - 55555555555555555555555555555) 异号可能溢出，超出最小范围了。
//99999999999999999999999999 - (-444444444444444444444444444) 异号可能溢出，超过最大范围了。
if ( (_strData[0] == '+' && _value > b._value-MaxValue)
|| (_strData[0] == '-'&& _value < b._value-MinValue) )
{
return BigData(_value-b._value); //处理异号没有溢出的情况。
}
}
}
//至少有一个超出或者两个数相减超出。
//999999999999999999999999999999999999999999999999999999999999999999- 2222
//-99999999999999999999999999999999999999999999999999999999999999 - (-222)
if (_strData[0] == b._strData[0])
{
return BigData(Sub(_strData,b._strData));
}
//99999999999999999999999999999999999999999999999999 -(-222222222222)
//-9999999999999999999999999999999999999999999999999 - 2222222222222222
//return BigData(Add(_strData,b._strData)); //我觉得加法也是有坑的，但是实验发现没有坑。
if (_strData[0] == '+')
{
string temp = b._strData;
temp[0] = '+';
return BigData(Add(_strData,temp));
}
else
{
string temp = b._strData;
temp[0] = '-';
return BigData(Add(_strData,temp));
}
}
string BigData::Sub(string left,string right) // +55555555555555555555555555555555555555555555555555555555555555 left
{ // +66666666666666666666666666666666666666666666666666666666666666 right
int LSize = left.size(); // 两个正数相减，答案为负数，交换后变成下列。
int RSize = right.size(); // +66666666666666666666666666666666666666666666666666666666666666 left
// +55555555555555555555555555555555555555555555555555555555555555 right
//+号的时候左边的数小，-号的时候左边的数大就交换。 // 此时答案变成了正数，所以得把符号位改了。
char symbol = left[0]; //
if (LSize < RSize || LSize== RSize && left < right) // -5555555555555555555555555555555555555555555555555555555555555555 left
{//减法也是处理同号，所以不会出现位数相等，一个正一个负的情况 // -6666666666666666666666666666666666666666666666666666666666666666 right
swap(left, right); // 两个相减，答案为正数，交换后变成下列
swap(LSize,RSize); // -6666666666666666666666666666666666666666666666666666666666666666 left
// -55555555555555555555555555555555555555555555555555555555555555555 right
//符号 // 此时答案变成负数了，所以得把符号位改了。
if (left[0] == '+')
{
symbol = '-'; //交换后左边的数为正数，此时结果就应该为负数。
}
else
{
symbol = '+';
}
}
string strRet;
strRet.resize(LSize); //结果最多和左边的数一样的位数。
strRet[0] = symbol;
char step = 0;
for (size_t idx = 1; idx < LSize; ++idx)
{
char temp = left[LSize-idx] - '0';
if (RSize > idx)
{
temp -= right[RSize-idx] - '0';
}
if (temp < 0) //借位
{
left[LSize - idx-1] -= 1;
temp += 10;
}
strRet[LSize-idx] = temp + '0';
}
return strRet;
}
（4）乘法
/乘法
BigData BigData:: operator*(const BigData & b)
{
if ('0' == _strData[1] || '0' == b._strData[1])//其中一个操作数为0结果为0不需要操作
{
return BigData(0);
}
if (!IsINT64OverFlow() && !b.IsINT64OverFlow()) //两个数都没有溢出。
{
if (_strData[0] == b._strData[0]) //同号相乘,结果为正。可能超过最大值
{
if ((_value > 0 && MaxValue/_value >= b._value)
||(_value < 0 && MaxValue /_value <= b._value))
{
return BigData(_value*b._value);
}
}
else //异号相乘，结果为父，可能超过最小值
{
if ((_value > 0 && MinValue/_value <= b._value)
||(_value < 0 && MaxValue /_value >= b._value))
{
return BigData(_value*b._value);
}
}
}
if (b._strData == "+1" )
{
return BigData(_strData);
}
if (_strData == "+1")
{
return BigData(b._strData);
}
return BigData(Mul(_strData,b._strData));
}
string BigData:: Mul(string left,string right)
{
char symbol = '+';
int LSize = left.size();
int RSize = right.size();
if (left[0] != right[0]) //两个数异号，结果肯定是负数。
{
symbol = '-';
}
if ( LSize < RSize /*|| (LSize == RSize && left < right)*/ ) //乘法只要保证左边的位数多就可以了。
{
swap(left,right);
swap(LSize,RSize);
}
string ret;
ret.resize(LSize+RSize-1,'0'); //相乘后位数最多两个数的位数相加再减去一个多余的符号位。比如+9 * +9 = +81
ret[0] = symbol;
char offset = 0; //乘法要错位，这就是错位标志。
for (int i = 1; i < RSize; ++i)
{
char step = 0; //进位
int j = 1;
for (; j < LSize; ++j)
{
char value = (left[LSize-j] -'0') *( right[RSize-i] - '0') + step;
char temp = ret[ret.size()-j-offset] - '0'; //拿出原来这个位的数。
char num = (temp+value) % 10 ; //这个地方很关键，先把原来的数+原来的进位+这次value得到的结果求余。不会出现连环进位情况。
step = (value+temp) / 10;
ret[ret.size()-j-offset] = num +'0';
}
//还要考虑进位标志符是不是还有数据。
ret[ret.size()-j-offset] = step+'0';
offset++; //内部乘完一次乘完，就错位一次。
}
return ret;
}
/// -- 除法-- ///
BigData BigData:: operator/(const BigData & b)
{
int LSize = _strData.size(); //被除数。
int RSize = b._strData.size();//除数
char *pLeft = (char*)_strData.c_str()+1; //跳过符号位。
char *pRight = (char*)b._strData.c_str()+1; //跳过符号位。
char symbol = '+';
if (b._strData[1] == '0') //除数为0
{
cout << "除数为 0 "<<endl;
assert(0);
}
//if (!IsINT64OverFlow() && !b.IsINT64OverFlow()) //两个数不溢出。除法肯定不溢出。
//{
// return BigData(_value / b._value);
//}
if (_strData == "+0") //被除数为0.
{
return BigData(0);
}
if (LSize < RSize || (LSize==RSize && strcmp(pLeft,pRight) < 0)) //抛弃符号位后，比较大小，如果被除数小，直接返回0.
{
return BigData(0);
}
if (strcmp(pLeft,pRight) == 0) //两个数跳过符号位相等
{
BigData ret(1);
if (_strData[0] != b._strData[0]) //符号位不同
{
ret._value = -1;
ret._strData[0] = '-'; //这个地方应该要修改字符串中的符号位的，老师的没改，我觉得是错的。
}
return ret;
}
if (strcmp(pRight,"1") == 0) //除数的数值为1，结果可能为正负被除数。
{
BigData ret(_strData);
if (b._strData[0] == '-') //除数为-1
{
if (_strData[0] == '+') //被除数为正数
{
ret._strData[0] = '-';
ret._value = 0- _value;
}
else //被除数为负数。
{
ret._strData[0] = '+';
ret._value = 0- _value;
}
}
return ret; //除数为正，
}
return BigData(Div(_strData,b._strData)); //调用构造函数。
}
string BigData::Div(string left, string right)
{
//第一步先保存符号位。
char symbol = '+';
if (left[0] != right[0])
{
symbol = '-';
}
string ret;
ret += symbol;
char *pLeft = (char*)(left.c_str()+1);
char *pRight = (char*)(right.c_str()+1); //跳过各自的符号位。
int RSize = right.size()-1; //把符号位减去。
int Len = RSize; // 2222/33 第一步先拿出和33相同的位数的22,看22能整除33不，
while (*(pLeft+Len-1) != '\0') //[pLeft,pLeft+Len) 左闭右开的区间，pLeft+Len是取不到的，所以这里得-1.
{
if (*pLeft == '0') //990000000 / 33 当pLeft后面都指向0的时候就没有必要再除了，直接把后面的0搬到结果里就可以了。
{
ret.append(1,'0');
continue;
}
if (!IsLeftStrBig(pLeft,Len,pRight,RSize)) //2222 / 33 先拿22/33,左边小，所以拿出222来
{
Len++;
ret.append(1,'0');
continue;
}
else
{
ret.append(1,SubLoop(pLeft,Len,pRight,RSize)); //SubLoop(pLeft,Len,pRight,RSize)的结果就是一次商。
Len++;
}
}
return ret;
}
//这IsLeftBig和SubLoop两个函数left和right都是跳过符号位指向数据位的。
bool BigData::IsLeftStrBig(const char* left,int LSize,const char* right,int RSize)
{
if (LSize > RSize ||(LSize==RSize && strncmp(left,right,RSize) >= 0) )
{ // 222 33 刚开始要比较的是222中的22 和33比较，所以这里是ncmp比较。
return true;
}
return false;
}
char BigData:: SubLoop(char *&pLeft,int &LSize,char *pRight,int RSize) //除法时每次求商运算。
{
assert(pLeft);
assert(pRight);
char count = '0';
//这个while循环就是试除，比如222 /33 = 6, 我们可以让222一直减去33，减一次count++,最终减去6次后，剩下24小于33,6就是我们要的商。
// 222 33
while (IsLeftStrBig(pLeft,LSize,pRight,RSize))
{
for (int i = 0; i < LSize; ++i)
{
char temp = pLeft[LSize-1-i] - '0'; //拿到被除数的最低位
if(RSize > i)
temp -= (pRight[RSize-1-i] - '0'); //最低位相减。
if (temp < 0)
{
pLeft[LSize-2-i] -= 1; //次高位减1.
temp += 10;
}
pLeft[LSize-1-i] = temp + '0'; //写回去。
} //for循环完了就减去一次33.
count++;
while (*pLeft == '0' && LSize > 0) //当有前置0的时候需要跳过去。比如222 -33 某一个过程会减到090，本来90比33大，但是090字典排序小于33,不会进循环了。
{
pLeft++; //这里pLeft和LSize都移动了，要影响到外面，得用引用。
LSize--;
}
} //当减去后剩下的数比33大就一直减。
return count;
}
/// 求模 ///
//求模只和左侧符号相关，我们可以先把两个数都换成正数，模 = 被除数-除数*商，再看被除数的符号决定模的符号。
BigData BigData:: operator%(const BigData & b)
{
if (b._strData[1] == '0')
{
cout << "除数为0或对0求模: ";
return BigData(0);
}
if (_strData == "+0") //被除数为0
{
return BigData(0);
}
if (!IsINT64OverFlow() && !b.IsINT64OverFlow()) //两个数不溢出。模肯定不溢出。
{
return BigData(_value % b._value);
}
if (_strData.size() < b._strData.size())
{
return BigData(_strData); //模只和左侧符号位相关。
}
else if (_strData.size() == b._strData.size())
{
if (strcmp(_strData.c_str()+1,b._strData.c_str()+1) < 0) //比较数据部分
{
return BigData (_strData); //模只和左侧符号位相关。
}
if (strcmp(_strData.c_str()+1,b._strData.c_str()+1) == 0) //比较数据部分
{
return BigData(0);
}
}
return BigData(Mod(_strData,b._strData));
}
string BigData::Mod(string left,string right)
{
BigData n1(left.c_str()+1); //实验发现80%(-30) = 20，(-80)%(-30) = -20; (-80)%30 = -20 ,只是和左边的符号有关，和右边符号无法。
BigData n2(right.c_str()+1);
BigData n3 = n1 / n2; //商
BigData ret = n1 - n2*n3;
ret._strData[0] = left[0];
return ret._strData;
}
（7）四则运算
/* 以下是四则运算之表达式 */
/*
1.遇到操作数：直接输出（添加到后缀表达式中）
2.栈为空时，遇到运算符，直接入栈
3.遇到左括号：将其入栈
4.遇到右括号：执行出栈操作，并将出栈的元素输出，直到弹出栈的是左括号，左括号不输出。
5.遇到其他运算符：加减乘除：弹出 所有优先级大于或者等于该运算符的 栈顶元素，然后将该运算符入栈
6.最终将栈中的元素依次出栈，输出。
*/
//得到后缀表达式
string BigData::GetSuffixExpression(string str)
{
stack<char> operatorstack; //操作符栈
string postresult;
char *pst = (char*)str.c_str();
string data ;
while (*pst != '\0')
{
if (isdigit(*pst)) //如果是数据 1.遇到操作数：直接输出（添加到后缀表达式中）
{
//得到数据。
data = GetData(pst);
postresult += data;
postresult += '#'; //这个是标记，没什么意义
}
else if (IsOperator(*pst)) //如果是操作符，
{
//5.遇到其他运算符：加减乘除：弹出 所有优先级大于或者等于该运算符的 栈顶元素，然后将该运算符入栈
while ( !operatorstack.empty() &&CompareOperatorPriority(operatorstack.top(),*pst) >= 0)//栈顶元素大于等于该运算符
{
postresult += operatorstack.top();
operatorstack.pop();
}
operatorstack.push(*pst); // 2.栈为空时，遇到运算符，直接入栈
}
else if (*pst == '(') //如果是左括号（ 3.遇到左括号：将其入栈
{
operatorstack.push(*pst);
}
else if (*pst == ')') //4.遇到右括号：执行出栈操作，并将出栈的元素添加到后缀表达式，直到弹出栈的是左括号，左括号不输出。
{
while (operatorstack.top() != '(')
{
postresult += operatorstack.top();
operatorstack.pop();
}
operatorstack.pop(); //将左括号弹出。
}
pst++;
}
while (!operatorstack.empty() ) // 6.最终将栈中的元素依次出栈，输出。
{
postresult += operatorstack.top();
operatorstack.pop();
}
return postresult;
}
//根据后缀表达式计算
BigData BigData::CalPostExp(string str)
{
char* pStart = (char*)str.c_str();
stack<BigData> stackData;
string tempStr;
while(*pStart != '\0')
{
if ( isdigit(*pStart) )
{
tempStr = GetData(pStart);
BigData temp(tempStr);
stackData.push(temp);
}
if(IsOperator(*pStart))
{
BigData right(stackData.top()); //这里要注意，栈顶的是右操作数
stackData.pop();
BigData left(stackData.top());
stackData.pop();
switch(*pStart)
{
case '+':
stackData.push(left+right);
break;
case '-':
stackData.push(left-right);
break;
case '*':
stackData.push(left*right);
break;
case '/':
stackData.push(left/right);
break;
default:
cout << "后缀表达式中出现非法字符!" << endl;
return BigData(0);
}
}
pStart++;
}
return BigData(stackData.top());
}
string BigData::GetData( char *& ptr)
{
string ret;
while (isdigit(*ptr))
{
ret += *ptr;
ptr++;
}
ptr--; //这里减回去，在被调用函数中会有ptr++,
return ret;
}
bool BigData:: IsOperator(char c)
{
if( c == '+' || c == '-' || c == '*' || c == '/')
{
return true;
}else
{
return false;
}
}
int BigData::CompareOperatorPriority(char op1,char op2)
{
if (op1 == '(') //
{
return -1;
}
switch (op1)
{
case '+':
case '-':
return (op2 == '*' || op2 == '/' ? -1:0);
case '*':
case '/':
return (op2 == '-' || op2 == '+'? 1:0);
}
return -1;
}
BigData BigData:: Calculate(const string & str)//计算四则运算表达式
{
/* 检查是否合法*/
// 1. 中缀转后缀
string post = GetSuffixExpression(str);
// 2. 计算结果
return CalPostExp(post);
}
测试函数：
（1）数据的合法性：
void test()
{
BigData b1("");
BigData b2("123456789");
BigData b3("-123456789");
BigData b4("-000001234567");
BigData b5("12345asdfg123456");
BigData b6("aa12345689");
BigData b7(+123);
cout<<b1<<endl;
cout<<b2<<endl;
cout<<b3<<endl;
cout<<b4<<endl;
cout<<b5<<endl;
cout<<b6<<endl;
cout << b7 <<endl;
}
（2）加法和减法：
void testAddAndSub()
{
BigData a("999999999999999999999999999999999999999999999999999999999999999999");
BigData b("-2222");
cout << a+b <<endl;
BigData a1("2222");
BigData b1("-99999999999999999999999999999999999999999999");
cout << a1+b1 <<endl;
BigData c("9999999999999999999999999999999999999999999977777777777");
BigData d("-2222");
cout << c-d <<endl;
BigData c1("-9999999999999999999999999999999999999999999977777777777");
BigData d1("2222");
cout << c1-d1 <<endl;
BigData c3("-22222");
BigData c4("7777777777777777777777777777777777777777777777777777777");
cout << c3- c4<<endl;
BigData c2("-9999999999999999999999999999999999999999999999999999999");
BigData d2("2222222222222222222222222222222222222222222222222222222");
cout << d2 - c2 <<endl;
BigData d5("9223372036854775807");
BigData d6("-2");
BigData d7(88);
d7 = d5 - d6;
cout << d7 << endl;
}
（3）乘法：
void testMul()
{
BigData b1("-45353");
BigData b2("37353753");
BigData b3("-9223372036854775808");
BigData b4(" 9223372036854775800");
BigData b5("-9223372036854775810");
BigData b6(" 9223372036854775900");
//1、都在INT64范围内
cout << (BigData("999") * BigData("22222222222222222222222222222")) << endl;
cout << (b2 * b1) << endl;
cout << (b1 * b2) << endl;
cout << (b1 * BigData("0")) << endl;
cout << (BigData("0") * b2) << endl;
cout << endl;
cout << (b3 * b1) << endl;
cout << (b1 * b3) << endl;
cout << (b1 * b4) << endl;
cout << (b4 * b1) << endl;
cout << (b3 * b2) << endl;
cout << (b2 * b4) << endl;
cout << endl;
//2、一个在一个不在<运算后在范围内，运算后不在范围内>
cout << (BigData("0") * b6) << endl;
cout << (b5 * BigData("0")) << endl;
cout << (b5 * b1) << endl;
cout << (b1* b5) << endl;
cout << endl;
cout << (b6 * b2) << endl;
cout << (b2 * b6) << endl;
cout << endl;
cout << (b6 * b5) << endl;
cout << (b5 * b6) << endl;
cout << (b2 * b5) << endl;
cout << endl;
cout << (b1 * b6) << endl;
cout << (b6 * b1) << endl;
} 
（4）除法
void testDiv()
{
BigData b1("-45353");
BigData b2("37353753");
BigData b3("-9223372036854775808");
BigData b4(" 9223372036854775800");
BigData b5("-9223372036854775810");
BigData b6(" 9223372036854775900");
BigData b7("-1231123203367738338252");
//1、排除除数为0
// cout << (b1 / BigData(0)) << endl;
//2、在范围内
cout << (b1 / b2) << endl;
cout << (b2 / b1) << endl;
//3、不在范围内<左（被除数）比右（除数）小为0，左比右大>
cout << (b2 / b5) << endl;
cout << (b2 / b6) << endl;
cout << (b5 / b2) << endl;
cout << (b6 / b2) << endl;
cout << (b6 / b1) << endl;
cout << (b5 / b1) << endl;
cout << b7 / b1 << endl;
BigData a(222);
BigData b(33);
cout << a/b <<endl;
}
（5）求模：
void testMod()
{
BigData b1("-45353");
BigData b2("37353753");
BigData b3("-9223372036854775808");
BigData b4(" 9223372036854775800");
BigData b5("-9223372036854775810");
BigData b6(" 9223372036854775900");
BigData b7("-1231123203367738338252");
//1、排除除数为0
//cout << (b1 / BigData(0)) << endl;
//2、在范围内
cout << (b1 % b2) << endl;
cout << (b2 % b1) << endl;
//3、不在范围内
cout << (b2 % b5) << endl;
cout << (b2 % b6) << endl;
cout << (b5 % b2) << endl;
cout << (b6 % b2) << endl;
cout << (b6 % b1) << endl;
cout << (b5 % b1) << endl;
cout << b7 % b1 << endl;
}
（6）四则运算：
void testexpression()
{
BigData ret = BigData::Calculate("989416326513+(547461030974961130-46113031)*46413031+1/2");
cout << ret <<endl;
BigData ret2 = BigData::Calculate("12 * ( 3 + 4 )- 6 + 8 / 2");
cout << ret2 <<endl;
}
扫一扫
1976
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
