Operacje na ułamkach C++

Question

Cześć, napisałem klasę Fraction która reprezentuje ułamek, chcę teraz dopisać operatory umożliwiające: zmianę znaku, porównywanie ułamków, rzutowanie ułamka na double. Czy mógłby ktoś pomóc? Z góry dzięki.

Oto dotychczasowy kod:

#include <iostream>
 
class Fraction {
    int licznik;
    int mianownik;
 
public:
    Fraction(int licz, int mian) {
        if (mian != 0) {
            licznik = licz;
            mianownik = mian;
            if (mianownik < 0) {
                licznik *= (-1);
                mianownik *= (-1);
            }
        } else {
            std::cout << "Mianownik nie moze byc rowny 0 !!";
            exit(0);
        }
    }
 
    Fraction(const Fraction & f1) {
        licznik = f1.licznik;
        mianownik = f1.mianownik;
    }
 
    int getLicznik() {
        return licznik;
    }
 
    int getMianownik() {
        return mianownik;
    }
 
    void setLicznik(int x) {
        licznik = x;
 
    }
 
    void setMianownik(int y) {
        if (y != 0) {
            mianownik = y;
        } else {
            std::cout << "0 nie moze byc w mianowniku!" << std::endl;
            exit(0);
        }
    }
 
    void simplify(int a, int b) {
        while (a != b)
            if (a > b) {
                a -= b;
            }
            else {
                b -= a;
            }
        licznik /= a;
        mianownik /= b;
    }
 
    void wypisz() {
        std::cout << "Podany ulamek to: " << licznik << "/" << mianownik << std::endl;
    }
 
    float toFloat() {
        float dziesietny;
        dziesietny = float(licznik) / float(mianownik);
        return dziesietny;
    }
 
    //------------------- Operatory ------------------//
    Fraction operator+(const Fraction &f2) {
        int licznik = this->licznik * f2.mianownik + f2.licznik * this->mianownik;
        int mianownik = this->mianownik * f2.mianownik;
        Fraction result(licznik, mianownik); 
        result.simplify(result.getLicznik(), result.getMianownik()); 
        return result; 
    }
 
    Fraction operator-(const Fraction &f2) {
        int licznik = this->licznik * f2.mianownik - f2.licznik * this->mianownik;
        int mianownik = this->mianownik * f2.mianownik;
        return Fraction(licznik, mianownik);
    }
 
    Fraction operator*(const Fraction &f2) {
        int licznik = this->licznik * f2.licznik;
        int mianownik = this->mianownik * f2.mianownik;
        return Fraction(licznik, mianownik);
    }
 
    Fraction operator/(const Fraction &f2) {
        int licznik = this->licznik * f2.mianownik;
        int mianownik = this->mianownik * f2.licznik;
        return Fraction(licznik, mianownik);
    }
};
 
int main() {
    Fraction f1(3, 5);
    Fraction f2(1, 4);
    Fraction f3 = f1 + f2;
    Fraction f4 = f1 * f2;
    Fraction f5 = f1 / f2;
    Fraction f6 = f1 - f2;
    f3.wypisz();  //Dodawanie
    f4.wypisz();  //Mnożenie
    f5.wypisz();  //Dzielenie
    f6.wypisz();  //Odejmowanie
    return 0;
}

 

Answer 1

hint: unikaj porownywania ulamkow dzielac licznik przez mianownik, gdyz typy double oraz float maja ograniczona dokladnosc. zamiast tego gdy masz 2 ulamki: a/b oraz c/d porownaj a*d oraz b*c.

Comments

Dziękuję za cenne rady, lecz niestety wciąż nie wiem jak to zaimplementować. Czy mógłby Pan napisać fragment kodu czy coś w tym stylu?

---

int a, b; //reprezentuje ulamek a / b
int c, d; //reprezentuje ulamek c / d

if (a * d > b * c)
	// ulamek a / d jest wiekszy niz b / c
else
	// -------||------- mniejszy niz b / c

---

Bardzo dziękuję :)