大数运算之字符串模仿

（二）加法

BigData?BigData::operator+(?BigData&?d)
{

	if?(!_IsINT64OverFlow()?&&?!d._IsINT64OverFlow()?
		&&?(_value?+?d._value)?<=?Max_INT64?&&?(_value?+?d._value)?>=?Min_INT64)
	{
		_value?+=?d._value;
	}
	else
	{
		OverflowFlag?=?true;
		_strvalue?=?Add(_strvalue,?d._strvalue);
	}
	return?*this;
}
string?Add(string&?left,?string&?right)
{
	if?(left[0]?!=?right[0])//标记不等
	{
		if?(left[0]?==?'+')
		{
			right[0]?=?'+';
			return?Sub(left,?right);
		}
		else
		{
			left[0]?=?'+';
			return?Sub(right,?left);
		}
	}
	else
	{
		int?lsize?=?left.size();
		int?rsize?=?right.size();
		if?(lsize?==?rsize)
		{
			int?carry?=?0;
			while?(--lsize?&&?--rsize)
			{
				char?tmp?=?left[lsize];
				left[lsize]?=?(left[lsize]?-?'0'?+?right[rsize]?-?'0')?%?10?+?carry?+?'0';
				carry?=?(tmp?-?'0'?+?right[rsize]?-?'0')?/?10;
			}
			if?(carry?==?1)
			{
				left.insert(1,?"1");
			}
			return?left;
		}
		else
		{
			if?(lsize?>?rsize)
			{
				int?carry?=?0;//进位
				while?(--lsize?&&?--rsize)//不能为--rsize&&-lsize
				{
					char?tmp?=?left[lsize];
					left[lsize]?=?(left[lsize]?-?'0'?+?right[rsize]?-?'0')?%?10?+?carry?+?'0';
					carry?=?(tmp?-?'0'?+?right[rsize]?-?'0')?/?10;
				}
				while?(carry?==?1)
				{
					left[lsize]?=?left[lsize]?+?carry;
					carry?=?(left[lsize]?-?'0'?+?carry)?/?10;
					lsize--;
				}
				
				return?left;
			}
			else
			{
				int?carry?=?0;
				while?(--rsize?&&?--lsize)//留意不能为--lsize&&--rsize，
					//当lsize为1时不执行--lsize直接跳出
				{
					char?tmp?=?right[rsize];
					right[rsize]?=?(left[lsize]?-?'0'?+?right[rsize]?-?'0')?%?10?
						+?'0'?+?carry;
					carry?=?(tmp?-?'0'?+?left[lsize]?-?'0')?/?10;
				}
				while?(carry?==?1)//当进位为1就一向往前加进位
				{
					right[rsize]?=?right[rsize]?+?carry;
					carry?=?(right[rsize]?-?'0'?+?carry)?/?10;
					rsize--;
				}
				return?right;
			}
			
		}
	}
}

? 加减乘除法都是用+-*/的重载来实现，实现时本身写的ADD，SUB，MUL，DIV。+挪用ADD，-挪用SUB，*挪用MUL，/挪用DIV。往后+-*/的重载函数我就不贴出来了，换个挪用函数就行。这样的话利便往后的彼此挪用，只必要修改一下标记位。由于乘法是用加法模仿的，除法行使减法模仿的，减法用加法模仿的，按理来说我们行使加法就可以实现全部的运算。可是谁人服从真的是惨不忍睹。

?在这里，ADD的算法焦点就是要生涯低位向高位的进位。和我们手算是一样的。从两个字符串的最后一位开始往前相加，直到有一个字符串碰着_strvalue[0]的字符位为止，最后还要记得把最后的进位加上。在这里要思量被加数加长进位往后尚有进位的环境，以是在这我们行使了while来轮回加。不消担忧字符串的空间不足，由于两个位数一样的数相加，最多进位为1.

（三）减法

string?Sub(string&?left,?string&?right)
{
	if?(left[0]?!=?right[0])
	{
		if?(left[0]?==?'+')
		{
			right[0]?=?'+';
			return?Add(left,?right);
		}
		else
		{
			right[0]?=?'-';
			return?Add(left,?right);
		}
	}
	else
	{
		int?lsize?=?left.size();
		int?rsize?=?right.size();
		if?(lsize?==?rsize)
		{
			int?borrow?=0;
			while?(--lsize?&&?--rsize)
			{
				
				if?(left[lsize]?<?right[rsize])
				{
					left[lsize]?=?left[lsize]?+?10?-?right[rsize]?-?borrow?+?'0';
					borrow?=?1;
				}
				else
				{
					left[lsize]?=?left[lsize]?-?right[rsize]?-?borrow?+?'0';
					borrow?=?0;
				}
			}
			return?left;
		}
		else?if?(lsize?>?rsize)
		{
			int?borrow?=?0;
			while?(--lsize?&&?--rsize)
			{
				if?(left[lsize]?<?right[rsize])
				{
					left[lsize]?=?left[lsize]?+?10?-?right[rsize]?-?borrow?+?'0';
					borrow?=?1;
				}
				else
				{
					left[lsize]?=?left[lsize]?-?right[rsize]?-?borrow?+?'0';
					borrow?=?0;
				}
			}
			while?(?borrow==1?)
			{
				if?(left[lsize]?==?'0')
				{
					left[lsize]?=?left[lsize]?-?'0'?+?10?-?borrow?+?'0';//若借位为0，
					//向更高位借位,eg:1000-10
					lsize--;
				}
				else
				{
					left[lsize]?=?left[lsize]?-?'0'?-?borrow?+?'0';
					borrow?=?0;
				}

			}
			
			return?left;
		}
		else
		{
			int?borrow?=?0;
			while?(--rsize?&&?--lsize)
				//得先让rsize--，若--lsize为0；将不会执行--rsize;
			{
				if?(right[rsize]?<?left[lsize])
				{
					right[rsize]?=?right[rsize]?+?10?-?left[lsize]?-?borrow?+?'0';
					borrow?=?1;
				}
				else
				{
					right[rsize]?=?right[rsize]?-?left[lsize]?-?borrow?+?'0';
					borrow?=?0;
				}
			}
			while?(borrow?==?1)
			{
				if?(right[rsize]?==?'0')
				{
					right[rsize]?=?right[rsize]?-?'0'?+?10?-?borrow?+?'0';//若借位为0，
					//向更高位借位,eg:1000-10
					rsize--;
				}
				else
				{
					right[rsize]?=?right[rsize]?-?'0'?-?borrow?+?'0';
					borrow?=?0;
				}

			}
			return?right;
		}
	}
}

? 减法的算法焦点和加法差不多，每次从两个字符串的最后一位开始计较。要界说一个借位，低位向高位的借位。只要借位borrow为1就一向轮回借位。

加法和减法之间可以彼此挪用，当一个正数加一个负数时就可以挪用减法，会很利便，并且易懂。这里就浮现了我们封装ADD,SUB,MUL,DIV的甜头。

?尚有要留意的就是要用最大的字符串（最长的字符串)来减小的字符串。这样可以担保功效用最长的字符串就可以生涯，不消思量空间的题目。

（编辑：湖南网）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!