高精度

HugeInt.h

#ifndef HUGEINT_H
#define HUGEINT_H

#include <iostream>
#include <string>
using std::ostream;
using std::string;
class HugeInt
{
	friend ostream &operator<<(ostream &, const HugeInt &);
public:
	HugeInt(long = 0); // conversion/default constructor
	HugeInt(string); // conversion constructor
	// addition operator; HugeInt + HugeInt
	HugeInt operator+(const HugeInt &) const;
	// addition operator; HugeInt + int
	HugeInt operator+(int) const;
	// addition operator;
	// HugeInt + string that represents large integer value
	HugeInt operator+(string) const;
	bool operator==(const HugeInt &) const; // equality operator
	bool operator!=(const HugeInt &) const; // inequality operator
	bool operator<(const HugeInt &) const; // less than operator
	// less than or equal to operator
	bool operator<=(const HugeInt &) const;
	bool operator>(const HugeInt &) const; // greater than operator
	// greater than or equal to operator
	bool operator>=(const HugeInt &) const;
	HugeInt operator-(const HugeInt &) const; // subtraction operator
	HugeInt operator*(const HugeInt &) const; // multiply two HugeInts
	HugeInt operator/(const HugeInt &) const; // divide two HugeInts
	int getLength() const;
private:
	int integer[40];
}; // end class HugeInt
#endif

HugeInt.cpp

#include "HugeInt.h"
#include <cstring>
#include <iostream>
#include <cmath>
using namespace std;

ostream &operator<<(ostream & out, const HugeInt & num)
{
	for (int i = num.integer[0]; i >= 1; i--)
	{
		out << num.integer[i];
	}
	return out;
}

HugeInt::HugeInt(long num)
{
	memset(integer, 0, sizeof(integer));

	if (num == 0)
	{
		integer[0] = 1;
		return;
	}
	int len = int(log10(num)) + 1;
	integer[0] = len;

	int base = 1;
	for (int i = 1; i <= len; i++)
	{
		integer[i] = (num / base) % 10;
		base *= 10;
	}
}


HugeInt::HugeInt(string str)
{
	memset(integer, 0, sizeof(integer));
	integer[0] = str.length();
	for (int i = str.length() - 1; i >= 0; i--)
	{
		integer[integer[0] - i] = str[i] - '0';
	}
}


HugeInt HugeInt::operator+(const HugeInt& num) const
{
	HugeInt res = *this;
	int len = (integer[0] > num.integer[0] ? integer[0] : num.integer[0]);

	for (int i = 1; i <= len; i++)
	{
		res.integer[i] += num.integer[i];
		res.integer[i + 1] += res.integer[i] / 10;
		res.integer[i] %= 10;
	}
	len++;

	while (res.integer[len] == 0)
		len--;
	res.integer[0] = len;
	return res;
}

HugeInt  HugeInt::operator+(int num) const
{
	long numTemp = num;
	HugeInt plus(numTemp);
	return *this + plus;
}

HugeInt HugeInt::operator+(string num) const
{
	HugeInt plus(num);
	return *this + plus;
}

bool HugeInt::operator==(const HugeInt & cmp) const
{

	if (integer[0] != cmp.integer[0])
	{
		return false;
	}

	for (int i = 1; i <= integer[0]; i++)
	{
		if (integer[i] != cmp.integer[i])
		{
			return false;
		}
	}

	return true;
}

bool HugeInt::operator!=(const HugeInt & cmp) const
{
	return *this == cmp;
}

bool HugeInt::operator<(const HugeInt & num) const
{
	if (num.integer[0] != integer[0])
	{
		return integer[0] < num.integer[0];
	}

	for (int i = integer[0]; i > 0; i--)
	{
		if (num.integer[i] != integer[i])
		{
			return integer[i] < num.integer[i];
		}
	}

	return false;
}

bool HugeInt::operator>(const HugeInt & num) const
{
	if (num.integer[0] != integer[0])
	{
		return integer[0] > num.integer[0];
	}

	for (int i = integer[0]; i > 0; i--)
	{
		if (num.integer[i] != integer[i])
		{
			return integer[i] > num.integer[i];
		}
	}

	return false;
}

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

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

int HugeInt::getLength() const
{
	return integer[0];
}

HugeInt HugeInt::operator-(const HugeInt& num) const
{
	HugeInt res = *this;
	int len = (integer[0] > num.integer[0] ? integer[0] : num.integer[0]);

	for (int i = 1; i <= len; i++)
	{
		res.integer[i] -= num.integer[i];

		if (res.integer[i] < 0)
		{
			res.integer[i] += 10;
			res.integer[i + 1]--;
		}
	}

	while (res.integer[len] == 0)
		len--;

	res.integer[0] = len;
	return res;
}

HugeInt HugeInt::operator*(const HugeInt & num) const
{
	HugeInt ans;
	ans.integer[0] = integer[0] + num.integer[0];

	for (int i = 1; i <= integer[0]; ++i)
	{
		for (int j = 1; j <= num.integer[0]; ++j)
		{
			ans.integer[i + j - 1] += integer[i] * num.integer[j];
		}
	}

	for (int i = 1; i < ans.integer[0]; ++i)
	{
		if (ans.integer[i] > 9)
		{
			ans.integer[i + 1] += ans.integer[i] / 10;
			ans.integer[i] %= 10;
		}
	}

	int len = ans.integer[0];
	while (ans.integer[len] == 0 && len > 1)
		len--;

	ans.integer[0] = len;
	return ans;
}

HugeInt HugeInt::operator/(const HugeInt & b) const
{
	HugeInt ans;
	HugeInt a = *this;

	for (int t = a.integer[0] - b.integer[0]; a >= b; t--)
	{
		HugeInt temp;
		temp.integer[0] = t + 1;
		temp.integer[t + 1] = 1;
		HugeInt c = b * temp;
		while (a >= c)
		{
			a = a - c;
			ans = ans + temp;
		}
	}
	return ans;
}