Bigfloat I: Natural Number, UBINT

Team Projects

Bigfloat I: Natural Number, UBINT

Milkskin 2009. 3. 5. 12:48

안녕하십니까 Mr. K입니다

지난주에 올린 UBINT는 알고리즘상의 문제가 있어서 수정하였습니다

[헤더]

#ifndef UBINT_H
#define UBINT_H

#include <iostream>
using std::ostream;
using std::istream;

#include <string>
using std::string;

// ubint: Unsigned Big INTeger
class ubint
{
protected:
	string num;
public:
	ubint();
	ubint( ubint& ub );
	ubint operator =( ubint ub2 );

ubint( string number );
	ubint operator =( string n2 );

ubint( int number );
	ubint operator =( int n2 );

string getnum();
	void setnum( string str );

string add( string n2 ); // main heritage 1
	ubint operator +( ubint ub2 );

string multiply( string n2 ); // main heritage 2
	ubint operator *( ubint ub2 );

ubint operator +=( ubint ub2 );
	ubint operator *=( ubint ub2 );

ubint operator ++();
	ubint operator ++( int dummy );

friend ostream& operator <<( ostream& os, ubint ub );
	friend istream& operator >>( istream& is, ubint& ub );

bool operator <( ubint ub2 );
	bool operator >( ubint ub2 );

bool operator !=( ubint ub2 );
	bool operator ==( ubint ub2 );
	bool operator <=( ubint ub2 );
	bool operator >=( ubint ub2 );

// ubint-?-string
	ubint operator +( string n2 );
	ubint operator +=( string n2 );
	ubint operator *( string n2 );
	ubint operator *=( string n2 );
	bool operator <( string n2 );
	bool operator >( string n2 );
	bool operator !=( string n2 );
	bool operator ==( string n2 );
	bool operator <=( string n2 );
	bool operator >=( string n2 );

// ubint-?-int
	ubint operator +( int n2 );
	ubint operator +=( int n2 );
	ubint operator *( int n2 );
	ubint operator *=( int n2 );
	bool operator <( int n2 );
	bool operator >( int n2 );
	bool operator !=( int n2 );
	bool operator ==( int n2 );
	bool operator <=( int n2 );
	bool operator >=( int n2 );

// string-?-ubint
	friend ubint operator +( string n1, ubint ub2 );
	friend ubint operator *( string n1, ubint ub2 );
	friend bool operator <( string n1, ubint ub2 );
	friend bool operator >( string n1, ubint ub2 );
	friend bool operator !=( string n1, ubint ub2 );
	friend bool operator ==( string n1, ubint ub2 );
	friend bool operator <=( string n1, ubint ub2 );
	friend bool operator >=( string n1, ubint ub2 );

// int-?-ubint
	friend ubint operator +( int n1, ubint ub2 );
	friend ubint operator *( int n1, ubint ub2 );
	friend bool operator <( int n1, ubint ub2 );
	friend bool operator >( int n1, ubint ub2 );
	friend bool operator !=( int n1, ubint ub2 );
	friend bool operator ==( int n1, ubint ub2 );
	friend bool operator <=( int n1, ubint ub2 );
	friend bool operator >=( int n1, ubint ub2 );
};

#endif

[구현cpp]

#include "ubint.h"

// default constructor
ubint::ubint()
{
	num = '0';
}

// copy constructor
ubint::ubint( ubint& ub )
{
	num = ub.num;
}

// overloading: ubint = ubint
ubint ubint::operator =( ubint ub2 )
{
	num = ub2.num;

return ub2;
}

/******************************************************************************/

// constructor: string
ubint::ubint( string number )
{
	num = number;
}

// overloading: ubint = string
ubint ubint::operator =( string n2 )
{
	ubint temp(n2);

num = temp.num;

return temp;
}

/******************************************************************************/

// constructor: int
ubint::ubint( int number )
{
	string temp = string(12, '0');
	int i, s = 11;

if( number < 0 ) number = -number;

while( number > 0 )
	{
		temp[s] = number % 10 + '0';
		number /= 10;
		s--;
	}

s = temp.size();

for( i = 0; i < s; i++ )
	{
		if( temp[i] != '0' ) break;
	}

if( i < s ) num = temp.substr(i, s-i);
	else num = '0';
}

// overloading: ubint = int
ubint ubint::operator =( int n2 )
{
	ubint temp(n2);

num = temp.num;

return temp;
}

/******************************************************************************/

