大数运算实现加减乘除四则运算

首先，让我们先来熟悉一下两种防止头文件被重复引用的处理#pragma once和#ifndef的区别

????????http://www.voidcn.com/article/p-hwdpsafs-wx.html

????接下来，开始我们的主题 <大数运算>
????在平时生活中细心的你可能会发现，好多时候我们使用计算器时，总有一个显示的最大值，当计算超过这个值时就不能再计算了，那如果我们想要计算更大的数值要怎么办？

????本文通过C++编程实现 大数的加减乘除四则运算

????<思路与方法同样都在程序内部>

????这次通过标准的三个文件来实现声明<BIGDATA.h>、定义实现函数功能<BIGDATA.cpp>、测试<test.cpp>

<BIGDATA.h>

#pragma?once

#ifndef?__BIGDATA_H__
#define?__BIGDATA_H__

#define?_CRT_SECURE_NO_WARNINGS?1
#include<iostream>
using?namespace?std;
#include<string.h>
#include<assert.h>

//1、考虑当数值小时，运算速度尽量贴近内置类型（所以，结构会有两个-->内置类型long?long?及大数的?char*）
//2、构造时可能的输入{"1234"?"0001234"??"1564adf"??"???"??"+(-)12345"?}
//

typedef?long?long?INT64;

//string?MAX_INT64?=?"9223372036854775807";
//string?MIN_INT64?=?"-9223372036854775808";

//enum{?MAX_INT64?=?9223372036854775807,?MIN_INT64?=?-9223372036854775808?};//不行enum后是int类型
//

const?INT64?MAX_INT64?=?0x7fffffffffffffff;//?9223372036854775807;
const?INT64?MIN_INT64?=?0x8000000000000000;//-9223372036854775808;


class?BigData
{
public:
?BigData(INT64?value?=?0);
?BigData(const?string?pData);

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

?~BigData();

?void?Print();

private:
?bool?PDataIsOverINT64()const;
?friend?std::ostream&operator<<(std::ostream&?_cout,?const?BigData&?bigdata);//不能在_cout前加const???->_cout<<10<<endl;将不能通过
?
?BigData?Add(string?pData1,?string?pData2);//并不一定要写成成员函数?(也可以写成一般函数被使用)
?BigData?Sub(string?pData1,?string?pData2);
?BigData?Mul(string?pData1,?string?pData2);
?BigData?Div(string?pData1,?string?pData2);

private:
?INT64?_value;
?string?_pData;
};

#endif?__BIGDATA_H__


//<BIGDATA.cpp>


#include"BIGDATA.h"

BigData::BigData(INT64?value)//若输入的数值位数大于MAX_DATA，系统编译不通过，当位数一致且大于时，转为负，无能为力
?:_value(value)
{
?//在_pData中加入value
?void?Invert(string&?pdata);
?size_t?i?=?0;
?INT64?tmp?=?0;
?_pData.append(1,?'+');
?if?(value?<?0)
?{
??_pData[0]?=?'-';
??value?*=?-1;
?}
?while?(value?!=?0)
?{
??tmp?=?value?%?10;
??_pData.append(1,?(char)(tmp?+?'0'));
??value?/=?10;
?}
?Invert(_pData);
}

