网易笔试题 | C++实现大数的加减法（代码详解）

大数运算-------加法/减法

题目描述

编程（网易笔试题）： 请实现以下类的方法，完成大数的加减法（可以使用STL容器）
// 大整数类型
class BigInt
{
public:
	BigInt(string str) :strDigit(str){}
private:
	string strDigit; //使用字符串存储大整数
};
	// 打印函数
	ostream& operator<<(ostream &out, const BigInt &src);
	// 大数加法
	BigInt operator+(const BigInt &lhs, const BigInt &rhs);
	// 大数减法
	BigInt operator-(const BigInt &lhs, const BigInt &rhs);
int main()
{
	BigInt int1("28937697857832167849697653231243");
	BigInt int2("9785645649886874535428765");
	cout << int1 + int2 << endl;
	cout << int1 - int2 << endl;
	return 0;
}

通过代码我们来详细理解解题的整个思路

构造大整数类

#include "stdafx.h"
#include 
#include  // 泛型算法的头文件
#include 
#include 
// 定义了一个大整数类
class BigInt
{
public:
	BigInt(string str) :strDigit(str) {}
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);
};

输出运算符<<的重载函数

// 打印函数
ostream& operator<<(ostream &out, const BigInt &src)
{
	out << src.strDigit;
	return out;
}

加号+运算符的重载函数

解题思路

*遍历字符串lhs，rhs，都是从后往前遍历
同位置的数字相加， 设置状态位flag初始化为false表示没有进位
若有进位flag则将置为true  
结果存入到string result当中 
若同时完成 或者某个字符串先完成   最后都要考虑进位*

// 大数加法
BigInt operator+(const BigInt &lhs, const BigInt &rhs)
{
	string result; //每一位相加的结果放在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)
	{
		//由于strDigit[i]位的值为字符，所以要将其变成数字进行加减法，必须要
		//减掉字符‘0’的ascii码将其转换成数值
		int ret = lhs.strDigit[i] - '0' + rhs.strDigit[j] - '0'; 
		if (flag) //如果flag为true则表示有进位，ret要+1，进位之后要把flag置回false供下次使用
		{
			ret += 1;
			flag = false;
		}

		if (ret >= 10)//如果ret>=10则表示有进位，flag置为true，ret的值为他自己模10的余数。
		{
			ret %= 10;
			flag = true;
		}
		result.push_back(ret + '0');
		//把ret+‘0’这个字符尾插到result这个字符串里里边；这样插进去的位置
		//刚好是颠倒的，在最后会统一翻转成正确的顺序。
	}
	
	//退出这个循环的原因要么是i>=0要么是j>=0;
	//由于两个数可能不一样长 所以会导致加到最后剩下一个数还有没运算的
	//而另外一个已经加完了，这个时候也不能把剩下的直接拿下来，而要考虑进位
	
	if (i >= 0) //i>=0则说明右边的数字小而且已经加完了 剩下左边的数了
	{
		while (i >= 0)
		{
			int ret = lhs.strDigit[i] - '0';
			//算出strDigit[i]位的值
			if (flag) //如果flag为true则表示有进位，ret要+1，进位之后要把flag置回false供下次使用
			{
				ret += 1;
				flag = false;
			}

			if (ret >= 10)//如果ret>=10则表示有进位，flag置为true，ret的值为他自己模10的余数。
			{
				ret %= 10;
				flag = true;
			}
			result.push_back(ret + '0');//把字符压入到result中
			i--;//继续往前计算
		}
	}
	else if (j >= 0) //i>=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)//如果i=j的话，直接就第一个循环执行完了，但是也要在这里判断是否有进位
	{
		result.push_back('1');
	}

	reverse(result.begin(), result.end());
	//由于把字符都是尾部压入到result中的
	//所以要在这里用reverse泛型算法对result进行逆置
	return result;   // return BigInt(result);
}

减号-运算符的重载函数

解题思路

找大的字符串做减数，小的做被减数
遍历两个字符串，减法，
设置状态位flag初始化为false表示没有借位
若有借位flag则将置为true
结果存入到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)
		//若长度相等而且字符串也一样则两个数是一样的，结果为0，直接结束程序。
		{
			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];//减法不用减字符‘0’的ascii码；
		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());
	return result;
}

测试主函数代码

int main()
{
	BigInt int1("28937697857832167849697653231243");
	BigInt int2("9785645649886874535428765");
	//BigInt int3("9785645649886874535428765");
	//28937707643477817736572188660008
	cout << int1 + int2 << endl;
	//28937688072186517962823117802478
	//28937688072186517962823117802478
	cout << int1 - int2 << endl;
	return 0;
}

运行结果

然后实验了减法的几个特殊情况如下：
减数大于被减数时：

两个数相等时：