#include <iostream>

using namespace std;

class Wymierna
{
    friend ostream& operator<<(ostream&, const Wymierna&);      // nagłówek zaprzyjaźnienia funkcji
    friend Wymierna operator+(const Wymierna& A, const Wymierna& B);
    friend Wymierna operator-(const Wymierna& A, const Wymierna& B);
    friend Wymierna operator*(const Wymierna& A, const Wymierna& B);
    friend Wymierna operator/(const Wymierna& A, const Wymierna& B);
private:
    int licznik;
    int mianownik;
    void skroc();
public:
    Wymierna();
    Wymierna(int a, int b);
    Wymierna(int calkowita);
    Wymierna(double ulamek);
    double wartosc() const;
    void print() const;
    int get_licznik() const { return licznik; }
    int get_mianownik() const { return mianownik; }
};

int nwd(int a, int b)
{
    if (a * b == 0)
        return 1;
    if (a < 0)
        a = -a;
    if (b < 0)
        b = -b;
    while (a != b)
    {
        if (a > b)
            a -= b;
        if (b > a)
            b -= a;
    }
    return a;
}

Wymierna::Wymierna(int a, int b) : licznik(a), mianownik(b) { skroc(); }

Wymierna::Wymierna(int calkowita) : Wymierna(calkowita, 1) {}

Wymierna::Wymierna() : Wymierna(0) {}

Wymierna::Wymierna(double ulamek)
{
    double l = ulamek;
    mianownik = 1;
    while (1.0 * static_cast<int>(l) / mianownik != ulamek)
    {
        l *= 10;
        mianownik *= 10;
    }
    licznik = static_cast<int>(l);
    skroc();
}

double Wymierna::wartosc() const
{
    return 1.0 * licznik / mianownik;
}

void Wymierna::print() const
{
    if (mianownik == 1)
        cout << licznik << endl;
    else
        cout << licznik << "/" << mianownik << endl;
}

ostream& operator<<(ostream& os, const Wymierna& liczba)
{
    if (liczba.mianownik == 1)
        os << liczba.licznik;
    else
        os << liczba.licznik << '/' << liczba.mianownik;
    return os;
}

Wymierna operator+(const Wymierna& A, const Wymierna& B)
{
    Wymierna wynik;
    wynik.licznik = A.licznik * B.mianownik + B.licznik * A.mianownik;
    wynik.mianownik = A.mianownik * B.mianownik;

    wynik.skroc();

    return wynik;
}

Wymierna operator*(const Wymierna& A, const Wymierna& B)
{
    Wymierna wynik;
    wynik.licznik = A.licznik * B.licznik;
    wynik.mianownik = A.mianownik * B.mianownik;
    wynik.skroc();
    return wynik;

}

Wymierna operator-(const Wymierna& A, const Wymierna& B)
{
    Wymierna wynik;
    wynik.licznik = A.licznik * B.mianownik - B.licznik * A.mianownik;
    wynik.mianownik = A.mianownik * B.mianownik;
    wynik.skroc();

    return wynik;
}

Wymierna operator/(const Wymierna& A, const Wymierna& B)
{
    Wymierna wynik;
    wynik.licznik = A.licznik * B.mianownik;
    wynik.mianownik = A.mianownik * B.licznik;
    wynik.skroc();

    return wynik;
}



void Wymierna::skroc()
{
    int dzielnik = nwd(licznik, mianownik);
    licznik /= dzielnik;
    mianownik /= dzielnik;
    if (mianownik < 0)
    {
        licznik = -licznik;
        mianownik = -mianownik;
    }
}




int main()
{
    const Wymierna ulamek(8, 4);
    Wymierna B(1, -3);
    cout << ulamek << endl;
    cout << B << endl;

    cout << ulamek << " + " << B << " = " << ulamek + B << endl;

    Wymierna C{ ulamek + B };       // nowszy sposób inicjalizacji obiektu

    cout << 7.3 + C << endl;
    cout << ulamek - B << endl;
    cout << ulamek * B << endl;
    cout << ulamek / B << endl;

    cout << 1.5 > C << endl;
    cout << ulamek += 2.4 << endl;
    cout << 2.5 == ulamek << endl;



    return 0;
}