Wymierna.cpp

#include <iostream>
#include <stdio.h>
#include <cstdlib>
#include "wymierna.h"
#include <conio.h>
//wyjatki!!!!!
using namespace std;

    long Wymierna:: nwd(long x, long y)
    {
        if (x<0)
            x=x*-1;
        if (y<0)
            y=y*-1;
        while (x != y)
        {
             if (x > y)
             x -= y;
             else
             y -= x;
        }
         return x;
    };

    Wymierna Wymierna:: operator +(const Wymierna &praw)
    {
        if(this->mianownik*praw.mianownik> LONG_MAX || this->licznik*praw.mianownik+praw.licznik*this->mianownik>LONG_MAX )
        {
            cout<<"Zakres zmiennej zostal przekroczony";
            throw "Przekroczenie zakresu zmiennej";
        }
        return Wymierna(this->licznik*praw.mianownik+praw.licznik*this->mianownik,this->mianownik*praw.mianownik);
    };
    Wymierna Wymierna:: operator -(const Wymierna &praw)
    {
        if(this->licznik*praw.mianownik-praw.licznik*this->mianownik<LONG_MIN || this->mianownik*praw.mianownik> LONG_MAX || this->licznik*praw.mianownik-praw.licznik*this->mianownik>LONG_MAX )
        {
            cout<<"Zakres zmiennej zostal przekroczony";
            throw "Przekroczenie zakresu zmiennej";
        }
        return Wymierna(this->licznik*praw.mianownik-praw.licznik*this->mianownik,this->mianownik*praw.mianownik);
    };
    Wymierna Wymierna:: operator *(const Wymierna &praw)
    {
        if(this->licznik*praw.licznik>LONG_MAX || this->mianownik*praw.mianownik>LONG_MAX)
        {
            cout<<"Zakres zmiennej zostal przekroczony";
            throw "Przekroczenie zakresu zmiennej";
        }
        return Wymierna(this->licznik*praw.licznik,this->mianownik*praw.mianownik);
    };
    Wymierna Wymierna:: operator *(const int &praw)
    {
         if(this->licznik*praw>LONG_MAX)
        {
            cout<<"Zakres zmiennej zostal przekroczony";
            throw "Przekroczenie zakresu zmiennej";
        }
        return Wymierna(this->licznik*praw,this->mianownik);
    }
    Wymierna Wymierna:: operator /(const Wymierna &praw)
    {
        Wymierna lic =praw;
        return *this*(!lic);
    };
    Wymierna Wymierna:: operator+=(const Wymierna &praw)
    {
        if(this->mianownik*praw.mianownik> LONG_MAX || this->licznik*praw.mianownik+praw.licznik*this->mianownik>LONG_MAX )
        {
            cout<<"Zakres zmiennej zostal przekroczony";
            throw "Przekroczenie zakresu zmiennej";
        }
        *this= Wymierna(this->licznik*praw.mianownik+praw.licznik*this->mianownik,this->mianownik*praw.mianownik);
        return *this;
    };
    Wymierna Wymierna:: operator -=(const Wymierna &praw)
    {
        if(this->licznik*praw.mianownik-praw.licznik*this->mianownik<LONG_MIN || this->mianownik*praw.mianownik> LONG_MAX || this->licznik*praw.mianownik-praw.licznik*this->mianownik>LONG_MAX )
        {
            cout<<"Zakres zmiennej zostal przekroczony";
            throw "Przekroczenie zakresu zmiennej";
        }
        *this= Wymierna(this->licznik*praw.mianownik-praw.licznik*this->mianownik,this->mianownik*praw.mianownik);
        return *this;
    };
    Wymierna Wymierna:: operator *=(const Wymierna &praw)
    {
        if(this->licznik*praw.licznik>LONG_MAX || this->mianownik*praw.mianownik>LONG_MAX)
        {
            cout<<"Zakres zmiennej zostal przekroczony";
            throw "Przekroczenie zakresu zmiennej";
        }
        *this= Wymierna(this->licznik*praw.licznik,this->mianownik*praw.mianownik);
        return *this;
    };
    Wymierna Wymierna:: operator /=(const Wymierna &praw)
    {
        Wymierna lic =praw;
        *this *= !lic;
        return *this;
    };
    Wymierna Wymierna:: operator=(const Wymierna &praw)
    {
        this->licznik = praw.licznik;
        this->mianownik=praw.mianownik;
        return praw;
    };
    Wymierna Wymierna:: operator!()
    {
        return Wymierna(this->mianownik,this->licznik);
    };
