整型数一般是4个字节，但是有时候经常会遇到超大数的运算，系统就没办法了（现在通常的32位系统下）

因此必须自己解决，我们来定义一个大整数类来解决 MyBigNum

代码如下：

#include <iostream>
#include <string>
#include <deque>
#include <functional>
#include <algorithm>

using namespace std;

class MyBigNum
{
	deque<int> v;
public:
	MyBigNum() {}
	MyBigNum(string strNum)
	{
		copy(strNum.begin(),strNum.end(),back_inserter(v));
		transform(v.begin(),v.end(),v.begin(),bind2nd(minus<int>(),'0'));
	}

	deque<int>::iterator begin()
	{
		return v.begin();
	}

	deque<int>::iterator end()
	{
		return v.end();
	}

	int size()
	{
		return v.size();
	}

	back_insert_iterator<deque<int> >Back_Inserter()
	{
		return back_inserter(v);
	}

	void push_front(int n)
	{
		v.push_front(n);
	}

	void push_back(int n)
	{
		v.push_back(n);
	}

	void adjust()
	{
		int nSize = v.size();

		for(int i = nSize-1;i >= 1; i --)
		{
			int value = v[i];
			if(value < 10)
				continue;
			v[i] = value%10;
			v[i-1] += value/10;
		}

		int value = v[0];
		if(value >= 10)
		{
			v[0] = value%10;
			value = value / 10;
			while(value > 0)
			{
				v.push_front(value%10);
				value /= 10;
			}
		}
		nSize = v.size();
	}

	MyBigNum Add(MyBigNum & m)
	{
		MyBigNum result;
		int n = size() - m.size();
		if(n >= 0)
		{
			transform(begin()+n,end(),m.begin(),result.Back_Inserter(),plus<int>());
			for(int i = n - 1; i >= 0 ;i --)
			{
				result.push_front(* (begin()+i));
			}
		}
		else
		{    //代码和上面一段一样很容易理解，只要注意n为负，转换过来和上面一样
			transform(begin(),end(),m.begin()-n,result.Back_Inserter(),plus<int>());
			for(int i = -n-1; i >= 0 ; i --)
			{
				result.push_front(*(m.begin()+i));
			}
		}

		result.adjust();

		return result;
	}

	MyBigNum  Multiply(MyBigNum &m)
	{
		MyBigNum result("0");
		MyBigNum mid;

		for(int i = m.size()-1 ;i >= 0; i --)
		{
			mid = *this;
			for(int j = 0 ; j < i ;j ++)
			{
				mid.push_back(0);
			}
			transform(mid.begin(),mid.end(),mid.begin(),bind2nd(multiplies<int>(),*(m.begin()+i)));
			result = mid.Add(result);  //Add函数内已经调用了调整函数
		}
		return result;
	}
};


int main()
{
	MyBigNum m1("1234567890");
	MyBigNum m2("99999999998");
	MyBigNum result = m1.Add(m2);
	cout << "1234567890 + 99999999998 = ";
	copy(result.begin(),result.end(),ostream_iterator<int>(cout));
	cout << endl;

	MyBigNum m3("99");
	MyBigNum m4("99999");
	MyBigNum m5 = m3.Multiply(m4);
	cout << "99 * 99999 = ";
	copy(m5.begin(),m5.end(),ostream_iterator<int>(cout));
	cout << endl;

	return 0;
}

三大算法：

adjust算法：

01> 获得待调整大整型数容器长度nSize

02> for  从最低位开始到次高位，循环依次调整每一位

03>               若当前位小于10，转到2

04>               当前位值等于当前值对10取余

05>               利用while循环把进位值依次加到前面位的值当中

06> end  for

07> if     最高位值大于10

08>               最高位值等于当前值对10取余

09>               改变容器大小，利用while循环把进位值依次填充新加位的值

10> endif

Add算法：

01> 定义结果大整型数变量result

02> 求被加数位数与加数位数差n

03> if  n >= 0  then

04>                 从最高位开始加数所有位与被加数所有位相加，每位结果和存入result后面

05>                 把被加数多余位存入result前面

06> else

07>                 从高位开始被加数所有位与加数所有位相应位相加，每位结果存入result后面

08>                 把加数多余位存入result前面

09> endif

10> result  <- result.adjust() ，进行位数值调整，保证result容器每位值都小于10

11> 返回result 给调用者

Multiply算法：

01> 定义结果大整型数result，初始值为0，用于累加

02> 定义临时大整型数变量mid

03> for i=0，i < 乘数位数 ， i ++

04>             mid <- 被乘数大整型数

05>             mid 尾部添加适当个数0元素

06>             mid 中每位值等于mid中每位当前值乘以乘数从低位开始的第 i 位

07>             result <- mid.Add(result)

08> end for

09> 返回result给调用者