Elektroda.pl
Elektroda.pl
X
Proszę, dodaj wyjątek www.elektroda.pl do Adblock.
Dzięki temu, że oglądasz reklamy, wspierasz portal i użytkowników.

C++ działania na ułamkach zwykłych z uzyciem klas

AlaratH 02 Sty 2009 12:13 10385 7
  • #1 02 Sty 2009 12:13
    AlaratH
    Poziom 9  

    Witam
    Musze napisać program którego tematem jest : "Obiektowa implementacja ułamków zwykłych" Sporo zajęć nam przepadło i niestety nie wiem do końca jak się za to zabrać. Byłbym wdzięczny za jakiekolwiek wskazówki.

    Znalazłem cos ale w tym miejscu:

    Code:
    // Oblicza największy wspólny dzielnik
    
    int nwd(int a, int b) {
        if(a < 0) a = -a;
        if(b < 0) b = -b;

        while(a != b) {
            (b > a)  ? b -= a : a -= b;
        }
    }


    wywala mi błąd
    Error 1 error C4716: 'nwd' : must return a value

    1 7
  • #3 02 Sty 2009 22:47
    AlaratH
    Poziom 9  

    zmieniłem na:

    Code:
    int nwd(int a, int b) 
    
    {
        if(a < 0) a = -a;
        if(b < 0) b = -b;

        while(a != b)
       {
            (b > a)  ? b -= a : a -= b;
        }
       return a;
    }

    teraz jest taki błąd:
    Error 1 error LNK2019: unresolved external symbol _main referenced in function ___tmainCRTStartup MSVCRTD.lib

    Error 2 fatal error LNK1120: 1 unresolved externals C:\Documents and Settings\Max\Moje dokumenty\Visual Studio 2008\Projects\test\Debug\test.exe

    A tutaj dam cały kod:

    ulamki.cpp
    Code:

    #include "ulamki.h"
    #include <sstream>

    // Oblicza największy wspólny dzielnik
    int nwd(int a, int b)
    {
        if(a < 0) a = -a;
        if(b < 0) b = -b;

        while(a != b)
       {
            (b > a)  ? b -= a : a -= b;
        }
       return a;
    }


    // =============================================================================

    // Dodaje inny ułamek
    void ulamki::add(const ulamki& f) {
        numerator = numerator * f.den() + denominator * f.num();
        denominator *= f.den();

        reduce();
    }

    // Odejmuje inny ułamek
    void ulamki::substract(const ulamki& f) {
        numerator = numerator * f.den() - denominator * f.num();
        denominator *= f.den();

        reduce();
    }

    // Mnoży przez inny ułamek
    void ulamki::multiply(const ulamki& f) {
        numerator *= f.num();
        denominator *= f.den();

        reduce();
    }

    // Dzieli przez inny ułamek
    void ulamki::divide(const ulamki& f) {
        numerator *= f.den();
        denominator *= f.num();

        reduce();
    }

    // =============================================================================

    // Tworzy ułamek
    ulamki::ulamki(int num, int den, bool reduction) {
        numerator = num;
        denominator = den;

        if(reduction) {
            reduce();
        }
    }





    // Tworzy niezainicjowany ułamek
    ulamki::ulamki() {
        numerator = 0;
        denominator = 0;
    }

    // Niszczy ułamek
    ulamki::~ulamki() {
        numerator = 0;
        denominator = 0;
    }

    // -----------------------------------------------------------------------------

    // Zwraca licznik ułamka
    int ulamki::num() const {
        return numerator;
    }

    // Zwraca mianownik ułamka
    int ulamki::den() const {
        return denominator;
    }

    // Zmienia licznik ułamka
    void ulamki::num(int num) {
         numerator = num;
    }

    // Zmienia mianownik ułamka
    void ulamki::den(int den) {
        denominator = den;
    }

    // -----------------------------------------------------------------------------

    // Zwraca ułamek w postaci dziesiętnej
    float ulamki::decimal() const {
        return (float)numerator / (float)denominator;
    }

    // Zwraca ułamek w postaci łańcucha znaków
    std::string ulamki::str() const {
        std::string s;
        std::stringstream ss;

        ss << numerator << "/" << denominator;
        ss >> s;

        return s;
    }

    // -----------------------------------------------------------------------------

    // Sprawdza, czy ułamek jest właściwy
    bool ulamki::isProper() const {
        if(numerator < denominator) {
            return true;
        }
        else {
            return false;
        }
    }

    // -----------------------------------------------------------------------------

    // Skraca ułamek
    void ulamki::reduce() {
        int divisor;

        if(!denominator || !numerator) {
            return;
        }

        divisor = nwd(abs(numerator), abs(denominator));

        denominator /= divisor;
        numerator /= divisor;

        // Umieszcza znak ułamka w liczniku
        if(denominator < 0) {
            if(numerator >= 0) {
                numerator = -numerator;
                denominator = -denominator;
            }
            else {
                numerator = -numerator;
                denominator = -denominator;
            }
        }
    }



    // Suma ułamków
    ulamki ulamki::operator+(const ulamki& f) const {
        ulamki result(numerator, denominator);
        result.add(f);

        return result;
    }

    // Różnica ułamków
    ulamki ulamki::operator-(const ulamki& f) const {
        ulamki result(numerator, denominator);
        result.substract(f);

        return result;
    }

    // Iloczyn ułamków
    ulamki ulamki::operator*(const ulamki& f) const {
        ulamki result(numerator, denominator);
        result.multiply(f);

        return result;
    }

    // Iloraz ułamków
    ulamki ulamki::operator/(const ulamki& f) const {
        ulamki result(numerator, denominator);
        result.divide(f);

        return result;
    }



    // Suma ułamka i liczby
    ulamki ulamki::operator+(const int i) const {
        ulamki result(numerator + i*denominator, denominator, true);
        return result;
    }

    // Różnica ułamka i liczby
    ulamki ulamki::operator-(const int i) const {
        ulamki result(numerator - i*denominator, denominator, true);
        return result;
    }

    // Iloczyn ułamka i liczby
    ulamki ulamki::operator*(const int i) const {
        ulamki result(numerator*i, denominator, true);
        return result;
    }

    // Iloraz ułamka i liczby
    ulamki ulamki::operator/(const int i) const {
        ulamki result(numerator, denominator*i, true);
        return result;
    }


     // Dodanie innego ułamka
    ulamki& ulamki::operator+=(const ulamki& f) {
        add(f);
        return *this;
    }

    // Pomnożenie przez inny ułamek
    ulamki& ulamki::operator*=(const ulamki& f) {
        multiply(f);
        return *this;
    }

    // Podzielenie przez inny ułamek
    ulamki& ulamki::operator/=(const ulamki& f) {
        divide(f);
        return *this;
    }

    // Odjęcie innego ułamka
    ulamki& ulamki::operator-=(const ulamki& f) {
        substract(f);
        return *this;
    }



    // Dodanie liczby do ułamka
    ulamki& ulamki::operator+=(const int i) {
        numerator += i*denominator;
        reduce();
        return *this;
    }

    // Odjęcie liczby od ułamka
    ulamki& ulamki::operator-=(const int i) {
        numerator -= i*denominator;
        reduce();
        return *this;
    }

    // Pomnożenie ułamka przez liczbę
    ulamki& ulamki::operator*=(const int i) {
        numerator *= i;
        reduce();
        return *this;
    }

    // Podzielenie ułamka przez liczbę
    ulamki& ulamki::operator/=(const int i) {
        denominator *= i;
        reduce();
        return *this;
    }


    // Porównanie dwóch ułamków

    bool ulamki::operator==(const ulamki& f) const {
        // Utworzenie tymczasowych ułamków pomocniczych
        ulamki a(numerator, denominator);
        ulamki b(f.num(), f.den());

        // Skrócenie ułamków pomocniczych
        a.reduce();
        b.reduce();
        // Sprawdzenie równości licznika i mianownika ułamków pomocniczych
        if(a.num() == b.num() && a.den() == b.den()) {
            return true;
        }
        else {
            return false;
        }
    }

    bool ulamki::operator!=(const ulamki& f) const {
        // Utworzenie tymczasowych ułamków pomocniczych
        ulamki a(numerator, denominator);
        ulamki b(f.num(), f.den());

        // Skrócenie ułamków pomocniczych
        a.reduce();
        b.reduce();

        // Sprawdzenie nierówności licznika i mianownika ułamków pomocniczych
        if(a.num() != b.num() || a.den() != b.den()) {
            return true;
        }
        else {
            return false;
        }
    }

    bool ulamki::operator>(const ulamki& f) const {
        // Utworzenie tymczasowych ułamków pomocniczych
        ulamki a(numerator, denominator);
        ulamki b(f.num(), f.den());

        // Skrócenie ułamków pomocniczych
        a.reduce();
        b.reduce();

        // Sprowadzenie ułamków pomocniczych do wspólnego mianownika i porównanie
        if(a.num() * b.den() > b.num() * a.den()){
            return true;
        }
        else {
            return false;
        }
    }

    bool ulamki::operator>=(const ulamki& f) const {
        // Utworzenie tymczasowych ułamków pomocniczych
        ulamki a(numerator, denominator);
        ulamki b(f.num(), f.den());

        // Skrócenie ułamków pomocniczych
        a.reduce();
        b.reduce();

        // Sprowadzenie ułamków pomocniczych do wspólnego mianownika i porównanie
        if(a.num() * b.den() >= b.num() * a.den()){
            return true;
        }
        else {
            return false;
        }
    }

    bool ulamki::operator<(const ulamki& f) const {
        // Utworzenie tymczasowych ułamków pomocniczych
        ulamki a(numerator, denominator);
        ulamki b(f.num(), f.den());

        // Skrócenie ułamków pomocniczych
        a.reduce();
        b.reduce();

        // Sprowadzenie ułamków pomocniczych do wspólnego mianownika i porównanie
        if(a.num() * b.den() < b.num() * a.den()){
            return true;
        }
        else {
            return false;
        }
    }

    bool ulamki::operator<=(const ulamki& f) const {
        // Utworzenie tymczasowych ułamków pomocniczych
        ulamki a(numerator, denominator);
        ulamki b(f.num(), f.den());

        // Skrócenie ułamków pomocniczych
        a.reduce();
        b.reduce();

        // Sprowadzenie ułamków pomocniczych do wspólnego mianownika i porównanie
        if(a.num() * b.den() <= b.num() * a.den()){
            return true;
        }
        else {
            return false;
        }
    }


    // Porównanie ułamka i liczby

    bool ulamki::operator==(const int i) const {
        // Utworzenie tymczasowego ułamka pomocniczego
        ulamki a(numerator, denominator);

        a.reduce();

        if(a.den() == 1 && a.num() == i) {
            return true;
        }
        else {
            return false;
        }
    }

    bool ulamki::operator!=(const int i) const {
        // Utworzenie tymczasowego ułamka pomocniczego
        ulamki a(numerator, denominator);

        a.reduce();

        if(a.den() != 1 || a.den() != i) {
            return true;
        }
        else {
            return false;
        }
    }

    bool ulamki::operator>(const int i) const {
        // Utworzenie tymczasowych ułamków pomocniczych
        ulamki a(numerator, denominator);
        ulamki b(i, 1);

        // Skrócenie ułamka pomocniczego
        a.reduce();

        // Sprowadzenie ułamków pomocniczych do wspólnego mianownika i porównanie
        if(a.num() * b.den() > b.num() * a.den()){
            return true;
        }
        else {
            return false;
        }
    }

    bool ulamki::operator>=(const int i) const {
        // Utworzenie tymczasowych ułamków pomocniczych
        ulamki a(numerator, denominator);
        ulamki b(i, 1);

        // Skrócenie ułamka pomocniczego
        a.reduce();

        // Sprowadzenie ułamków pomocniczych do wspólnego mianownika i porównanie
        if(a.num() * b.den() >= b.num() * a.den()){
            return true;
        }
        else {
            return false;
        }
    }

    bool ulamki::operator<(const int i) const {
        // Utworzenie tymczasowych ułamków pomocniczych
        ulamki a(numerator, denominator);
        ulamki b(i, 1);

        // Skrócenie ułamka pomocniczego
        a.reduce();

        // Sprowadzenie ułamków pomocniczych do wspólnego mianownika i porównanie
        if(a.num() * b.den() < b.num() * a.den()){
            return true;
        }
        else {
            return false;
        }
    }

    bool ulamki::operator<=(const int i) const {
        // Utworzenie tymczasowych ułamków pomocniczych
        ulamki a(numerator, denominator);
        ulamki b(i, 1);

        // Skrócenie ułamka pomocniczego
        a.reduce();

        // Sprowadzenie ułamków pomocniczych do wspólnego mianownika i porównanie
        if(a.num() * b.den() <= b.num() * a.den()){
            return true;
        }
        else {
            return false;
        }
    }


    // Ułamek o przeciwnym znaku
    ulamki ulamki::operator-() const {
        ulamki result(numerator*-1, denominator, true);
        return result;
    }

    // Odwrotność ułamka
    ulamki ulamki::operator~() const {
        ulamki result(denominator, numerator, true);
        return result;
    }



    // Sprawdza poprawność ułamka
    bool ulamki::operator!() const {
        if(!denominator) {
            return true;
        }
        else {
            return false;
        }
    }



    ulamki.h
    Code:
    #ifndef ULAMKI_H
    
    #define ULAMKI_H

    #include <string>

    class ulamki {
        int numerator; // Licznik
        int denominator; // Mianownik

        void add(const ulamki& f); // Dodaje inny ułamek
        void substract(const ulamki& f); // Odejmuje inny ułamek
        void multiply(const ulamki& f); // Mnoży przez inny ułamek
        void divide(const ulamki& f); // Dzieli przez inny ułamek
    public:
        ulamki(int num, int den, bool reduction = false); // Tworzy ułamek
        ulamki(); // Tworzy niezainicjowany ułamek
        ~ulamki(); // Niszczy ułamek

        int num() const; // Zwraca licznik ułamka
        int den() const; // Zwraca mianownik ułamka
        void num(int num); // Zmienia licznik ułamka
        void den(int den); // Zmienia mianownik ułamka

        float decimal() const; // Zwraca ułamek w postaci dziesiętnej
        std::string str() const; // Zwraca ułamek w postaci łańcucha znaków

        bool isProper() const; // Sprawdza, czy ułamek jest właściwy

        void reduce(); // Skraca ułamek

        ulamki operator+(const ulamki& f) const; // Suma ułamków
        ulamki operator-(const ulamki& f) const; // Różnica ułamków
        ulamki operator*(const ulamki& f) const; // Iloczyn ułamków
        ulamki operator/(const ulamki& f) const; // Iloraz ułamków

        ulamki operator+(const int i) const; // Suma ułamka i liczby
        ulamki operator-(const int i) const; // Różnica ułamka i liczby
        ulamki operator*(const int i) const; // Iloczyn ułamka i liczby
        ulamki operator/(const int i) const; // Iloraz ułamka i liczby

        ulamki& operator+=(const ulamki& f); // Dodanie innego ułamka
        ulamki& operator-=(const ulamki& f); // Odjęcie innego ułamka
        ulamki& operator*=(const ulamki& f); // Pomnożenie przez inny ułamek
        ulamki& operator/=(const ulamki& f); // Podzielenie przez inny ułamek

        ulamki& operator+=(const int i); // Dodanie liczby do ułamka
        ulamki& operator-=(const int i); // Odjęcie liczby od ułamka
        ulamki& operator*=(const int i); // Pomnożenie ułamka przez liczbę
        ulamki& operator/=(const int i); // Podzielenie ułamka przez liczbę

        // Porównanie dwóch ułamków
        bool operator==(const ulamki& f) const;
        bool operator!=(const ulamki& f) const;
        bool operator>(const ulamki& f) const;
        bool operator>=(const ulamki& f) const;
        bool operator<(const ulamki& f) const;
        bool operator<=(const ulamki& f) const;

        // Porównanie ułamka i liczby
        bool operator==(const int i) const;
        bool operator!=(const int i) const;
        bool operator>(const int i) const;
        bool operator>=(const int i) const;
        bool operator<(const int i) const;
        bool operator<=(const int i) const;

        ulamki operator-() const; // Ułamek o przeciwnym znaku
        ulamki operator~() const; // Odwrotność ułamka

        bool operator!() const; // Sprawdza poprawność ułamka
    };

    #endif // ulamki_H

    Niestety tylko takie cos znalazlem do podstawowych 4 działań na ułamkach zwykłych.

    0
  • #4 03 Sty 2009 00:03
    Dr.Vee
    VIP Zasłużony dla elektroda

    Zadziwiająco dużo kodu udało Ci się napisać bez posiadania wiedzy o tym, co to jest funkcja main ;)

    Podpowiedź - masz już klase ulamki, ale nie masz głównego programu, który by korzystał z tej klasy i wykonywał operacje na ułamkach.

    Pozdrawiam,
    Dr.Vee

    0
  • #5 03 Sty 2009 08:33
    AlaratH
    Poziom 9  

    Znalazłem nie napisałem :P gdybym to sam napisał podejrzewam, ze skończyłbym ten program. Może ktoś się zlituje, znajdzie chwile czasu i pomoże dając chociaż jakąś przejrzystą jak dla prostego człowieka wskazówkę. Aczkolwiek dziękuje za powyższą podpowiedź.

    0
  • #6 03 Sty 2009 12:31
    SeLuMar
    Poziom 13  

    Na stronie z której ściągnąłeś ten kod na pewno są przykłady jak go użyć. ;)

    0
  • #7 03 Sty 2009 14:48
    AlaratH
    Poziom 9  

    Mam takie cos, moze mi ktos pomóc z przerobieniem tego tak, abym mógł wprowadzac dane jednego i drugiego ułamka ?

    Code:
    #include "ulamki.h"
    
    #include <iostream>
    using namespace std;

    int main() {
        ulamki f(1,2); // Tworzy ułamek 1/2

        ulamki g(1,3); // Tworzy ułamek 1/3

        // Suma ułamków
        cout << f.str() << " + " << g.str() << " = " << (f + g).str() << endl;

        // Różnica ułamków
        cout << f.str() << " - " << g.str() << " = " << (f - g).str() << endl;

        // Iloczyn ułamków
        cout << f.str() << " * " << g.str() << " = " << (f * g).str() << endl;

        // Iloraz ułamków
        cout << f.str() << " / " << g.str() << " = " << (f / g).str() << endl;

        cout << endl;

        // Suma ułamka i liczby
        cout << f.str() << " + " << 2 << " = " << (f + 2).str() << endl;

        // Różnica ułamka i liczby
        cout << f.str() << " - " << 2 << " = " << (f - 2).str() << endl;

        // Iloczyn ułamka i liczby
        cout << f.str() << " * " << 2 << " = " << (f * 2).str() << endl;

        // Iloraz ułamka i liczby
        cout << f.str() << " / " << 2 << " = " << (f / 2).str() << endl;
    }

    0
  • #8 14 Maj 2011 10:50
    kris3351
    Poziom 1  

    Ma ktoś program cały poprawiony który działa? pilnie potrzebuje

    0