main.cpp(Rational클래스 라이브러리)

※main.cpp파일

#include <iostream>

#include "rational.h"



int main() {

	Rational r1(3,5);

	Rational r2(2,7);

	std::cout << r1+r2 << std::endl;

	std::cout << r1-r2 << std::endl;

	std::cout << r1*r2 << std::endl;

	std::cout << r1/r2 << std::endl;

	std::cout << r1++ << std::endl;

	std::cout << ++r1 << std::endl;

	std::cout << (r1>r2) << std::endl;

	std::cout << r1+5 << std::endl;

	std::cout << r1*100 << std::endl;

	return 0;

}

※rational.h파일

#ifndef RATIONAL_H

#define RATIONAL_H

#include <iostream>



class Rational {

friend std::ostream& operator<<(std::ostream& s,const Rational& r);

private:

	long num;

	long den;

	long gcd(long, long);

public:

	Rational(long num=0, long den=1);        //생성자

	Rational(const Rational &rhs);          // 복사생성자

	

	Rational& operator=(const Rational& rhs);  //치환연산자

	Rational& operator=(long rhs);

	long numerator() const {return num;}       //get num함수

	long denominator() const {return den;} 	 //get den함수

	

	Rational operator+() const {return *this;}   // +r1

	Rational operator-() const {return Rational(-num,den);} // -r1

	Rational invert() const {return Rational(den,num);}  // 역수

	

	const Rational& operator+=(const Rational &rhs); // +=연산

	const Rational& operator-=(const Rational &rhs); // -=연산

	const Rational& operator*=(const Rational &rhs); // *=연산

	const Rational& operator/=(const Rational &rhs); // /=연산

	

	const Rational& operator+=(long rhs);

	const Rational& operator-=(long rhs);

	const Rational& operator*=(long rhs);

	const Rational& operator/=(long rhs);

	

	const Rational& operator++();

	const Rational operator++(int);

	const Rational& operator--();

	const Rational operator--(int);

	

	const Rational operator+(const Rational& r);

	const Rational operator-(const Rational& r);

	const Rational operator*(const Rational& r);

	const Rational operator/(const Rational& r);

	

	bool operator==(const Rational& rhs);

	bool operator!=(const Rational& rhs);

	bool operator<=(const Rational& rhs);

	bool operator>=(const Rational& rhs);

	bool operator<(const Rational& rhs);

	bool operator>(const Rational& rhs);

	

};



#endif

※rational.cpp파일

#include "rational.h"

#include <iostream>



std::ostream& operator<<(std::ostream& s, const Rational& r) {

	if (r.denominator() == 1L) s<<r.numerator();

	else { 

		s<<r.numerator();

		s<<"/";

		s<<r.denominator();

	}

	return s;

}



inline Rational& Rational::operator=(long rhs) {

	num = rhs;

	den = 1;

	return *this;

}



inline double toDouble(const Rational& r) {

	return double(r.numerator())/r.denominator();

}



inline long trunc(const Rational& r) {

	return r.numerator() / r.denominator();

}



inline long floor(const Rational& r) {

	long q = r.numerator()/r.denominator();

	return (r.numerator() < 0 && r.denominator() != 1) ? --q : q;

}

inline long ceil(const Rational& r) {

	long q = r.numerator() / r.denominator();

	return (r.numerator() >=0 && r.denominator() != 1) ? ++q : q;

}



Rational::Rational(long n, long d) {

	if (d == 0L) {

		std::cerr<<"Division by Zero" << std::endl;

		exit(1);

	}

	if (d<0L) {n = -n; d = -d;}

	if (n == 0L) {

		num = 0L; den = 1L;

	} else {

		long g = gcd(n,d);

		num = n/g;

		den = d/g;

	}

}



Rational::Rational(const Rational& rhs) {

	num = rhs.num;

	den = rhs.den;

}



