Oui bien sur c'était seulement pour les test de compil

Si ton sujet est résolu, passe le en " Résolu ", à moins que tu attendes d'avoir implémenté les opérateurs de comparaisons etc...

J'ajouterais en prime que comme ton operator<< renvoie une référence vers un ostream, tu peux chaîner tes appels :
plutôt que de faire
cout << fraction1;
cout <<"+";
cout << fraction2;

fais
cout << fraction1 << "+" << fraction2 << "=" << (fraction1+fraction2) << endl;

Ca n'apporte pas grand chose, mais c'est possible et plus simple.

Bon je ne veut pas créer de nouveau sujet je continu sur celui la.

J'ai un souci au niveau de l’implémentation de estInferieure.

HELP ME

main.cpp

#include <iostream>
#include <string>

#include "ZFraction.h"



using namespace std;

int main()
{

    ZFraction fraction1(1,5), fraction2(1,2);

    cout<<"fraction 1 = "<<fraction1<<" x "<<"fraction 2 = "<<fraction2<<endl<<" = "<<fraction1*fraction2<<endl<<endl;


    if(fraction1<fraction2)
        cout<<fraction1<<" Est inferrieur a "<<fraction1<<endl;


    return 0;
}

ZFraction.cpp

#include <iostream>
#include <string>

#include "ZFraction.h"
using namespace std;

ZFraction::ZFraction(int numerateur, int denominateur) : m_numerateur(numerateur), m_denominateur(denominateur)//ctor
{
    simplifie();
}

void ZFraction::simplifie() // Methode Simplifie les fractions
{
    int nombre = pgcd(m_numerateur,m_denominateur);
    m_numerateur/=nombre;
    m_denominateur/=nombre;
}

ZFraction operator+(ZFraction const& a, ZFraction const& b) // +
{
    ZFraction copie(a);
    copie += b;
    return copie;

}

ZFraction& ZFraction::operator+=(const ZFraction &fraction) // +=
{
    int copie1(m_denominateur), copie2(fraction.m_numerateur);
    m_numerateur*=fraction.m_denominateur;//num1*den2 mise au meme denominateur
    copie1*=fraction.m_denominateur;//den1*den2
    copie2*=m_denominateur;//num2*den1
    m_numerateur+=copie2;
    m_denominateur=copie1;
    simplifie();

    return *this;
}

ZFraction operator*(ZFraction const& a, ZFraction const& b) // *
{
    ZFraction copie(a);
    copie *= b;
    return copie;

}

ZFraction& ZFraction::operator*=(const ZFraction &fraction) // *=
{
    m_numerateur*=fraction.m_numerateur;//num1*den2 mise au meme denominateur
    m_denominateur*=fraction.m_denominateur;//den1*den2
    simplifie();

    return *this;
}

void ZFraction::afficher() const
{
    cout<<m_numerateur<<"/"<<m_denominateur;
}

void ZFraction::afficher(ostream &flux) const // Methode afficher
{
    flux<<m_numerateur<<"/"<<m_denominateur;
}

ostream &operator<<( ostream &flux, ZFraction const& fraction )
{
    fraction.afficher(flux);
    return flux;
}

bool ZFraction::estEgal(ZFraction const& b) const //Teste si =
{
    if (m_numerateur== b.m_numerateur && m_denominateur==b.m_denominateur)
        return true;
    else
        return false;
}

bool operator==(ZFraction const& a, ZFraction const& b)
{
    return a.estEgal(b);
}

bool ZFraction::estInferrieur(ZFraction const& b) const //Test si <
{
    if ((m_numerateur/m_denominateur) < (b.m_numerateur/b.m_denominateur))// ES BON    ?????
        return true;
    else
        return false;
}

bool operator<(ZFraction const& a, ZFraction const& b) //Test si <
{
    return a.estInferrieur(b);
}

bool operator>(ZFraction const& a, ZFraction const& b) //Test si >
{
    if (a.estInferrieur(b) || a.estEgal(b))
        return false;
    else
        return true;
}

bool operator<=(ZFraction const& a, ZFraction const& b) //Test si <=
{
    if (a.estInferrieur(b) || a.estEgal(b))
        return true;
    else
        return false;
}

bool operator>=(ZFraction const& a, ZFraction const& b) //Test si >=
{
    if (a.estInferrieur(b))
        return false;
    else
        return true;
}

int pgcd(int a, int b) // Calcul du plus grand commun denominateur
{
    while (b != 0)
    {
        const int t = b;
        b = a%b;
        a=t;
    }
    return a;
}

ZFraction.h

#ifndef ZFRACTION_H
#define ZFRACTION_H

#include <iostream>
#include <string>

class ZFraction
{
    public:

    ZFraction(int numerateur = 0, int denominateur = 1) ;
    ZFraction& operator+=(const ZFraction &fraction);
    ZFraction& operator*=(const ZFraction &fraction);
    void simplifie();
    void afficher() const;
    void afficher(std::ostream &flux) const;
    bool estEgal(ZFraction const& b) const;
    bool estInferrieur(ZFraction const& b) const;

    private:

    int m_numerateur;
    int m_denominateur;

};

ZFraction operator+(ZFraction const& a, ZFraction const& b);
ZFraction operator*(ZFraction const& a, ZFraction const& b);
std::ostream &operator<<(std::ostream &flux, ZFraction const& fraction);
bool operator==(ZFraction const& a, ZFraction const& b);
bool operator<(ZFraction const& a, ZFraction const& b);
bool operator>(ZFraction const& a, ZFraction const& b);
bool operator<=(ZFraction const& a, ZFraction const& b);
bool operator>=(ZFraction const& a, ZFraction const& b);
int pgcd(int a, int b);

#endif // ZFRACTION_H

Dans "EstInferrieur", remplace les "/" par des "*", et les parenthèses autour de m_numerateur et m_denominateur ne sont pas utiles, le C++ gère les priorités opératoires.

Ok merci du coup j'inverse <.

Pourquoi les / ne marche pas ?

Et pour le reste du code y a t'il des améliorations d'algo a faire ?

J'ai pas trop regardé ton code en détail, je verrais après si tu veux , pour les "/" , je sais pas si ça marche qu'avec les multiplications, ça utilise le produit en croix, donc en gros, si le numérateur de la 1ère fraction multiplié par le dénominateur de la 2ème est égal au dénominateur de la 1ère fraction multiplié par le numérateur de la 2ème, alors les 2 fractions sont égales.

EDIT : Ta méthode " operator+=" est beaucoup trop longue, aide toi du corrigé. Pour t'aider, la formule pour additionner deux fractions de dénominateur diffé
<math>\(a/b + c/d\)</math> => Le numérateur sera égal à = <math>\(a*d + c*b\)</math> et le dénominateur sera égal à = <math>\(b*d\)</math>
Normalement ça devrait tenir en 2 lignes.

2eEDIT : Ligne 99-105 de ZFraction.cpp, "operator>", le signe ">" signifie strictement supérieur, ce signe est vrai uniquement si le nombre à gauche du signe est vraiment supérieur au nombre qui est à sa droite, dans ton premier "if", tu dois juste tester avec " estInferieur" et pas aussi avec "estEgal" car le nombre doit être vraiment supérieur.

En faite il me renvoi false si il est inferieur ou egal

Ah oui j'avais pas vu mince

Et bien merci pour ton aide.
a++

Derien