Bonsoir à tous , 

Je suis en train de réaliser la classe ZFraction , cependant il me reste un problème de réduction de fraction.

Lorsque je compile , il n'y a plus d'erreur mais plus rien ne s'affiche en exécution, merci de bien vouloir m'aider , je mets le code ci dessous:

/* le .h*/



#ifndef ZFRACTION_H_INCLUDED
#define ZFRACTION_H_INCLUDED





class ZFraction
{

public :

   ZFraction() ; //constructeur par defaut

   ZFraction(int  n); //constructeur numerateur

   ZFraction(int  n, int d); // constructeur avec des attributs ;

   ZFraction& operator+=(ZFraction const& b); /*utile pour la surchage de l'operateur +*/
   void fraction(std::ostream &aff) const; /*affichage du signe fractionnaire*/
    int getNum() const;
    int getDenum() const;
    int pgcd( int  a , int b) ;
    ZFraction redui( ZFraction const& a);
    void setNum( int  numerateur);
    void setDenum(int denomin);
    bool estSup(ZFraction const& b) const; //on utilise àla place des accesseurs deja écris
    bool estEgal(ZFraction const& b) const;




private :

int c_num   ;  //numerateur de la fraction
int c_denum ; // denominateur de la fraction

};

ZFraction operator+(ZFraction const& a, ZFraction const& b);
std::ostream& operator<<(std::ostream& f , ZFraction const& b);
ZFraction operator*(ZFraction const&a , ZFraction const&b);
 bool operator>(ZFraction const& a,ZFraction const& b);
  bool operator==(ZFraction const& a, ZFraction const& b);

#endif // ZFRACTION_H_INCLUDED

/*le .cpp*/


#include<iostream> // ne jamais oublier
#include "ZFraction.h"

using namespace std;

ZFraction::ZFraction():c_num(0),c_denum(0){}

ZFraction::ZFraction(int  n):c_num(n),c_denum(1){}

ZFraction::ZFraction(int  n, int d):c_num(n),c_denum(d){}

ZFraction& ZFraction::operator+=(const ZFraction &frac){ /*méthode de classe*/

c_num+=frac.c_num;

c_denum+=frac.c_denum;

return *this;

}

int ZFraction::pgcd(int a , int  b){
do {
    if(a>b)a=a-b;
    else if(b>a)b=a-b;
    else return a;
}while(a!=b);
}


ZFraction ZFraction::redui(ZFraction const& a){
    int resultat=pgcd(a.c_num,a.c_denum);
    int numerateur_reduit=a.c_num/resultat;
    int denominateur_reduit=a.c_denum/resultat;
    ZFraction  nval(numerateur_reduit,denominateur_reduit);
    return  nval;


}

ZFraction operator+(ZFraction const& a, ZFraction const& b){

ZFraction val(a); //copie de la valeur de a dans une variable car on ne peut pas modifier sa valeur

val+=b; // addition avec operateur raccourcis

//cout << val.c_num <<"/"<<val.c_denum << endl;

return val;

}

/*surcharge de la fonction d'affichage */
void ZFraction::fraction(std::ostream &out) const
{
    out << c_num <<"/" <<c_denum;
}

std::ostream& operator<<(std::ostream& f, ZFraction const& b){

b.fraction(f);

return f;
}


/*accesseurs*/

int ZFraction::getNum() const{

return c_num;

}

int ZFraction::getDenum() const{
return c_denum;
}

void ZFraction::setNum(int numerateur){

c_num = numerateur; // modification de la val du num

}
void ZFraction::setDenum(int denomin){

c_denum = denomin; //modification de la valeur du denominateur
}


ZFraction operator*(ZFraction const& a , ZFraction const&b){

ZFraction j,g;

j.setNum(a.getNum()*b.getNum()); // utilisation des accesseurs car les attributs sont privés
j.setDenum(a.getDenum()*b.getDenum()); // calcul de multiplication terme à terme

/* calcul du pgcd*/
g.redui(j); // erreur comise ,lorsqu'une méthode est appelée , mettre un . au lieu du =

/* retourne le résultat*/
return g;

}

bool ZFraction::estSup(ZFraction const& b) const{

if ((c_num>b.c_num)&&(c_denum>b.c_denum)) return true;

else return false;


}
bool ZFraction::estEgal(ZFraction const& b) const{ /* quand on utilise des objets de la classe dans les méthodes , si on ne déclare pas la méthode const
    , on ne pourra pas utiliserla méthodes sur des objets de la classe ! */
 if((c_num==b.c_num)&&(c_denum==b.c_denum))return true;

 else return false;
}

bool operator>(ZFraction const& a , ZFraction const& b){

    return a.estSup(b);

}

bool operator==(ZFraction const& a , ZFraction const& b){

return a.estEgal(b);

}

/* le main*/

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

int main()
{

    ZFraction a(4,5);      //Déclare une fraction valant 4/5
    ZFraction b(2);        //Déclare une fraction valant 2/1 (ce qui vaut 2)
    ZFraction c,d;         //Déclare deux fractions valant 0

    c = a+b;               //Calcule 4/5 + 2/1 = 14/5
    d = a*b;

  c.fraction(cout);
  cout << " " << endl;
  d.fraction(cout);

  cout << " " << endl;

    if(a > b)
        cout << "a est plus grand que b." << endl;
    else if(a==b)
        cout << "a est egal a b." << endl;
    else
        cout << "a est plus petit que b." << endl;

    return 0;
}

Bonjour,

Ton pgcd va boucler indéfiniment, relis bien ta ligne 28.
Attention, ta connaissance des mathématiques est à revoir.
- Pour ajouter 2 fractions, il ne faut pas ajouter dénominateur et numérateur entre-eux.
- Pour comparer 2 fractions, il ne faut pas comparer dénominateur et numérateur entre-eux.
- Pour multiplier 2 fractions, il faut bien multiplier dénominateur et numérateur entre-eux mais ta réduction ne sera pas appliquée (relire ta fonction reduc() et la manière utilisée pour l'appeler.)

Ah oui en effet merci pour votre réponse. 

Ce n'est pas forcément ma connaissance des mathématiques que je dois revoir , c'est plutôt 

mon attention. 

Je vous tiens au courant de la suite

int pgcd(int a , int  b){

   while(b!=0){
       const int r = b;
        b = a%b;
        a = r;

   }

/*do {
    if(a>b){r=a%b; a=b;b=r;}
    else if(b>a){ r=b%a; b=a; a=r;}
    //else return a;
}while(r!=0);*/
return a;
}