// additional operation for bint
string ubint::getnum()
{
	return num;
}

// additional operation for bint
void ubint::setnum( string str )
{
	num = str;
}

/******************************************************************************/

// addition of two strings; main heritage 1
string ubint::add( string n2 )
{
	string t1, t2;
	int s1, s2;

t1 = num;
	t2 = n2;
	s1 = t1.size();
	s2 = t2.size();

if( s1 > s2 ) t2 = string(s1-s2, '0') + n2;
	else if( s1 < s2 ) t1 = string(s2-s1, '0') + num;

int i, s, carry = 0;
	string res;

s = t1.size();
	res = string(s, '0');

for( i = s-1; i >= 0; i-- )
	{
		res[i] = t1[i] + t2[i] - '0' + carry;
		
		if( res[i] > '9' )
		{
			carry = 1;
			res[i] -= 10;
		}
		else carry = 0;
	}

if( carry ) res = '1' + res;

return res;
}

// overloading: ubint + ubint
ubint ubint::operator +( ubint ub2 )
{
	ubint res;

res.num = this->add(ub2.num);

return res;
}

/******************************************************************************/

// multiplication of two strings; main heritage 2
string ubint::multiply( string n2 )
{
	int s1, s2;
	string res;

s1 = num.size();
	s2 = n2.size();
	res = string(s1+s2, 0);

int i, j, s, carry = 0;

for( i = s2-1; i >= 0; i-- )
	{
		for( j = s1-1; j >= 0; j-- )
		{
			res[i+j+1] += (num[j] - '0') * (n2[i] - '0') + carry;

if( res[i+j+1] > 9 )
			{
				carry = res[i+j+1] / 10;
				res[i+j+1] %= 10;
			}
			else carry = 0;
		}

res[i+j+1] = carry;
		carry = 0;
	}

s = res.size();

for( i = 0; i < s; i++ )
	{
		res[i] += '0';
	}

for( i = 0; i < s; i++ )
	{
		if( res[i] != '0' ) break;
	}

if( i < s ) res = res.substr(i, s-i);
	else res = '0';

return res;
}

// overloading: ubint * ubint
ubint ubint::operator *( ubint ub2 )
{
	ubint res;

res.num = this->multiply(ub2.num);

return res;
}

/******************************************************************************/

// overloading: ubint += ubint
ubint ubint::operator +=( ubint ub2 )
{
	*this = *this + ub2;

return *this;
}

// overloading: ubint *= ubint
ubint ubint::operator *=( ubint ub2 )
{
	*this = *this * ub2;

return *this;
}

/******************************************************************************/

// overloading: ++ubint
ubint ubint::operator ++()
{
	ubint temp("1");

*this += temp;

return *this;
}

// overloading: ubint++
ubint ubint::operator ++( int dummy )
{
	ubint temp("1");
	ubint old = *this;

*this += temp;

return old;
}

/******************************************************************************/

// overloading: ostream
ostream& operator <<( ostream& os, ubint ub )
{
	os << ub.num;

return os;
}

// overloading: istream
istream& operator >>( istream& is, ubint& ub )
{
	is >> ub.num;

return is;
}

/******************************************************************************/

// overloading: ubint < ubint
bool ubint::operator <( ubint ub2 )
{
	int s1, s2;

s1 = num.size();
	s2 = ub2.num.size();

if( s1 < s2 ) return true;
	else if( s1 > s2 ) return false;
	else
	{
		int i, s = s1;

for( i = 0; i < s; i++ )
		{
			if( num[i] != ub2.num[i] ) break;
		}

if( num[i] < ub2.num[i] ) return true;
		else return false;
	}
}

// overloading: ubint > ubint
bool ubint::operator >( ubint ub2 )
{
	int s1, s2;

s1 = num.size();
	s2 = ub2.num.size();

if( s1 > s2 ) return true;
	else if( s1 < s2 ) return false;
	else
	{
		int i, s = s1;

for( i = 0; i < s; i++ )
		{
			if( num[i] != ub2.num[i] ) break;
		}

if( num[i] > ub2.num[i] ) return true;
		else return false;
	}
}

/******************************************************************************/

// overloading: ubint == ubint
bool ubint::operator !=( ubint ub2 )
{
	return (*this < ub2) || (*this > ub2);
}

// overloading: ubint != ubint
bool ubint::operator ==( ubint ub2 )
{
	return !(*this != ub2);
}

// overloading: ubint < ubint
bool ubint::operator <=( ubint ub2 )
{
	return !(*this > ub2);
}