long Rational::gcd(long u, long v) {

	long a = labs(u), b = labs(v);

	long tmp;

	if (b>a) {

		tmp = a;

		a = b;

		b = tmp;

	}

	for (;;) {

		if (b == 0L) return a;

		else if (b == 1L) return b;

		else {

		 tmp =b; b = a%b; a = tmp;

		}

	}

}



const Rational& Rational::operator+=(const Rational& rhs) {

	long g1 = gcd(den, rhs.den);

	if (g1 == 1L) {

		num = num*rhs.den + den*rhs.num;

		den = den*rhs.den;

	} else {

		long t = num * (rhs.den/g1) + (den/g1)*rhs.num;

		long g2 = gcd(t,g1);

		num = t/g2;

		den = (den/g1) * (rhs.den/g2);

	}

	return *this;

}



const Rational& Rational::operator-=(const Rational& rhs) {

	long g1 = gcd(den, rhs.den);

	if (g1 == 1L) {

		num = num*rhs.den - den*rhs.num;

		den = den*rhs.den;

	} else {

		long t = num*(rhs.den/g1) - (den/g1) * rhs.num;

		long g2 = gcd(t,g1);

		num = t/g2;

		den = (den/g1) * (rhs.den/g2);

	}

	return *this;

}



const Rational& Rational::operator*=(const Rational& rhs) {

	long g1 = gcd(num,rhs.den);

	long g2 = gcd(den,rhs.num);

	num = (num/g1) * (rhs.num/g2);

	den = (den/g2) * (rhs.den/g1);

	return *this;

}



const Rational& Rational::operator/=(const Rational& rhs) {

	if (rhs.num == 0L) {

		std::cerr << "Division by Zero" << std::endl;

		exit(1);

	}

	long g = gcd(rhs.num,rhs.den);

	num *= rhs.den/g;

	den *= rhs.num/g;

	if (den < 0L) {

		num = -num;

		den = -den;

	}

	return *this;

}



const Rational& Rational::operator+=(long rhs) {

	num = num + den*rhs;

	return *this;

}



const Rational& Rational::operator-=(long rhs) {

	num = num - den*rhs;

	return *this;

}



const Rational& Rational::operator*=(long rhs) {

	long g = gcd(den,rhs);

	num *= rhs/g;

	den /= g;

	return *this;

}



const Rational Rational::operator+(const Rational &r){

	int num1 = num * r.den + den * r.num;

	int den1 = den * r.den;

	return Rational(num1,den1);	

}







const Rational Rational::operator-(const Rational &r){

	int num1 = num * r.den - den * r.num;

	int den1 = den * r.den;

	return Rational(num1,den1);	

}







const Rational Rational::operator*(const Rational &r) {

	int num1 = num * r.num;

	int den1 = den * r.den;

	return Rational(num1,den1);



}







const Rational Rational::operator/(const Rational &r) {

	int num1 = num * r.den;

	int den1 = den * r.num;

	return Rational(num1,den1);

}



const Rational& Rational::operator++() {

	return (*this +=1);

}



const Rational& Rational:: operator--() {

	return (*this -=1);

}



const Rational Rational::operator++(int ) {

	num /=gcd(num,den);

	den /=gcd(num,den);

	Rational result(*this);

	num += den;

	return result;

}



const Rational Rational::operator--(int ) {

	num/=gcd(num,den);

	den/=gcd(num,den);

	Rational result(*this);

	num -= den;

	return result;

}



bool Rational::operator==(const Rational& rhs) {

	return (this->num == rhs.numerator() && this->den == rhs.denominator());

}



bool Rational::operator!=(const Rational& rhs) {

	return (this->num != rhs.numerator() || this->den != rhs.denominator());

}



bool Rational::operator<(const Rational& rhs) {

	return (toDouble(*this) < toDouble(rhs));

}



bool Rational::operator>(const Rational& rhs) {

	return (toDouble(*this) > toDouble(rhs));

}



bool Rational::operator<=(const Rational& rhs) {

	return ((*this<rhs) || (*this==rhs));

}



bool Rational::operator>=(const Rational& rhs) {

	return ((*this>rhs)||(*this==rhs));

}