long_number.cpp

长整数的加减乘 重载了运算符

#include "long_number.h"
#include <iostream>


using namespace std;

long_number::long_number()
{
	decimal_head=decimal_tail=integer_head=integer_tail=NULL;
	sign=1;
	decimal_long=integer_long=0;
}
//复制构造函数
long_number::long_number(const long_number &temp)
{
	decimal_head=decimal_tail=integer_head=integer_tail=NULL;
	sign=1;
	decimal_long=integer_long=0;

	number_node *p,*q;
	decimal_long=temp.decimal_long;
	integer_long=temp.integer_long;
	sign=temp.sign;

	if(temp.decimal_head)
	{
		decimal_head=new number_node;
		decimal_tail=decimal_head;
		decimal_head->high_link=decimal_tail->low_link=NULL;
		decimal_head->node=temp.decimal_head->node;

		for(p=temp.decimal_head->low_link;p!=NULL;p=p->low_link)
		{
			q=new number_node;
			q->node=p->node;
			q->low_link=NULL;
			q->high_link=decimal_tail;
			decimal_tail->low_link=q;
			decimal_tail=q;
		}
	}

	integer_head=new number_node;
	integer_tail=integer_head;
	integer_head->high_link=integer_tail->low_link=NULL;
	integer_head->node=temp.integer_head->node;

	for(p=temp.integer_head->low_link;p!=NULL;p=p->low_link)
	{
		q=new number_node;
		q->node=p->node;
		q->low_link=NULL;
		q->high_link=integer_tail;
		integer_tail->low_link=q;
		integer_tail=q;
	}
}

long_number::~long_number()
{
	decimal_long=integer_long=0;
	sign=1;
	number_node *p,*q;
	if(decimal_head)
	{
		for(q=decimal_head->low_link,p=decimal_head;q!=NULL;p=q,q=q->low_link)
			delete p;
		delete p;
		decimal_head=decimal_tail=NULL;
	}
	if(integer_head)
	{
		for(q=integer_head->low_link,p=integer_head;q!=NULL;p=q,q=q->low_link)
			delete p;
		delete p;
		integer_head=integer_tail=NULL;
	}
}
//数据标准化函数
bool long_number::number_std()
{
	number_node *p;
	if(integer_head)
	while((integer_head->node==0)&&(integer_head!=integer_tail))
	{
		p=integer_head;
		integer_head=integer_head->low_link;
		integer_head->high_link=NULL;
		integer_long--;
		delete p;
	}
	if(decimal_tail)
	while(decimal_tail->node==0)
	{
		p=decimal_tail;
		decimal_tail=decimal_tail->high_link;
		decimal_long--;
		delete p;
		if(!decimal_tail)
		{
			decimal_head=NULL;
			break;
		}
		decimal_tail->low_link=NULL;
	}
	
	if((integer_head==integer_tail)&&(integer_head->node==0)&&(decimal_head==NULL))
		sign=1;

	return true;
}
//输出的重载函数
ostream & operator << (ostream & out ,const long_number &temp)
{
	number_node *p;
	if(temp.sign==-1)
		out<<'-';
	p=temp.integer_head;
	while(p)
	{
		out<<p->node;
		p=p->low_link;
	}
	if(temp.decimal_head)
	{
		out<<'.';
		p=temp.decimal_head;
		while(p)
		{
			out<<p->node;
			p=p->low_link;
		}
	}
	return out;
}
//输入的重载函数
istream & operator >> (istream & in ,long_number &temp)
{
	number_node *p;
	char ch;
	ch=in.peek();
	temp.sign= (ch=='-') ? -1 : 1;
	if(temp.sign==-1)
	{
		in.get(ch);
		ch=in.peek();
	}
	if(ch=='.')
	{
		temp.integer_tail=temp.integer_head=new number_node;
		temp.integer_head->high_link=temp.integer_head->low_link=NULL;
		temp.integer_head->node=0;
		temp.integer_long++;
	}
	else
	{
		in.get(ch);
		do
		{
			p=new number_node;
			p->high_link=p->low_link=NULL;
			p->node=(ch-'0');
			if(temp.integer_head==NULL)
			{
				temp.integer_head=temp.integer_tail=p;
			}
			else
			{
				temp.integer_tail->low_link=p;
				p->high_link=temp.integer_tail;
				temp.integer_tail=p;
			}
			temp.integer_long++;
			if(in.peek()=='\n')
			{
				in.get(ch);
				break;
			}
			
			if(in.peek()<'0'||in.peek()>'9')
				break;
			in.get(ch);
			if(!in)
				break;
		
		}while(1);
	}
	if(ch!='\n')
		if(in.peek()=='.')
		{
			in.get(ch);
			while(1)
			{
				if(in.peek()=='\n')
				{
					in.get(ch);
					break;
				}
				
				if(in.peek()<'0'||in.peek()>'9')
					break;
				in.get(ch);
				if(!in)
					break;
				
				p=new number_node;
				p->high_link=p->low_link=NULL;
				p->node=(ch-'0');
				if(temp.decimal_head==NULL)
				{
					temp.decimal_head=temp.decimal_tail=p;
				}
				else
				{
					temp.decimal_tail->low_link=p;
					p->high_link=temp.decimal_tail;
					temp.decimal_tail=p;
				}
				temp.decimal_long++;
			};
		}

	temp.number_std();
	return in;
}