BigData::BigData(const?string??pData)
{
?//解决各种特殊情况
?//{"1234"?"0001234"??"1564adf"??"???"??"+(-)12345"?NULL?}
?//参考atoi()函数处理办法
?

?//跳过符号将输入字符串都归为一般

//??//判是否是数字字符isdigit(int?c)是-1/否0??还有判空字符（宏定义）?isspace(int?c)??头文件<ctype.h>

?char*?tmp?=?(char*)&pData[0];
?_pData.append(1,?'+');??//添加符号(默认为'+')

?if?((*tmp?<?'0'?||?*tmp?>?'9')?&&?*tmp?!=?'?'&&?*tmp?!=?'+'&&?*tmp?!=?'-'&&?*tmp?!=?'t')??//排除其他符号
?{
??//cout?<<?"false"?<<?endl;
??_pData.append(1,?'0');
??_value?=?0;
??return;
?}

?while(isspace(*tmp))?//while?(*tmp=='?')???//消除前面的空格(tab)
?{
??tmp++;
?}

?if?(*tmp?==?'+'?||?*tmp?==?'-')??//跳过符号/修正符号
?{
??if?(*tmp?==?'-')
??{
???_pData[0]?=?'-';
??}
??tmp++;
?}

?while?(*tmp?==?'0')???//消除前面的0（必须先消除空格，再消除0，最后判断+（-））
?{
??tmp++;
?}

//*********************
?//一个一个追加效率不高-->转化为一次开辟
?//while(isdigit(*tmp))??//while?(*tmp?>=?'0'&&?*tmp?<=?'9')
?//{
?//?_pData.append(1,?*tmp++);
?//}
//*********************

?_pData.resize(strlen(tmp)?+?1);
?int?i?=?1;
?while?(isdigit(*tmp))
?{
??_pData[i++]?=?*tmp++;
?}

?if?(*tmp?!=?'')
?{
??//cout?<<?"false"?<<?endl;
??_value?=?0;
??return;
?}

?//若超出INT64表示的范围则用string管理，否则用INT64,string综合管理
?if?(!PDataIsOverINT64())
?{
??size_t?i?=?1;
??_value?=?0;
??for?(i?=?1;?i?<?_pData.size();?i++)
??{
???_value?=?_value?*?10?+?_pData[i]?-?'0';
??}
??if?(_pData[0]?==?'-')
???_value?*=?-1;
?}

}

BigData::~BigData()
{}

bool?BigData::PDataIsOverINT64()const
{
?std::string?tmp("+9223372036854775807");
?if?(_pData[0]?==?'-')
?{
??tmp?=?"-9223372036854775808";
?}

?if?((_pData.size()?<?tmp.size())||
??(_pData.size()?==?tmp.size()?&&?_pData?<=?tmp))
?{
??return?false;
?}
?return?true;

}

std::ostream&?operator<<(std::ostream&?_cout,?const?BigData&?bigdata)//不能在_cout前加const???->_cout<<10<<endl;将不能通过
{
?if?(!bigdata.PDataIsOverINT64())
?{
??_cout?<<?bigdata._value;
?}
?else
?{
??char*?tmp?=?(char*)&bigdata._pData[0];
??if?('+'?==?*tmp)
??{
???tmp++;
??}
??while?(*tmp)
??{
???_cout?<<?*tmp++;
??}
??//_cout?<<?endl;
?}
?return?_cout;
}

void?BigData::Print()
{
?if?(!PDataIsOverINT64())
?{
??cout?<<?_value?<<?endl;???//printf("%lldn",?_value);
??return;
?}
?if?(*(char*)&_pData[0]?==?'+')
?{
??printf("%sn",?&_pData[1]);
??return;
?}
?printf("%sn",&_pData[0]);
}

void?Invert(string&?pdata)
{
?int?left?=?1;
?int?right?=?pdata.size()?-?1;
?while?(left?<?right)
?{
??swap(pdata[left++],?pdata[right--]);
?}
}

BigData?BigData::?operator+(const?BigData?bigdata)
{
?//1、都在INT64范围内<运算后在范围内，运算后不在范围内>（再进行构造可以解决）
?//2、都不在INT64范围内<运算后在范围内，运算后不在范围内>
?//3、一个在一个不在<运算后在范围内，运算后不在范围内>
?//
?//如果全部用string进行计算，就达不到数值小时用基本类型提高运算的目的
?//由于实现结构是若在INT64范围内_value与_pData共同管理，若不在只由_pData管理

?//所以，可以将上面分化成两类<1、都在范围内(<运算后在范围内，运算后不在范围内>)?2、至少有一个不在范围内>


?if?(!PDataIsOverINT64()?&&?!bigdata.PDataIsOverINT64())
?{
??if?(_pData[0]?!=?bigdata._pData[0])//若异号，则肯定不会溢出
??{
???return?BigData(_value?+?bigdata._value);
??}
??else?//同号
??{
???if?(_pData[0]?==?'+')//为正
???{
????if?(_value?<=?MAX_INT64?-?bigdata._value)//结果不溢出
????{
?????return?BigData(_value?+?bigdata._value);
????}
????else?//结果溢出
????{
?????return?BigData(Add(_pData,?bigdata._pData));
????}
???}
???else?//为负
???{
????if?(_value?>=?MIN_INT64?-?bigdata._value)//结果不溢出
????{
?????return?BigData(_value?+?bigdata._value);
????}
????else?//结果溢出
????{
?????return?BigData(Add(_pData,?bigdata._pData));
????}
???}
??}
?}
?else//至少有一个溢出
?{
??return?BigData(Add(_pData,?bigdata._pData));
?}
}



