高精度运算类bign

本例选自<算法竞赛入门经典>。

#include<cstdio>
#include<iostream>

using namespace std;

class bign
{
	private:
		enum{maxn = 200};
		int len, s[maxn];
	public:
		bign();
		bign(int num);
		bign(const char * str);
		bign& operator =(int num);
		bign& operator =(const char * str);
		string str() const;
		bign operator +(const bign & b) const;
		bign operator -(const bign & b);
		bign& operator +=(const bign & b);
		bign& operator -=(const bign & b);
		void clean();
		bign operator *(const bign & b);
		bool operator <(const bign & b)  const;
		bool operator <=(const bign & b) const;
		bool operator >(const bign & b)  const;
		bool operator >=(const bign & b) const;
		bool operator ==(const bign & b) const;
		bool operator !=(const bign & b) const;
};

bign::bign()
{
	memset(s,0,sizeof(s));
	len = 0;
}

bign::bign(int num)
{
	*this = num;
}

bign::bign(const char * str)
{
	*this = str;	
}

bign& bign::operator=(int num)
{
	bign();
	char s[maxn];
	sprintf(s,"%d",num);
	*this = s;
	return *this;
}

bign& bign::operator=(const char *str)
{
	bign();
	len = strlen(str);
	for(int i = 0; i < len; ++i)
		s[i] =  str[len -i - 1] - '0';
	return *this;
}

string bign::str() const
{
	string res = "";
	for(int i = 0; i < len; ++i)
		res = (char)(s[i] + '0') + res;
	if(res == "")
		res = "0";
	return res;
}

bign bign::operator +(const bign & b) const
{
	bign c;
	for(int i = 0, g = 0; g || i < max(len,b.len); ++i )
	{
		int x = g;
		if(i < len) x += s[i];
		if(i < b.len) x += b.s[i];
		g = x / 10;
		c.s[c.len++] = x % 10;
	}
	return c;
	
}

bign bign::operator -(const bign & b)
{
	if(*this < b)
	{
		cout << "the result is nagive/n";
		return bign();
	}
	bign c;
	c.len = 0;
	for(int i = 0, g = 0; i < len; ++i)
	{
		int x = s[i] - g;
		if(i < b.len)
			x -= b.s[i];
		if(x < 0)
		{
			x += 10;
			g = 1;
		}
		else
			g = 0;	
		c.s[c.len++] = x;
	}
	c.clean();
	return c;
}

bign& bign::operator +=(const bign & b)
{
	*this = *this + b;
	return *this;	
}

bign& bign::operator -=(const bign & b)
{
	*this = *this - b;
	return *this;
}

void bign::clean()
{
	while(len > 0 && s[len - 1] == 0) --len;	
}

bign bign::operator *(const bign & b)
{
	bign c;
	c.len = len + b.len;
	for(int i = 0; i < len; ++i)
		for(int j = 0; j < b.len; ++j)
			c.s[i+j] = s[i] * b.s[j];
	for(int k = 0; k < c.len; ++k)
	{
		c.s[k+1] += c.s[k] / 10;
		c.s[k] %= 10;
	}
	c.clean();
	return c;
}

bool bign::operator <(const bign & b)  const
{
	if(len != b.len)
		return len < b.len;
	for(int i = 0; i < len; ++i)
		if(s[i] != b.s[i])
			return s[i] < b.s[i];
	return false;
}

bool bign::operator <=(const bign & b) const
{
	return !(*this > b); 
}

bool bign::operator >(const bign & b)  const
{
	if(len != b.len)
		return len > b.len;
	for(int i = 0; i < len; ++i)
		if(s[i] != b.s[i])
			return s[i] > b.s[i];
	return false;
}

bool bign::operator >=(const bign & b) const
{
	return !(*this < b);
}

bool bign::operator ==(const bign & b) const
{
	return !(b < *this) && !(*this < b);	
}

bool bign::operator !=(const bign & b) const
{
	return (b < *this) || (*this < b);
}

istream & operator >> (istream & in, bign & x)
{
	string res;
	in >> res;
	x = res.c_str();
	return in;
}

ostream & operator << (ostream & out, const bign & x)
{
	out << x.str();
	return out;
}