//Konstruktory================================================================================
    Wymierna:: Wymierna(long licznik,long mianownik)
    {
            if (mianownik==0)
            {
                cout<<endl<<"Pojawilo sie zero w mianowniku";
                throw "zero w mianowniku";
            }
        if (mianownik<0)
        {
            licznik*=-1;
            mianownik*=-1;
        }
        if (licznik!=0)
        {
            long dzielnik = nwd(licznik,mianownik);
            this->licznik=licznik/dzielnik;
            this->mianownik=mianownik/dzielnik;
        }
        else
        {
            this->licznik=licznik;
            this->mianownik=mianownik;
        }
    }
    Wymierna:: Wymierna(){}
    Wymierna:: Wymierna(const Wymierna &wym)
    {
        this->licznik=wym.licznik;
        (*this).mianownik=wym.mianownik;
    }
//Operatory logiczne===================================================================================
    bool Wymierna:: operator==(const Wymierna &wym)
    {
        if(this->licznik==wym.licznik && wym.mianownik==this->mianownik)
            return true;
        else
            return false;
    }
    bool Wymierna:: operator!=(const Wymierna &wym)
    {
        if(wym.licznik!=this->licznik || wym.mianownik!=this->mianownik)
            return true;
        else

      return false;
    }
    bool Wymierna:: operator>(const Wymierna &wym)
    {
        if(wym.licznik*this->mianownik>this->licznik*wym.mianownik)
            return true;
        else
            return false;
    }
    bool Wymierna:: operator<(const Wymierna &wym)
    {
        if(wym.licznik*this->mianownik<this->licznik*wym.mianownik)
            return true;
        else
            return false;
    }
    bool Wymierna:: operator>=(const Wymierna &wym)
    {
        return !(*this<wym);
    }
    bool Wymierna:: operator<=(const Wymierna &wym)
    {
        return !(*this>wym);
    }
//funkcje zaprzyjaznione, porownania logiczne i strumienie
    ostream& operator<<(ostream & cout,const Wymierna &wym)
    {
        cout<<"("<<wym.licznik<<"/"<<wym.mianownik<<")";
        return cout;
    };

    istream& operator>>(istream & in,Wymierna &wym)
    {
        wym.licznik=0;
        char a;
        bool poprawna=true;
        int znak=1;
        do
        {
            cout<<"(";
            a = getch();
                if((a<48 || a>57) && a!=45)
                {
                    if(a!=13)
                    {
                        system("cls");
                        cout<<"wprowadzony znak nie byl cyfra"<<endl<<"Powtorz wprowadzanie licznika"<<endl;
                        a=13;
                        wym.licznik=0;
                        znak=1;
                        poprawna=false;
                    }
                }
                else
                {
                    if (a==45)
                    {
                        cout<<"-";
                        znak=-1;
                        poprawna=true;
                    }
                    else
                    {
                        cout<<a;
                        wym.licznik=wym.licznik*10+a-48;
                        poprawna=true;
                    }
                }
            if(poprawna)
            {
                do
                {
                    a = getch();
                    if(a<48 || a>57)
                    {
                        if(a!=13)
                        {
                            system("cls");
                            cout<<"wprowadzony znak nie byl cyfra"<<endl<<"Powtorz wprowadzanie licznika"<<endl;
                            a=13;
                            wym.licznik=0;
                            znak=1;
                            poprawna=false;
                        }
                    }
                    else
                    {
                        cout<<a;
                        wym.licznik=wym.licznik*10+a-48;
                        poprawna=true;
                    }
                }while(a!=13);
            }
        }while(!poprawna);
        wym.licznik=wym.licznik*znak;
        poprawna=true;
        wym.mianownik=0;
        do
        {
            cout<<endl<<"("<<wym.licznik<<"/";
            do
            {

                a = getch();
                if(a<48 || a>57)
                {
                    if(a!=13)
                    {
                        system("cls");
                        cout<<endl<<"wprowadzony znak nie byl cyfra"<<endl<<"Powtorz wprowadzanie mianownika";
                        a=13;
                        wym.mianownik=0;
                        poprawna=false;
                    }
                }
                else
                {
                    cout<<a;
                    wym.mianownik=wym.mianownik*10+a-48;
                    poprawna=true;
                }
            }while(a!=13);
            if(poprawna && wym.mianownik==0)
            {
                cout<<endl<<"Wartosc mianownika nie moze wynoscic ZERO"<<endl<<"Powtorz wprowadzanie mianownika";
                poprawna=false;
            }
        }while(!poprawna);
        wym=Wymierna(wym.licznik,wym.mianownik);
        return in;
};