[C++] Classes simples polinomino e monomios

[saramgsilva]

Vou apresentar outro exemplo de classes... desta vez , tem a ver com polinómios, também implemento tratamento de erros...

Começo por apresentar a classe Simpoli, polinomios simples da forma ax^n +b...(n>0) ... que inclui tratamento de erros.

Simpoli.cpp:

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

class ErroSimpoli{
  public:
     ErroSimpoli(){}
     virtual void print_erro()
    {cerr<<"Erro..Voce quer somar dois polinomios com grau diferentes!! BURRO!!!!  ehehhe\n";}
};

class Simpoli{
private:
       double coef;
       int grau;
       double ti;
public:
      Simpoli(){ coef=0; grau=0; ti=0;}
      Simpoli(double s, int r, double m){coef=s; grau=r; ti=m; }

      virtual int obtem_grau()const{return grau;}
      virtual double obtem_ti()const{return ti;}
      virtual double obtem_coef()const{return coef;}

      virtual void muda_coef(double n){coef=n;}
      virtual void muda_ti(double m){ti=m;}
      virtual void muda_grau(int n){grau=n;}

      Simpoli derivada(){
        Simpoli s;
        s.muda_ti(0);
        s.muda_coef(obtem_grau()*obtem_coef());
        s.muda_grau(obtem_grau()-1);         
        return s;
      }       

      virtual double valor(double x){

         return (double) pow(x,obtem_grau());

      }

      virtual void mult(double c){
         muda_ti(ti*c);
         muda_coef(c*coef);
      }

      virtual Simpoli soma(Simpoli o){
        Simpoli s;
        if( grau==o.obtem_grau() )
        { s.muda_coef(coef+o.obtem_coef());
          s.muda_ti(ti+o.obtem_ti()),
          s.muda_grau(grau);
         return s;
        }
        else
         throw ErroSimpoli();
      }

      virtual void escrevepoli()const{
      cout<<"O polinomio em causa... :"<<obtem_coef()<<"*x^"<<obtem_grau()<<"+"<<obtem_ti()<<endl;

      }

      virtual void pede(){
       cout<<"\nIntroduza o polinomio da forma a*x^n+b.\n Coeficiente a de a*x^n-> ";
       cin>>coef;
       cout<<"\nGrau n do polinomio-> ";
       cin>>grau;
       cout<<"\nTermo independente, ti-> ";
       cin>>ti;
       cout<<"\n";
      }
};

UsarSimpoli.cpp:

#include<iostream>
#include "Simpoli.cpp"
using namespace std;
int main(){

 try{
 Simpoli g(2,3,4);
 g.escrevepoli();

 Simpoli p,r;
 p.pede();
 p.escrevepoli();

   r=p.soma(g);
   r.escrevepoli();
 }
 catch(ErroSimpoli &e){ e.print_erro();}


int sair; cin>>sair;
return 0;

}

a classe monom é uma subclasse de simpoli, e monom representa os monómios da forma ax^n (n>0) ...isto é b=0.

Monom.cpp:

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


class Monom :public Simpoli{
 private:
 public:
        Monom():Simpoli(){}
        Monom(double a, int n):Simpoli(a,(int)fabs(n),0){}

        virtual void muda_grau(int n){ muda_grau( (int)fabs(n) );}
        virtual void muda_ti(double m){muda_ti(0);}

        Monom derivada(){
           Monom s;
           s.muda_coef(obtem_grau()*obtem_coef());
           s.muda_grau(obtem_grau()-1);         
           return s;
        } 

        virtual Monom primitiva(){  // vou considerar que o b=0.. spr!!
           Monom p;
           p.muda_grau( obtem_grau()+1 );
           p.muda_coef( obtem_coef()/(obtem_grau()+1) );
           return p;         
        } 
        virtual void mult(double c){
           muda_coef(c*obtem_coef());
      }

      virtual Monom soma(Monom o){
        Monom s;
        if( obtem_grau()==o.obtem_grau() )
        { s.muda_coef(obtem_coef()+o.obtem_coef());
          s.muda_grau(obtem_grau());
          return s;
        }
        else
         throw ErroSimpoli();
      }

      virtual void escrevepoli()const{
      cout<<"O polinomio em causa... :"<<obtem_coef()<<"*x^"<<obtem_grau()<<endl;

      }

      virtual void pede(){
       double a;
       int n;
       cout<<"\nIntroduza o polinomio da forma a*x^n.\n Coeficiente a de a*x^n-> ";
       cin>>a;
       muda_coef(a);
       cout<<"\nGrau n do polinomio-> ";
       cin>>n;
       muda_grau(n);

      }   
};

UsarMonom.cpp:

#include<iostream>
#include "Monom.cpp"

using namespace std;

int main(){

 try{
 cout<<"Vou originar um erro ...ehehe k giro...\n";
 Monom g(2,3);
 g.escrevepoli();
 Monom p(2,2);
 p.escrevepoli();
 Monom r;


   r=p.soma(g);
   r.escrevepoli();
 }
 catch(ErroSimpoli &e){ e.print_erro();}



int sair; cin>>sair;
return 0;

}

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