BigData?BigData::?operator-(const?BigData?bigdata)
{
?//1、都在范围内(运算后在范围内，运算后不在范围内)?
?//2、至少有一个不在范围内

?if?(!PDataIsOverINT64()?&&?!bigdata.PDataIsOverINT64())
?{
??//同号相减不可能溢出，异号相减才可能溢出

??if?(_pData[0]?==?bigdata._pData[0])//同号
??{
???return?BigData(_value?-?bigdata._value);
??}
??else//?异号
??{
???if?(_pData[0]?==?'+')//第一个为正，第二个为负
???{
????if?(_value?<?MAX_INT64?+?bigdata._value)//结果不溢出
????{
?????return?BigData(_value?-?bigdata._value);
????}
????else???//结果溢出
????{
?????return?Sub(_pData,?bigdata._pData);
????}
???}
???else?//第一个为负，第二个为正
???{
????if?(_value?>?MIN_INT64?+?bigdata._value)//结果不溢出
????{
?????return?BigData(_value?-?bigdata._value);
????}
????else???//结果溢出
????{
?????return?Sub(_pData,?bigdata._pData);
????}
???}
??}
?}
?else
?{
??return?Sub(_pData,?bigdata._pData);
?}
}

void?_EachAdd0(string&?pdate)?//各项添加'0'
{
?int?size?=?pdate.size();
?int?i?=?1;
?for?(i?=?1;?i?<?size;?i++)
?{
??pdate[i]?+=?'0';
?}
}

void?_EachSub0(string&?pdate)?//各项去'0'
{
?int?size?=?pdate.size();
?int?i?=?1;
?for?(i?=?1;?i?<?size;?i++)
?{
??pdate[i]?-=?'0';
?}
}

BigData?BigData::?Add(string?pData1,?string?pData2)
{
?//转化为string中从低到高字符相加
?//若同号?就相加，若异号，转为减

?if?(pData1[0]?!=?pData2[0])//异号
?{
??if?(pData1[0]?==?'+')
??{
???pData2[0]?=?'+';
???return?Sub(pData1,?pData2);
??}
??else
??{
???pData1[0]?=?'+';
???return?Sub(pData2,?pData1);
??}
?}
?else//同号??
?{
??//判断哪个位数多，放在前面
??if?(pData1.size()?<?pData2.size())
??{
???swap(pData1,?pData2);
??}

??std::string?tmp;
??int?size1?=?pData1.size();
??int?size2?=?pData2.size();
??int?sizet?=?size1?+?1;
??int?flag?=?0;
??tmp.resize(size1?+?1);
??tmp[0]?=?pData1[0];

??for?(int?i?=?0;?i?<?size1?-?1;?i++)
??{
???flag?=?0;
???char?cur?=?'0';
???if?(size2?-?1?-?i?>?0)
???{
????cur?=?pData2[size2?-?1?-?i];
???}
???tmp[sizet?-?i-1]?=?pData1[size1?-?1?-?i]?+?cur?-?2?*?'0';//tmp存数值而不是数字字符
???if?(tmp[size1?-?i]?/?10?==?1)
???{
????flag?=?1;
????tmp[size1?-?i]?%=?10;
???}
???
???pData1[size1?-?i?-?2]?+=?flag;
??}
??tmp[1]?=?flag;
??_EachAdd0(tmp);

??return?BigData(tmp);
?}
}