//运算符的重载
long_number& long_number::operator =(long_number &temp)
{
	decimal_long=integer_long=0;
	sign=1;
	number_node *p,*q;
	if(decimal_head)
	{
		for(q=decimal_head->low_link,p=decimal_head;q!=NULL;p=q,q=q->low_link)
			delete p;
		delete p;
		decimal_head=decimal_tail=NULL;
	}
	if(integer_head)
	{
		for(q=integer_head->low_link,p=integer_head;q!=NULL;p=q,q=q->low_link)
			delete p;
		delete p;
		integer_head=integer_tail=NULL;
	}

	decimal_long=temp.decimal_long;
	integer_long=temp.integer_long;
	sign=temp.sign;

	if(temp.decimal_head)
	{
		decimal_head=new number_node;
		decimal_tail=decimal_head;
		decimal_head->high_link=decimal_tail->low_link=NULL;
		decimal_head->node=temp.decimal_head->node;

		for(p=temp.decimal_head->low_link;p!=NULL;p=p->low_link)
		{
			q=new number_node;
			q->node=p->node;
			q->low_link=NULL;
			q->high_link=decimal_tail;
			decimal_tail->low_link=q;
			decimal_tail=q;
		}
	}

	integer_head=new number_node;
	integer_tail=integer_head;
	integer_head->high_link=integer_tail->low_link=NULL;
	integer_head->node=temp.integer_head->node;

	for(p=temp.integer_head->low_link;p!=NULL;p=p->low_link)
	{
		q=new number_node;
		q->node=p->node;
		q->low_link=NULL;
		q->high_link=integer_tail;
		integer_tail->low_link=q;
		integer_tail=q;
	}
	return *this;
}
//基本比较函数
int long_number::basic_compare(long_number &temp)
{
	number_node *p,*q;
	if(integer_long<temp.integer_long)
		return -1;
	else if(integer_long==temp.integer_long)
	{
		for(p=integer_head,q=temp.integer_head;q!=NULL;q=q->low_link,p=p->low_link)
		{
			if(p->node<q->node)
				return -1;
			else if(p->node>q->node)
				return 1;
		}

		for(p=decimal_head,q=temp.decimal_head;q!=NULL&&p!=NULL;q=q->low_link,p=p->low_link)
		{
			if(p->node<q->node)
				return -1;
			else if(p->node>q->node)
				return 1;
		}

		if(q==NULL&&p==NULL)
			return 0;
		else if(p==NULL)
			return -1;
		else 
			return 1;
	}
	else
		return 1;
}

bool long_number::operator <(long_number &temp)
{
	if(sign<temp.sign)
		return true;
	else if(sign>temp.sign)
		return false;
	else
	{
		if(sign==1)
		{
			if(basic_compare(temp)==-1)
				return true;
			else
				return false;
		}
		else
		{
			if(basic_compare(temp)==-1)
				return false;
			else
				return true;
		}
	}
}

bool long_number::operator >(long_number &temp)
{
	if(sign<temp.sign)
		return false;
	else if(sign>temp.sign)
		return true;
	else
	{
		if(sign==1)
		{
			if(basic_compare(temp)==1)
				return true;
			else
				return false;
		}
		else
		{
			if(basic_compare(temp)==1)
				return false;
			else
				return true;
		}
	}
}

bool long_number::operator ==(long_number &temp)
{
	if(sign!=temp.sign)
		return false;
	else if(basic_compare(temp)==0)
		return true;
	else
		return false;
}

bool long_number::operator <=(long_number &temp)
{
	if(!((*this)>temp))
		return true;
	else
		return false;
}

bool long_number::operator >=(long_number &temp)
{
	if(!((*this)<temp))
		return true;
	else
		return false;
}

bool long_number::operator !=(long_number &temp)
{
	if(!((*this)==temp))
		return true;
	else
		return false;
}

//基本运算函数
bool long_number::basic_operation(const long_number &temp)
{
	int tag=0,i,tn;
	number_node *p,*q;
	if(decimal_head||temp.decimal_head)
	{