Fraction.h

#pragma once

#include <iostream>
using namespace std;

class Fraction
{
	int numerator; // ÷èñëèòåëü
	int denominator; // çíàìåíàòåëü

public:
	Fraction();
	Fraction(int chis, int znam);

	// êîíñòðóêòîð ïðåîáðàçîâàíèÿ
	explicit Fraction(int value)
	{
		numerator = value;
		denominator = 1;
	}
	
	Fraction& operator++() // òîëüêî äëÿ ïðåôèêñà
	{
		numerator += denominator; // èçìåíÿåì «ñåáÿ»
		return *this; // âîçâðàùàåì «ñåáÿ»
	}

	Fraction operator++(int) // òîëüêî äëÿ ïîñòôèêñà
	{
		numerator += denominator;
		return *this;
	}

	double GetDecimal() const;
	void Print() const;
	void PrintDecimal() const;

	static Fraction Sum(const Fraction& left, const Fraction& right);
	
	bool GreaterThan(const Fraction& another) const;
	bool IsEquals(const Fraction& another) const;
	bool LessThan(const Fraction& another) const;

	int GetNumerator() const;
	int GetDenominator() const;
	void SetNumerator(int chis);
	void SetDenominator(int znam);

	Fraction operator + (/*Fraction* this, */ const Fraction& right);
	Fraction operator + (/*Fraction* this, */int);

	Fraction operator += (const Fraction& right);

	friend ostream& operator << (ostream&, const Fraction&);
	friend class cat;
	friend class String;
	friend class Date;
	friend class Student;
};

/////////////////////////////////////////////////////////////////////////////////////
// ïðîòîòèïû ãëîáàëüíûõ ôóíêöèé, ðåàëèçîâàííûõ â .cpp-ôàéëå Fraction.h
Fraction operator + (const Fraction&, const Fraction&);
Fraction operator + (const Fraction&, int);
Fraction operator + (int, const Fraction&);

//bool operator < (const Fraction&, const Fraction&);

//Fraction operator - (const Fraction&);

ostream& operator << (ostream&, const Fraction&);

//////////////////////////////////////////////////////
// REALIZATIONS:

// ÿâíûé êîíñòðóêòîð áåç ïàðàìåòðîâ ñ äåëåãèðîâàíèåì
Fraction::Fraction() : Fraction(0, 1)
{
	// çàñ÷¸ò äåëåãèðîâàíèÿ â òåëå ìåòîäà äåëàòü óæå íå÷åãî :)
}

// "ãëàâíûé" êîíñòðóêòîð
Fraction::Fraction(int chis, int znam)
{
	SetNumerator(chis);
	SetDenominator(znam);
}

// ïîëó÷åíèå äðîáè â äåñÿòè÷íîì ôîðìàòå
double Fraction::GetDecimal() const
{
	return (double)numerator / denominator;
}

// ðàñïå÷àòêà áåç ïåðåõîäà íà ñëåäóþùóþ ñòðîêó
void Fraction::Print() const
{
	cout << numerator << "/" << denominator << "\n";
}

// ðàñïå÷àòêà ñ ïåðåõîäîì íà ñëåäóþùóþ ñòðîêó
void Fraction::PrintDecimal() const
{
	cout << GetDecimal() << "\n";
}

// ãåòòåð ÷èñëèòåëÿ
int Fraction::GetNumerator() const
{
	return numerator;
}

// ãåòòåð çíàìåíàòåëÿ
int Fraction::GetDenominator() const
{
	return denominator;
}

// ñåòòåð ÷èñëèòåëÿ (áåç ïðîâåðîê)
void Fraction::SetNumerator(int chis)
{
	numerator = chis;
}

// ñåòòåð çíàìåíàòåëÿ (çíàìåíàòåëü íå äîëæåí áûòü ðàâåí 0!)
void Fraction::SetDenominator(int znam)
{
	denominator = znam != 0 ? znam : 1;
}

// ñðàâíåíèå äâóõ äðîáåé (ëåâàÿ äðîáü ñðàâíèâàåò ñåáÿ ñ ïðàâîé)
bool Fraction::LessThan(const Fraction& right) const
{
	return GetDecimal() < right.GetDecimal();
}

