Rational 有理数表示（运算符操作）

#ifndef RATIONAL_H

#define RATIONAL_H

/** @file

* @brief rational和其操作符函数的完整定义

*/

/** @mainpage 有理数表示

* 合并所有的rantional的所有操作

* 该程序可以用于满足所有的运算符操作

* 源文件：@link Rational.h Rational.cpp @endlink

* @date 2013-11-10

* @author Alex Lin

* @version 1.0

*/

#include <cassert>

#include <cstdlib>

#include <istream>

#include <ostream>

#include <sstream>

/**

* @brief The Rational class

* 有理数操作

*/

class Rational

{

public:

Rational();

Rational(int num);

Rational(int num, int den);

Rational(double r);

Rational& operator = (Rational const& that);

float as_float();

double as_double();

long double as_long_double();

void assign(int num, int den);

void reduce();

friend Rational abs(Rational const & r);

friend Rational operator-(Rational const& r);

friend Rational operator+(Rational const& lhs, Rational const& rhs);

friend Rational operator-(Rational const& lhs, Rational const& rhs);

friend Rational operator*(Rational const& lhs, Rational const& rhs);

friend Rational operator/(Rational const& lhs, Rational const& rhs);

friend bool operator==(Rational const& a, Rational const& b);

friend bool operator!=(Rational const& a, Rational const& b);

friend bool operator<(Rational const& a, Rational const& b);

friend bool operator<=(Rational const& a, Rational const& b);

friend bool operator>(Rational const& a, Rational const& b);

friend bool operator>=(Rational const& a, Rational const& b);

friend std::istream& operator>>(std::istream& in, Rational& rat);

friend std::ostream& operator<<(std::ostream& out, Rational const& rat);

public:

static int gcd(int n, int m);

static int GCD( int n, int m );

static int LCM(int a, int b);

private:

int numerator;      //< 分子

int denominator;    //< 分母

};

#endif // RATIONAL_H

#include "Rational.h"

///使用欧几里德算法计算最大公约数

int Rational::gcd(int n, int m)

{

n = std::abs(n);

while ( m != 0){

int tmp(n%m);

n = m;

m = tmp;

}

return n;

}

///利用递归计算最大公约数

int Rational::GCD( int n, int m )

{

if ( n % m == 0 )

return m;

else

return GCD(m, n % m);

}

///求两个数的最小公倍数

int Rational::LCM(int a, int b)

{

int temp_lcm;

temp_lcm = a*b/GCD(a, b);//最小公倍数等于两数之积除以最大公约数

return temp_lcm;

}

Rational::Rational()

: numerator(0), denominator(1)

{/*空*/}

Rational::Rational(int num)

: numerator(num), denominator(1)

{/*空*/}

Rational::Rational(int num, int den)

: numerator(num), denominator(den)

{

reduce();

}

Rational::Rational(double r)

: numerator(static_cast<int>(r * 10000)), denominator(10000)

{

reduce();

}

Rational& Rational::operator =(Rational const& that)

{

this->numerator = that.numerator;

this->denominator = that.denominator;

return *this;

}

float Rational::as_float()

{

return static_cast<float>(numerator) / denominator;

}

double Rational::as_double()

{

return static_cast<double>(numerator) / denominator;

}

long double Rational::as_long_double()

{

return static_cast<long double>(numerator) / denominator;

}

///为分子、分母赋值并约分

void Rational::assign(int num, int den)

{

numerator = num;

denominator = den;

reduce();

}

///约分

void Rational::reduce()

{

assert(denominator!=0);

if(denominator < 0)

{

denominator = -denominator;

numerator = -numerator;

}

int div(gcd(numerator, denominator));

numerator = numerator / div;

denominator = denominator / div;

}

///有理数的绝对值

Rational abs(Rational const & r)

{

return (std::abs(r.numerator), r.denominator);

}

///将有理数取反的单目操作

Rational operator-(Rational const& r)

{

return Rational(-r.numerator, r.denominator);

}

///有理数相加

Rational operator+(Rational const& lhs, Rational const& rhs)

{

return Rational(lhs.numerator*rhs.denominator+rhs.numerator*lhs.denominator,

lhs.denominator*rhs.denominator);

}

///有理数想减

Rational operator-(Rational const& lhs, Rational const& rhs)

{

return Rational(lhs.numerator*rhs.denominator-rhs.numerator*lhs.denominator,

lhs.denominator*rhs.denominator);

}

///有理数相乘

Rational operator*(Rational const& lhs, Rational const& rhs)

{

return Rational(lhs.numerator*rhs.numerator, lhs.denominator*rhs.denominator);

}

///有理数相除

///检测除零错误

Rational operator/(Rational const& lhs, Rational const& rhs)

{

return Rational(lhs.numerator*rhs.denominator, lhs.numerator*rhs.numerator);

}

///比较两个有理数是否相等

bool operator==(Rational const& a, Rational const& b)

{

return a.numerator == b.numerator and a.denominator == b.denominator;

}

///比较两个有理数是否不等

bool operator!=(Rational const& a, Rational const& b)

{

return not (a == b);

}

///比较两个有理数是否小于关系

bool operator<(Rational const& a, Rational const& b)

{

return a.numerator*b.denominator < b.numerator*a.denominator;

}

///比较两个有理数是否是小于等于关系

bool operator<=(Rational const& a, Rational const& b)

{

return not (b < a);

}

///比较两个有理数是否是大于关系

bool operator>(Rational const& a, Rational const& b)

{

return b < a;

}

///比较两个有理数是否是大于等于关系

bool operator>=(Rational const& a, Rational const& b)

{

return not (b > a);

}

///读取有理数

///格式为@em 整数 @c / @em 整数

std::istream& operator >>(std::istream& in, Rational& rat)

{

int n(0), d(0);

char sep('\0');

if (not (in >> n >> sep))

// 读取分子或分隔符出错

in.setstate(in.failbit);

else if (sep !='/')

{

// 成功读取分子，但其后无/。

// 将读取的sep放回输入流，以备下次读取。

in.unget();

rat.assign(n, 1);

}

else if (in >> d)

// 成功读取分子、分隔符及分母

rat.assign(n, d);

else

in.setstate(in.failbit);

return in;

}

///写出有理数

///格式为@em 分子 @c / @em 分母

std::ostream& operator<<(std::ostream& out, Rational const& rat)

{

std::ostringstream tmp;

tmp << rat.numerator << '/' << rat.denominator;

out << tmp.str();

return out;

}