BigData?BigData::Sub(string?pData1,?string?pData2)
{
?//转化为string中从低到高字符相减
?//若同号?就相减（注意前后位数不同），若异号，转为加

?if?(pData1[0]?!=?pData2[0])//异号
?{
??if?(pData1[0]?==?'+')
??{
???pData2[0]?=?'+';
???return?Add(pData1,?pData2);
??}
??else
??{
???pData2[0]?=?'-';
???return?Add(pData1,?pData2);
??}
?}
?else??//同号
?{
??//取数值的符号，将较大值放在前面

??if?(pData1.size()?<?pData2.size()?||
???(pData1.size()?==?pData2.size()?&&?(strcmp(pData1.c_str(),?pData2.c_str())?<?0)))
??{
???if?(pData1[0]?==?'+')
???{
????pData2[0]?=?'-';
???}
???else
???{
????pData2[0]?=?'+';
???}
???swap(pData1,?pData2);???
??}
??std::string?tmp;
??int?size1?=?pData1.size();
??int?size2?=?pData2.size();
??int?sizet?=?size1;
??int?flag?=?0;
??tmp.resize(sizet);
??tmp[0]?=?pData1[0];
??for?(int?i?=?0;?i?<?size1?-?1;?i++)
??{
???flag?=?0;
???int?cur?=?0;
???if?(i?<?size2?-?1)
???{
????cur?=?pData1[size1?-?i?-?1]?-?pData2[size2?-?i?-?1];
???}
???else
???{
????cur?=?pData1[size1?-?i?-?1]?-?'0';
???}
???if?(cur?<?0)
???{
????flag?=?1;
????cur?+=?10;
???}
???tmp[sizet?-?1?-?i]?=?cur?+?'0';

???pData1[size1?-?2?-?i]?-=?flag;

??}
??return?BigData(tmp);
?}
}


BigData?BigData::?operator*(const?BigData?bigdata)
{
?//1、都在INT64范围内<运算后在范围内，运算后不在范围内>
?//???同号与?MAX_DATA比较??异号与MIN_DATA比较
?//2、至少一个不在范围内
?if?(0?==?_value?||?0?==?bigdata._value)
?{
??return?BigData(0);
?}
?if?(!PDataIsOverINT64()?&&?!bigdata.PDataIsOverINT64())
?{
??if?(_pData[0]==bigdata._pData[0])//同号
??{
???if?(_value?>=?0)//为正
???{
????if?(_value?<?MAX_INT64?/?bigdata._value)//结果在范围内
????{
?????return?BigData(_value*bigdata._value);
????}
????else?//?结果不在范围内
????{
?????return?Mul(_pData,bigdata._pData);
????}
???}
???else//为负
???{
????if?(_value?>?MAX_INT64?/?bigdata._value)//结果在范围内
????{
?????return?BigData(_value*bigdata._value);
????}
????else?//?结果不在范围内
????{
?????return?Mul(_pData,?bigdata._pData);
????}
???}
??}
??else??//异号
??{
???if?(_value?>=?0)//为正?负
???{
????if?(_value?<?MIN_INT64?/?bigdata._value)//结果在范围内
????{
?????return?BigData(_value*bigdata._value);
????}
????else?//?结果不在范围内
????{
?????return?Mul(_pData,?bigdata._pData);
????}
???}
???else?//为?负?正
???{
????if?(_value?>?MIN_INT64?/?bigdata._value)//结果在范围内
????{
?????return?BigData(_value*bigdata._value);
????}
????else?//?结果不在范围内
????{
?????return?Mul(_pData,?bigdata._pData);
????}
???}
??}
?}
?else
?{
??return?Mul(_pData,?bigdata._pData);
?}
}

BigData?BigData::Mul(string?pData1,?string?pData2)
{
?//同号?异号??先大数?后小数??
?//为提高效率?外层循环次数少，内层次数多

?std::string?tmp;
?int?size1?=?pData1.size();
?int?size2?=?pData2.size();
?int?sizet?=?size1?+?size2;
?tmp.resize(size1?+?size2);
?tmp[0]?=?'+';
?if?(pData1[0]?!=?pData2[0])//同号?异号?
?{
??tmp[0]?=?'-';
?}

?if?(size1?<?size2?||?(size1?==?size2&&strcmp(&pData1[0],?pData2.c_str())?<?0))//先大数?后小数
?{
??swap(pData1,?pData2);
??swap(size1,?size2);
?}

?_EachSub0(pData1);
?_EachSub0(pData2);
?//tmp初始化时?全为?0
?for?(int?i?=?1;?i?<?size2;?i++)//小数位数??
?{
??if?(pData2[size2?-?i]?==?0)??//若位数上为0则跳过
??{
???continue;
??}
??for?(int?j?=?1;?j?<?size1;?j++)//大数位数
??{
???if?(pData1[size1?-?j]?==?0)??//若位数上为0则跳过
???{
????continue;
???}
???tmp[sizet?-?j?-?i?+?1]?+=?pData1[size1?-?j]?*?pData2[size2?-?i];
???if?(tmp[sizet?-?j?-?i?+?1]>=10)
???{
????tmp[sizet?-?j?-?i]?+=?tmp[sizet?-?j?-?i?+?1]?/?10;
????tmp[sizet?-?j?-?i?+?1]?%=?10;
???}
??}

?}

?for?(int?i?=?0;?i?<?sizet?-?1;?i++)
?{
??if?(tmp[sizet?-?i?-?1]?>=?10)
??{
???tmp[sizet?-?i?-?2]?+=?tmp[sizet?-?i?-?1]?/?10;
???tmp[sizet?-?i?-?1]?%=?10;
??}
?}

?_EachAdd0(tmp);
?return?BigData(tmp);
}

