C plus plus class of rational numbers in which multiplication and division occur?

Answer 1

The following program implements a user-defined class for rational numbers, including operator overloads for all arithmetic operations (+, -, * and /).

Note that the class does not handle 0/n fractions properly because the reciprocal of 0/n is n/0 which is an invalid fraction with undefined value. The problem is that 0/n fractions are perfectly valid (1/2 - 1/2 = 0/2) so you need to cater for them (they simplify to zero), but you cannot divide by them. It is left as an exercise for the reader to provide handlers to cater for this type of exception.

#include<iostream>

#include<string>

#include<sstream>

// GCF: greatest common factor (AKA: GCD, greatest common divisor)

int gcf (int a, int b)

{

// Recursive Euclid algorithm.

return (b != 0 ) ? gcf (b, a % b) : a;

}

// LCM: least common multiple

int lcm(int a, int b)

{

return (b / gcf (a, b)) * a;

}

// Class to store rational numbers (fractions).

class rational

{

friend std::ostream& operator<< (std::ostream&, const rational&);

private:

int m_p;

int m_q;

public:

rational (const int = 1, const int = 1);

rational (const rational&);

rational (const std::string& str);

rational (const char* c_str);

rational& operator= (const rational&);

rational& operator= (const std::string&);

rational& operator= (const char*);

rational& operator-= (const rational&);

rational& operator*= (const rational&);

rational& operator/= (const rational&);

rational& operator+= (const rational&);

rational operator- (const rational&);

rational operator* (const rational&);

rational operator/ (const rational&);

rational operator+ (const rational&);

rational reciprocal() const;

rational& simplify ();

rational& unsimplify (int multiple);

bool operator slash_pos)

{

std::string p = str.substr (0, slash_pos++);

std::string q = str.substr (slash_pos, str.size()-slash_pos);

std::stringstream ssp (p);

std::stringstream ssq (q);

int ip;

int iq;

if (ssp >> ip && ssq >> iq && iq != 0)

{

m_p = ip;

m_q = iq;

return *this;

}

}

}

return *this;

}

// Equality operator.

bool rational::operator== (const rational& other) const

{

// Simplify both fractions before comparing.

rational copy (*this);

rational temp (other);

copy.simplify();

temp.simplify();

return copy.m_p==temp.m_p && copy.m_q==temp.m_q;

}

// Return the reciprocal by value (swap numerator/denominator)

rational rational::reciprocal() const

{

return rational (m_q, m_p);

}

// Simplifies the fraction.

rational& rational::simplify()

{

// Simplify the sign.

if (m_q<0)

{

m_p *= -1;

m_q *= -1;

}

int factor = gcf (this->m_p, this->m_q);

this->m_p /= factor;

this->m_q /= factor;

return *this;

}

// Usimplifies the fraction (use given denominator)

rational& rational::unsimplify (int denominator)

{

this->m_p *= denominator / m_q;

this->m_q = denominator;

return *this;

}

// Test drive the rational class.

int main()

{

// Test arithmetic.

rational a = "1/2";

rational b (2, 5); // e.g., "2/5"

std::cout << a << " + " << b << " = " << a + b << std::endl;

std::cout << a << " - " << b << " = " << a - b << std::endl;

std::cout << a << " * " << b << " = " << a * b << std::endl;

std::cout << a << " / " << b << " = " << a / b << std::endl;

// Test simplifier on negatives and integers.

rational c (2, -5); // -2/5

rational d (-2, -5); // 2/5

rational e (3, -1); // -3

std::cout << c << " simplified is ";

std::cout << c.simplify() << std::endl;

std::cout << d << " simplified is ";

std::cout << d.simplify() << std::endl;

std::cout << e << " simplified is ";

std::cout << e.simplify() << std::endl;

}