[C++] Classes fraccao e fraccao positiva

[saramgsilva]

Vou apresentar outro exemplo de classes... desta vez , tem a ver com fracções, também implemento tratamento de erros...

Começo por apresentar a classe Fraccao, que inclui tratamento de erros..

Fraccao.cpp:

#include <iostream>
#include <cmath>
using namespace std;


class Fraccao{
     private:
      int num;
      int den;

     public:
            Fraccao(){num=0; den=1;}
            Fraccao(int n, int m){ int r=mdc(n,m); num=n/r; den=m/r;}
            ~Fraccao(){}; // destrutor...

     virtual void set_num(int n){num=n;}
     virtual void set_den(int m){den=m;}

     virtual int obtem_num()const{ return num;}
     virtual int obtem_den()const{ return den;}

     virtual int mdc(int x, int y)
     {
       if(x==0 && y==0)
        return 1;

       x=(int)fabs( (double)x);
       y=(int)fabs((double)y);

       while(true) {
          if(x== 0)
            return y;
          y = y % x;
          if(y == 0)
           return x;
          x = x % y;
       }

     }

     virtual Fraccao soma(Fraccao o)
     { int n, m, r;

       n=obtem_num()*o.obtem_den()+o.obtem_num()*obtem_den();
       m=obtem_den()*o.obtem_den();

       r=mdc(n,m);
       n=n/r;
       m=m/r;
         Fraccao p(n,m);
       return p;

     }

     virtual Fraccao simetrico()
     {  Fraccao p;

       if(obtem_num()>0 && obtem_den()>0)
        { p.set_num( (-1)*obtem_num() );
          p.set_den( obtem_den() );}
       else
        if(obtem_num()<0 && obtem_den()<0)
         {p.set_num(obtem_num());
          p.set_den((-1)*obtem_den());}
        else
          if(obtem_num()<0 && obtem_den()>0)
          { p.set_num((-1)*obtem_num());
            p.set_den(obtem_den());}
          else
            if(obtem_num()>0 && obtem_den()<0)
              { p.set_num(obtem_num());
                p.set_den((-1)*obtem_den()); }
            else
          if(obtem_num()==0 )
              {p.set_num(obtem_num());
               p.set_den(obtem_den()); }

         return p;
     }



     virtual void inverso(){
     int aux;
       aux=obtem_num();
       set_num(obtem_den());
       set_den(aux);

     }

     virtual void escrevefraccao()const{
       if(num!=0 && den!=0)
         cout<<"A fraccao e' ("<<obtem_num()<<")/("<<obtem_den()<<").\n";
       else
         if(num==0 && den!=0)
          cout<<"A fraccao e' ("<<obtem_num()<<")\n";


     }

     virtual void pede(){
     cout<<"o numerador->";
     cin>>num;
     cout<<"\no denominador->";cin>>den;
     }

};// fim da class

isto vai servir para usar a classe Fraccao

UsarFraccao.cpp:

#include <iostream>
#include "Fraccao.cpp"
using namespace std;


int main(){
 Fraccao q,r,a;
 Fraccao p(-4,-2);

 cout<<"q->";
 q.escrevefraccao();   
 cout<<"p->";
 p.escrevefraccao();

 cout<<"O numerador de q passa a ser -2\n";
 q.set_num(-2);
 cout<<"q->";
 q.escrevefraccao();

 cout<<"r=p+q\n";
 r=q.soma(p);
 cout<<"r->";
 r.escrevefraccao();

 a=q.simetrico();
 cout<<"Simetrico de q\n";
 a.escrevefraccao();
 cout<<"Inverso de q\n";
 q.inverso();
 q.escrevefraccao();

 int sair; cin>>sair;
 return 0;
}

a classe PosFrac é uma subclasse da classe Fraccao, e PosFrac, representa a classe das fracções positivas...

PosFrac.cpp:

#include <iostream>
#include "Fraccao.cpp"
using namespace std;

class NegFracErro
{
public:
 NegFracErro(){};
 virtual void print_erro() const {cerr<<"Fraccao Negativa...ERRO!!!!"<<endl;}
};


class PosFrac: public Fraccao{
     private:
     public:
     PosFrac():Fraccao(){};
     PosFrac(int n, int m):Fraccao(n,m){senegativa();};

     virtual void set_num(int n){Fraccao::set_num(n); senegativa();}
     virtual void set_den(int m){Fraccao::set_den(m); senegativa();}

     virtual void pede(){ int n, m;
     Fraccao::pede();
     /*cout<<"o numerador->";
     cin>>n;
     cout<<"\no denominador->";cin>>m;
     set_num(n);
     set_den(m);*/
     senegativa();
     }

     virtual void senegativa(){
       if(obtem_num()<0 || obtem_den()<0)
         throw NegFracErro();
    }

};

UsarPosFrac.cpp:

#include <iostream>
#include "PosFrac.cpp"
using namespace std;

int main(){
  PosFrac d,c;    Fraccao t;
  try{
       d.pede();
       c.pede();
       t=d.soma(c);
       d.escrevefraccao();    c.escrevefraccao();      t.escrevefraccao();
  }
  catch(NegFracErro & E){E.print_erro();}

  cout<<"Ja terminei inserir as fraccoes....isto é so pra saber que ja passei o try-catch anterior...\n";
  // testes..eheh funciona!!
  try{  PosFrac p(-2,1);}
  catch(NegFracErro &E){E.print_erro();}

  try{  PosFrac q(-2,-1);}
  catch(NegFracErro &E){E.print_erro();}

  try{  PosFrac r(2,1);}
  catch(NegFracErro &E){E.print_erro();}

  PosFrac a;

  try{   a.set_num(-2); a.set_den(3);a.escrevefraccao();}
  catch(NegFracErro &E){E.print_erro();}
  PosFrac b;

  try{   b.set_num(2); b.set_den(3); b.escrevefraccao();}
  catch(NegFracErro &E){E.print_erro();}

int sair; cin>>sair;
return 0;
}

qualquer dúvida ou se encontrarem alguma gafe...avisem 😉