// ñðàâíåíèå äâóõ äðîáåé (ëåâàÿ äðîáü ñðàâíèâàåò ñåáÿ ñ ïðàâîé)
bool Fraction::GreaterThan(const Fraction& right) const
{
	return GetDecimal() > right.GetDecimal();
}

// ñðàâíåíèå äâóõ äðîáåé (ëåâàÿ äðîáü ñðàâíèâàåò ñåáÿ ñ ïðàâîé)
bool Fraction::IsEquals(const Fraction& right) const
{
	return GetDecimal() == right.GetDecimal();
}

// òåñòîâàÿ ãëîáàëüíàÿ ôóíêöèÿ ïðåîáðàçîâàíèÿ èíòà â äðîáü ¹1
void F1(Fraction a)
{
	cout << "explicit c-tor test global function F1\n";
}

// òåñòîâàÿ ãëîáàëüíàÿ ôóíêöèÿ ïðåîáðàçîâàíèÿ èíòà â äðîáü ¹2
Fraction F2()
{
	int a = 10;
	int b = 15;
	cout << "explicit c-tor test global function F2\n";
	return (Fraction)(a + b);
}

// ñëîæåíèå äâóõ äðîáåé (ñòàòè÷åñêèì ìåòîäîì êëàññà)
Fraction Fraction::Sum(const Fraction& left, const Fraction& right)
{
	//return left + right;
	Fraction result;
	result.SetNumerator(left.GetNumerator() * right.GetDenominator() + right.GetNumerator() * left.GetDenominator());
	result.SetDenominator(left.GetDenominator() * right.GetDenominator());
	return result;
}

bool operator < (const Fraction& left, const Fraction& right)
{
	return left.GetDecimal() < right.GetDecimal();
}

Fraction operator - (const Fraction& fraction)
{
	Fraction temp;
	temp.SetNumerator(-fraction.GetNumerator());
	temp.SetDenominator(fraction.GetDenominator());
	return temp;
}

// ïðèìåð ïåðåãðóçêè îïåðàöèè + ãëîáàëüíîé ôóíêöèåé
Fraction operator + (const Fraction& left, const Fraction& right)
{
	cout << "GLOBAL FUNCTION === FRACTION + FRACTION!\n";
	Fraction result;
	result.SetNumerator(left.GetNumerator() * right.GetDenominator() + right.GetNumerator() * left.GetDenominator());
	result.SetDenominator(left.GetDenominator() * right.GetDenominator());
	return result;
}

// ïðèìåð ïåðåãðóçêè îïåðàöèè + ìåòîäîì êëàññà
Fraction Fraction::operator + (/*Fraction* this, */ const Fraction& right)
{
	cout << "CLASS METHOD === FRACTION + FRACTION!\n";
	Fraction result;
	result.SetNumerator(this->GetNumerator() * right.GetDenominator() + right.GetNumerator() * this->GetDenominator());
	result.SetDenominator(this->GetDenominator() * right.GetDenominator());
	return result;
}

/////////////////////////////////////////////

Fraction operator + (const Fraction& left, int value)
{
	cout << "GLOBAL FUNCTION === FRACTION + INT!\n";
	Fraction result;
	result.SetNumerator(1);
	result.SetDenominator(1);
	return result;
}

Fraction Fraction::operator + (/*Fraction* this, */ int right)
{
	cout << "CLASS METHOD === FRACTION + INT!\n";
	Fraction result;
	result.SetNumerator(2);
	result.SetDenominator(1);
	return result;
}

Fraction operator + (int left, const Fraction& right)
{
	cout << "GLOBAL FUNCTION === INT + FRACTION!\n";
	Fraction result;
	result.SetNumerator(3);
	result.SetDenominator(1);
	return result;
}

Fraction Fraction::operator += (const Fraction& right)
{
	cout << "+=\n";
	numerator = numerator * right.denominator + right.numerator * denominator;
	denominator *= right.denominator;
	return *this;
}

ostream& operator << (ostream& os, const Fraction& f)
{
	os << f.numerator << '/' << f.denominator;
	return os;
}