BigData?BigData::?operator/(const?BigData?bigdata)
{
?//1、排除除数为0
?//2、在范围内，不在范围内
?//3、不在范围内<左（被除数）比右（除数）小为0，左比右大>
?//4、正负

?if?(0?==?bigdata._value)
?{
??assert(false);
?}

?if?(!PDataIsOverINT64()?&&?!bigdata.PDataIsOverINT64())
?{
??return?BigData(_value?/?bigdata._value);
?}
?else
?{
??//左（被除数）比右（除数）小为0
??if?(_pData.size()?<?bigdata._pData.size()?||
???(_pData.size()?==?bigdata._pData.size()?&&?_pData[0]?==?bigdata._pData[0]&&
???strcmp((char*)&_pData[0],(char*)&bigdata._pData[0])?<?0))
??{
???return?BigData(0);//正0?负0?都记为0?
??}
??else?//左比右大
??{
???return?Div(_pData,?bigdata._pData);
??}
?}
}



BigData?BigData::Div(string?pData1,?string?pData2)
{
?//正负且?参数左大右小
?char*?_trueDiv(char*?tp1,?char*?tmp2,?int?size,?string&?cur);

?string?cur;
?cur.append(1,?'+');
?if?(pData1[0]?!=?pData2[0])
?{
??cur[0]?=?'-';
?}

?char*?tmp1?=?(char*)malloc(pData1.size());//?*tmp2?=?(char*)malloc(pData2.size());
?strcpy(tmp1,?&pData1[1]);?//strcpy内部实现free(tmp1)
?char*tmp2?=?&pData2[1];
?int?size2?=?strlen(tmp2);
?int?sizermd?=?size2;
?int?excursion?=?size2;
?char*?rmd?=?NULL;

?while?(strlen(tmp1)?>?strlen(tmp2)?||?
??(strlen(tmp1)?==?strlen(tmp2)?&&?strcmp(tmp1,?tmp2)?>?0))//左大于右时，循环
?{??
??while?(sizermd?<?size2?||?(sizermd?==?size2&&strncmp(tmp1,?tmp2,?sizermd)<0))//不够?商0
??{
???cur.append(1,?'0');
???sizermd++;
???++excursion;
??}

??rmd?=?_trueDiv(tmp1,?sizermd,?cur);//?16713??31071??
??sizermd?=?strlen(rmd);
??
??strcat(rmd,?&pData1[++excursion]);

??tmp1?=?rmd;
??sizermd++;??//?将余数与剩余被除数相接
?}

?return?BigData(cur);
}

char*?_trueDiv(char*?tp1,?char*?tp2,?int?size1,?string&?cur)
{
?//只有tp1和?tp2位数相同且比tp2大，或者比tp2多一位的情况
?int?size2?=?strlen(tp2);

?int?i?=?0;
?tp1[size1]?=?'';

?char?count?=?0;
?int?flag?=?0;

?while?(size1?>?size2?||
??(size1?==?size2&&strcmp(tp1,?tp2)?>?0))//tp1大于tp2
?{
??for?(i?=?0;?i?<?size1;?i++)
??{
???flag?=?0;
???int?count?=?0;
???if?(i?<?size2)
???{
????count?=?tp1[size1?-?i?-?1]?-?tp2[size2?-?i?-?1];
???}
???else
???{
????count?=?tp1[size1?-?i?-?1]?-?'0';
???}
???if?(count?<?0)
???{
????flag?=?1;
????count?+=?10;
???}
???tp1[size1?-?1?-?i]?=?count?+?'0';

???tp1[size1?-?2?-?i]?-=?flag;

???while?(*tp1?==?'0'?&&?size1>1)//可能出现整除情况
???{
????tp1++;
????size1--;
???}

??}
??count++;
?}

?cur.append(1,?count?+?'0');
?return?tp1;
}


