#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
using namespace std;
// 大整数类型
class BigInt
{
public:
BigInt(string str) :strDigit(str) {}
BigInt operator=(const BigInt &src)//赋值运算符的重载
{
return BigInt(this->strDigit = src.strDigit);
}
private:
string strDigit; // 使用字符串存储大整数
friend ostream& operator<<(ostream &out, const BigInt &src);
friend BigInt operator+(const BigInt &lhs, const BigInt &rhs);
friend BigInt operator-(const BigInt &lhs, const BigInt &rhs);
friend bool isBig(const BigInt & lhs, const BigInt & rhs);
};
// 打印函数
ostream& operator<<(ostream &out, const BigInt &src)
{
out << src.strDigit;
return out;
}
bool isBig(const BigInt & lhs, const BigInt & rhs)//判断两个大数的大小
{
int llen = lhs.strDigit.length();
int rlen = rhs.strDigit.length();
if (llen > rlen)
{
return true;
}
else if (llen < rlen)
{
return false;
}
else//长度相同，按位比较
{
if (lhs.strDigit >= rhs.strDigit)
{
return true;
}
else
{
return false;
}
}
}
int main()
{
BigInt int1("9785645649886874535428765");
BigInt int2("28937697857832167849697653231243");
BigInt int3("9785645649886874535428765");
//28937707643477817736572188660008
//28937707643477817736572188660008
cout << int1 + int2 << endl;
//28937688072186517962823117802478
//28937688072186517962823117802478
cout << int1 - int2 << endl;
return 0;
}
大数的加法
- 遍历字符串l，r，从后往前遍历
- 同位置的数字相加， 进位 flag 存入一个结果当中 string result
- 同时完成、某个字符串先完成 都要考虑进位
// 大数加法
BigInt operator+(const BigInt &lhs, const BigInt &rhs)
{
/*
t
*/
string result;
bool flag = false;
int size1 = lhs.strDigit.length() - 1;
int size2 = rhs.strDigit.length() - 1;
int i = size1, j = size2;
for (; i >= 0 && j >= 0; --i, --j)
{
int ret = lhs.strDigit[i] - '0' + rhs.strDigit[j] - '0';
if (flag)
{
ret += 1;
flag = false;
}
if (ret >= 10)
{
ret %= 10;
flag = true;
}
result.push_back(ret + '0');
}
// i j
if (i >= 0)
{
while (i >= 0)
{
int ret = lhs.strDigit[i] - '0';
if (flag)
{
ret += 1;
flag = false;
}
if (ret >= 10)
{
ret %= 10;
flag = true;
}
result.push_back(ret + '0');
i--;
}
}
else if (j >= 0)
{
while (j >= 0)
{
int ret = rhs.strDigit[j] - '0';
if (flag)
{
ret += 1;
flag = false;
}
if (ret >= 10)
{
ret %= 10;
flag = true;
}
result.push_back(ret + '0');
j--;
}
}
if (flag)
{
result.push_back('1');
}
reverse(result.begin(), result.end());
return result; // return BigInt(result);
}
大数的减法
-
找大的字符串做被减数，小的做减数
-
遍历两个字符串，减法，借位（bool flag）， string result 存下来
-
长度大的字符串减去长度小的字符串，小的字符串遍历完，对于大字符串要考虑借位
-
长度相等的字符串进行减法，最后不用考虑借位，直接用大数减去小数，前边添“-”
// 大数减法
BigInt operator-(const BigInt &lhs, const BigInt &rhs)
{
string result;
bool flag = false;
bool minor = false;
string maxStr = lhs.strDigit;
string minStr = rhs.strDigit;
if (maxStr.length() < minStr.length())
{
maxStr = rhs.strDigit;
minStr = lhs.strDigit;
minor = true;
}
else if (maxStr.length() == minStr.length())
{
if (maxStr < minStr)
{
maxStr = rhs.strDigit;
minStr = lhs.strDigit;
minor = true;
}
else if (maxStr == minStr)
{
return string("0");
}
}
else
{
;
}
int size1 = maxStr.length() - 1;
int size2 = minStr.length() - 1;
int i = size1, j = size2;
for (; i >= 0 && j >= 0; --i, --j)
{
int ret = maxStr[i] - minStr[j];
if (flag)
{
ret -= 1;
flag = false;
}
if (ret < 0)
{
ret += 10;
flag = true;
}
result.push_back(ret + '0');
}
while (i >= 0)
{
int ret = maxStr[i]-'0';
if (flag)
{
ret -= 1;
flag = false;
}
if (ret < 0)
{
ret += 10;
flag = true;
}
result.push_back(ret + '0');
i--;
}
if (minor)
{
result.push_back('-');
}
reverse(result.begin(), result.end());
string result1;
int flag1 = 0;
for (int i = 0; i < result.size();)
{
if (result[0] == '-')
{
result1.push_back('-');
i++;
}
while (result[i] == '0'&&flag1==0&& i < result.size())//去掉前边的0
{
i++;
}
flag1 = 1;
result1.push_back(result[i]);
i++;
}
return result1;
}
大数的乘法
//乘法
BigInt operator*(const BigInt &lhs, const BigInt &rhs)
{
int len1 = lhs.strDigit.size();
int len2 = rhs.strDigit.size();
vector<int> vec(len1+len2,0);
string result;
for (int i = 0; i < len1; i++)
{
for (int j = 0; j < len2; j++)
{
vec[i + j + 1] += (lhs.strDigit[i]-'0') * (rhs.strDigit[j]-'0');
}
}
int len3 = vec.size();
for (int i = len3 - 1; i >= 0; --i)
{
if (vec[i] >= 10)
{
vec[i - 1] += vec[i] / 10;
vec[i] = vec[i] % 10;
}
}
for (int i = 0; i < len3; ++i)
{
result.push_back(vec[i] + '0');
}
return result;
}
大数的除法
基本思想： 利用减法操作来实现，反复做除法，看从被除数里面最多能减去多少个除数，商就是多少。逐个减显然太慢，要判断一次最多能减少多少个整数(除数)的10的n次方。
- 被除数小于除数，直接返回0
- 计算两个数的长度之差
- 给除数第一次加上长度之差r个0每次计算减的次数，并将次数加r个零添加进容器
- 第一次循环之后的差作为第二次循环的被减数，给除数加r-1个0，计算减的次数，并将次数加r-1个0添加进容器
- 依次类推
- 最后将容器中的元素全部进行相加，即为所得的商
以7546除以23为例：
先用7546减去23的100倍，即减去2300，可以减3次，余下646，此时商就是300 (300=100*3)；
然后646减去23的10倍，即减去230，可以减2次，余下186，此时商就是320 (320=300+10*2)；
然后186减去23，可以减8次，余下2，此时商就是328 (328=320+1*8)；
因为2除以23的结果小于1，不用计算小数点位，所以不必再继续算下去了。
BigInt operator/(const BigInt &lhs, const BigInt &rhs)
{
if (lhs.strDigit == rhs.strDigit)//被除数和除数相等直接返回1
{
return string("1");
}
if (!isBig(lhs, rhs))//除数大于被除数
{
return string("0");
}
//一般情况：被除数大于除数
//得到长度差
int lendiffer = lhs.strDigit.length() - rhs.strDigit.length();
vector<BigInt>resvec;//存放结果的容器
BigInt lhstmp = lhs;
//开始循环
for (;lendiffer >= 0; --lendiffer)
{
BigInt rhstmp = rhs;
int k = lendiffer;
while (k > 0)//给被除数添加0
{
rhstmp.strDigit+= '0';
k--;
}
BigInt result("");//保存每次减完的结果
BigInt count("");//记录次数
//判断添完0之后的除数，如果大于被除数，代表一次都不能减
if (isBig(rhstmp.strDigit, lhstmp.strDigit))
{
rhstmp= rhs;//进行下一次的运算？？？
continue;
}
//如果被除数大于添加完0之后的除数， 代表至少可以减一次
do
{
result = lhstmp - rhstmp;
if (!isBig(result,rhstmp))//减完之后的结果小于减数，停止运算
{
lhstmp= result;
count = count + BigInt("1");
break;
}
lhstmp= result;
count = count + BigInt("1");
} while (isBig(result.strDigit, rhstmp.strDigit));
k = lendiffer;//恢复k的值，给次数加0
while (k > 0)
{
count.strDigit.push_back('0');
k--;
}
//将第一轮的结果添加进容器中
resvec.push_back(count);
}
BigInt res("");//保存商
for (int i = 0; i < resvec.size(); ++i)
{
res = res + resvec[i];
}
return res;
}