Fraction.h

Go to the documentation of this file.

#ifndef FRACTION_H
        #define FRACTION_H

        #include "PartialLib.h"

        #if !defined(FRACTION_ONLY) || !defined(MFRACTION_ONLY)

                #include <iostream>             
                #include "FracError.h"
                using namespace std;

                class Fraction
                {
                        #ifndef MFRACTION_ONLY

                                public:                         

                                        enum FracFormat
                                        {
                                                IM_FRAC = 0,  
                                                DECI = 1      
                                        };                              
                
                                private:


                                        static FracFormat FORMAT;

                                public:

                                        //static functions to set and get the %Fraction format
                                        //static functions cant access non-static variables             

                                        static void setFormat(const FracFormat &format);
                                
                                        static FracFormat getFormat();

                        #endif /* #ifndef MFRACTION_ONLY */

                        protected:
                                /* THE DATA MEMBERS: */
                                //protected allows only %Fraction class and classes tht inherites from %Fraction class access

                                bool sign;                       
                                unsigned int numerator;          
                                unsigned int denominator;        

                        private:
                                /* HELPER METHODS PRIVATE TO CLASS */                                   

                                unsigned int getGCD() const;
                                
                                void reduce();      

                        public:



                                Fraction();

                                Fraction(const double &number);
                                
                                Fraction(const int &numerator, const int &denominator);
                                
                                #ifndef MFRACTION_ONLY
                                
                                        Fraction(const char *frac);

                                #endif /* #ifndef MFRACTION_ONLY */

                                Fraction(const Fraction &frac);
                                

                                ~Fraction();




                                void setNum(int numerator);


                                void setDen(int denominator);

                                


                                int operator [] (const unsigned int &subscript) const;


                                Fraction &operator = (const Fraction& right);                                   
                                                
                                #ifndef MFRACTION_ONLY

                                        Fraction operator - () const;

                                        Fraction operator ++ ();
                                        
                                        Fraction operator -- ();
                                        
                                        Fraction operator ++ (int inc);

                                        Fraction operator -- (int dec);


                                        Fraction operator += (const Fraction &right);
                                        
                                        Fraction operator -= (const Fraction &right);

                                        Fraction operator *= (const Fraction &right);

                                        Fraction operator /= (const Fraction &right);

                                #endif /* #ifndef MFRACTION_ONLY */


                                #ifndef MFRACTION_ONLY

                                        /* FRIENDS: OVERLOADED OPERATORS */



                                        friend bool operator == (const Fraction &left, const Fraction &right);
                                        

                                        friend bool operator != (const Fraction &left, const Fraction &right);
                                

                                        friend bool operator < (const Fraction &left, const Fraction &right);
                                        
                                        friend bool operator <= (const Fraction &left, const Fraction &right);
                                        
                                        friend bool operator > (const Fraction &left, const Fraction &right);

                                        friend bool operator >= (const Fraction &left, const Fraction &right);



                                        friend Fraction operator + (const Fraction &left, const Fraction &right);
                                        
                                        friend Fraction operator - (const Fraction &left, const Fraction &right);
                                        
                                        friend Fraction operator * (const Fraction &left, const Fraction &right);
                                        
                                        friend Fraction operator / (const Fraction &left, const Fraction &right);



                                        friend ostream &operator << (ostream &out, const Fraction &fraction);
                                        
                                        friend istream &operator >> (istream &in, Fraction &fraction);


                                #endif /* #ifndef MFRACTION_ONLY */
                };
        #endif /* #if !defined(FRACTION_ONLY) || !defined(MFRACTION_ONLY) */
#endif /* #ifndef FRACTION_H */