//<test.cpp>


#include"BIGDATA.h"

void?test()
{
?BigData?b0(13215156);
?BigData?b10(-13215156);
?BigData?b11(9787687678661325156);//当传入的数值大于MAX_DATA且位数相等时，编译器不能检测，导致由正转负
?BigData?b12(-9223372036854775807);
?BigData?b1("a13215jfiow");
?b1.Print();
?cout?<<?b1<<?endl;
?BigData?b2("+000023215");
?cout?<<?b2?<<?endl;
?b2.Print();
?BigData?b3("?33215jfiow");?//(Tab、空格键消除用isspace（int）)
?cout?<<?b3?<<?endl;
?b3.Print();
?BigData?b4("????-33215jfiow");
?cout?<<?b4?<<?endl;
?b4.Print();
?BigData?b5("43215jfiow");
?b5.Print();
?cout?<<?b5?<<?endl;

?//BigData?b6("4321537537354373783783");
?//b6.Print();?
?//cout?<<?b6?<<?endl;
?BigData?b7("-43215378338735373783537");
?cout?<<?b7?<<?endl;
?b7.Print();
?BigData?b8("-9223372036854775808");
?cout?<<?b8?<<?endl;
?b8.Print();
?BigData?b9("-999999");
?cout?<<?b9?<<?endl;
?b9.Print();

?BigData?b101("43215378338735373783537");
?BigData?b102("-43215378338735373783537");
?BigData?b103("-43215378338735373783537");
?BigData?b110("-43215378338735373783537");

?(b2?+?b9).Print();
?cout?<<?(b2?+?b9)?<<?endl;
}

void?testAdd()
{
?BigData?b1("-45353");
?BigData?b2("37353753");
?BigData?b3("-9223372036854775808");
?BigData?b4("?9223372036854775800");
?BigData?b5("-9223372036854775810");
?BigData?b6("?9223372036854775900");

?cout?<<?(b1?+?b1)?<<?endl;?
?cout?<<?(b2?+?b2)?<<?endl;
?cout?<<?(b1?+?b2)?<<?endl;
?cout?<<?(b1?+?b4)?<<?endl;

?cout?<<?b3?<<?endl;
?cout?<<?(b1?+?b3)?<<?endl;
?cout?<<?(b2?+?b4)?<<?endl;

?cout?<<?(b2?+?b5)?<<?endl;
?cout?<<?(b1?+?b6)?<<?endl;
?cout?<<?(b6?+?b1)?<<?endl;

}

void?testSub()
{
?BigData?b1("-45353");
?BigData?b2("37353753");
?BigData?b3("-9223372036854775808");
?BigData?b4("?9223372036854775800");
?BigData?b5("-9223372036854775810");
?BigData?b6("?9223372036854775900");

?cout?<<?(b1?-?b2)?<<?endl;
?cout?<<?(b2?-?b1)?<<?endl;?
?cout?<<?(b3?-?b1)?<<?endl;
?cout?<<?(b1?-?b4)?<<?endl;
?cout?<<?(b3?-?b2)?<<?endl;
?cout?<<?(b4?-?b1)?<<?endl;
?cout?<<?(b1?-?b3)?<<?endl;
?cout?<<?(b2?-?b4)?<<?endl;
?cout?<<?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?<<?(b1?-?b6)?<<?endl;
?cout?<<?(b6?-?b1)?<<?endl;

}


void?testMul()
{
?BigData?b1("-45353");
?BigData?b2("37353753");
?BigData?b3("-9223372036854775808");
?BigData?b4("?9223372036854775800");
?BigData?b5("-9223372036854775810");
?BigData?b6("?9223372036854775900");

?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;


?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;
?BigData?b7("-203367738338252");
?cout?<<?b7*b1?<<?endl;
}


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;
}

int?main()
{
?//testAdd();
?//testSub();
?//testMul();
?testDiv();
?system("pause");
?return?0;
}