// overloading: ubint > ubint
bool ubint::operator >=( ubint ub2 )
{
	return !(*this < ub2);
}

/******************************************************************************/

// overloading: ubint + string
ubint ubint::operator +( string n2 )
{
	ubint temp(n2);

return (*this + temp);
}

// overloading: ubint += string
ubint ubint::operator +=( string n2 )
{
	ubint temp(n2);

return (*this += temp);
}

// overloading: ubint * string
ubint ubint::operator *( string n2 )
{
	ubint temp(n2);

return (*this * temp);
}

// overloading: ubint *= string
ubint ubint::operator *=( string n2 )
{
	ubint temp(n2);

return (*this *= temp);
}

// overloading: ubint < string
bool ubint::operator <( string n2 )
{
	ubint temp(n2);

return (*this < temp);
}

// overloading: ubint > string
bool ubint::operator >( string n2 )
{
	ubint temp(n2);

return (*this > temp);
}

// overloading: ubint != string
bool ubint::operator !=( string n2 )
{
	ubint temp(n2);

return (*this != temp);
}

// overloading: ubint == string
bool ubint::operator ==( string n2 )
{
	ubint temp(n2);

return (*this == temp);
}

// overloading: ubint <= string
bool ubint::operator <=( string n2 )
{
	ubint temp(n2);

return (*this <= temp);
}

// overloading: ubint >= string
bool ubint::operator >=( string n2 )
{
	ubint temp(n2);

return (*this >= temp);
}

/******************************************************************************/

// overloading: ubint + int
ubint ubint::operator +( int n2 )
{
	ubint temp(n2);

return (*this + temp);
}

// overloading: ubint += int
ubint ubint::operator +=( int n2 )
{
	ubint temp(n2);

return (*this += temp);
}

// overloading: ubint * int
ubint ubint::operator *( int n2 )
{
	ubint temp(n2);

return (*this * temp);
}

// overloading: ubint *= int
ubint ubint::operator *=( int n2 )
{
	ubint temp(n2);

return (*this *= temp);
}

// overloading: ubint < int
bool ubint::operator <( int n2 )
{
	ubint temp(n2);

return (*this < temp);
}

// overloading: ubint > int
bool ubint::operator >( int n2 )
{
	ubint temp(n2);

return (*this > temp);
}

// overloading: ubint != int
bool ubint::operator !=( int n2 )
{
	ubint temp(n2);

return (*this != temp);
}

// overloading: ubint == int
bool ubint::operator ==( int n2 )
{
	ubint temp(n2);

return (*this == temp);
}

// overloading: ubint <= int
bool ubint::operator <=( int n2 )
{
	ubint temp(n2);

return (*this <= temp);
}

// overloading: ubint >= int
bool ubint::operator >=( int n2 )
{
	ubint temp(n2);

return (*this >= temp);
}

/******************************************************************************/

// overloading with friend: string + ubint
ubint operator +( string n1, ubint ub2 ) { return (ub2 + n1); }
ubint operator *( string n1, ubint ub2 ) { return (ub2 * n1); }
bool operator <( string n1, ubint ub2 ) { return (ub2 > n1); }
bool operator >( string n1, ubint ub2 ) { return (ub2 < n1); }
bool operator !=( string n1, ubint ub2 ) { return (ub2 != n1); }
bool operator ==( string n1, ubint ub2 ) { return (ub2 == n1); }
bool operator <=( string n1, ubint ub2 ) { return (ub2 >= n1); }
bool operator >=( string n1, ubint ub2 ) { return (ub2 <= n1); }

/******************************************************************************/

// overloading with friend: int + ubint
ubint operator +( int n1, ubint ub2 ) { return (ub2 + n1); }
ubint operator *( int n1, ubint ub2 ) { return (ub2 * n1); }
bool operator <( int n1, ubint ub2 ) { return (ub2 > n1); }
bool operator >( int n1, ubint ub2 ) { return (ub2 < n1); }
bool operator !=( int n1, ubint ub2 ) { return (ub2 != n1); }
bool operator ==( int n1, ubint ub2 ) { return (ub2 == n1); }
bool operator <=( int n1, ubint ub2 ) { return (ub2 >= n1); }
bool operator >=( int n1, ubint ub2 ) { return (ub2 <= n1); }

참 쉽죠?

덧셈구현 바로 위에는

bint를 구현하다가 필요해진 get함수와 set함수를 추가했습니다