Bonjour,

Alors voila je suis sur le TP:La poo en pratique
A la compile il me dit sa:
error: request for member 'afficher' in 'resultat', which is of non-class type

main.cpp

ZFraction fraction1(4, 2), fraction2(10, 20);
    ZFraction resultat();

    fraction1.afficher();
    resultat.afficher();//Erreur

    cout<<endl<<endl;

Je supose que ce sont mes constructeurs qui ont un soucis.

ZFaction.cpp

ZFraction::ZFraction() : m_numerateur(0), m_denominateur(0)
{
    //ctor
}

ZFraction::ZFraction(int entier) : m_numerateur(entier), m_denominateur(1)
{
    //ctor
}

ZFraction::ZFraction(int numerateur, int denominateur)
{
    m_numerateur=numerateur/pgcd(numerateur,denominateur);
    m_denominateur=denominateur/pgcd(numerateur,denominateur); //ctor

Toutes reponse sera la bienvenu :-)

En gros tu as fait appel à une méthode qui n'existe pas dans la classe ZFraction
EDIT: Est ce normal que ZFraction resultat ne prenne pas de paramètres ?

"ZFraction resultat();" ne déclare pas une variable... vire les parenthèses.

En enlevant les parenthèses c'est pareille

et oui c'est pour l'instant normal car je voulais tester mes constructeurs et j'ai le même message si je fait
ZFraction fraction2(10);

edit:

Ce n'est pas le même message d'erreur pour ZFraction resultat:
error: call of overloaded 'ZFraction()' is ambiguous

Tu peux donner le code entier, avec les 3 fichiers ? ( Et tu utilise bien les balises codes C++ ? Car ton code n'est pas coloré)

main.cpp

#include <iostream>
#include <string>

#include "ZFraction.h"



using namespace std;

int main()
{
    ZFraction fraction1(4, 2), fraction2(10, 20);
    ZFraction resultat;

    fraction1.afficher();
    resultat.afficher();

    cout<<endl<<endl;
    return 0;
}

ZFracton.cpp

#include <iostream>
#include <string>

#include "ZFraction.h"
using namespace std;

ZFraction::ZFraction() : m_numerateur(0), m_denominateur(0)
{
    //ctor
}

ZFraction::ZFraction(int entier) : m_numerateur(entier), m_denominateur(1)
{
    //ctor
}

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

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

ZFraction& operator+(const ZFraction &fraction)
{

}



int pgcd(int a, int b)
{
    while (b != 0)
    {
        const int t = b;
        b = a%b;
        a=t;
    }
    return a;
}

ZFraction.h

#include <iostream>
#include <string>

#ifndef ZFRACTION_H
#define ZFRACTION_H



class ZFraction
{
    public:
    ZFraction();
    ZFraction(int entier = 0);
    ZFraction(int numerateur = 0, int denominateur = 0) ;

    void afficher() const;
    ZFraction& operator+(const ZFraction &zfraction);


    private:

    int m_numerateur;
    int m_denominateur;

};

int pgcd(int a, int b);

#endif // ZFRACTION_H

edit:
error: call of overloaded 'ZFraction()' is ambiguou
note: candidates are: ZFraction::ZFraction(int, int
note: ZFraction::ZFraction(int)
note: ZFraction::ZFraction()

Dans ton 3ème constructeur, ne simplifie pas la fraction, créer une fonction membre de ta classe " void simplifie() ", qui s'occupera de diviser le numérateur et le dénominateur par leur PGCD, ici contente toi d'affecter numerateur à m_numerateur et denominateur avec m_denominateur.
La fonction " operator+" est, comme son nom l'indique une fonction, dans ton fichier .h, le prototype doit être en dehors de la classe, c'est l'operator "+=" qui doit être une méthode.
Dans ta méthode " afficher ", pourquoi le fais-tu sur 3 lignes ? Fais le en 1 seule, c'est plus facile : cout << m_numerateur "/" << m_denominateur << endl;

Pour ton erreur, je vais copier-coller ton code et essayer de t'aider

Tout d'abord merci

Pour afficher, j'avais avant de l’écrire comme sa, fais en sorte que cela ressemble a une véritable fraction mais j'ai fini par simplifier.

Pour ce qui concerne le 3 éme constructeur es une faute de faire cela ?


et encore merci

Non mais pour des raisons de simplicité :).
J'ai essayé ton code, je n'obtiens pas les mêmes erreurs que toi, déjà tu as un constructeur en trop, ton premier constructeur ne prend pas de paramètres, ca c'est bon mais ton deuxième en prend un mais qui a une valeur par défaut, donc on n'est pas obligé de le mettre, résultat le "programme" ne sait pas lequel des deux utiliser.
Aussi, dans ton fichier.h, "include<iostream>", doit se faire après les 2 lignes du début, et tu n'as pas de besoin d'inclure "string".

J'ai supprimer le second constructeur mais toujours la même erreur "Ambigous"

En ce qui concerne le second constructeur je voulais qu'il me créer une fraction quand l'on rentre seulementun entier

Fais seulement un constructeur :

Zfraction::Zfraction(int numerateur, int denominateur) : m_numerateur(numerateur), m_denominateur(denominateur)
{

}
Et dans le prototypes dans le .h, tu mettra en valeur par défaut 0 et 1. Comme si l'utilisateur n'envoie pas de paramètre, la fraction vaudra 0/1, si il n'envoie pas le dénominateur et 2 au numérateur, elle vaudra 2/1, si il fait l'inverse, elle vaudra 1/2, et si il envoie les 2 bah c'est encore mieux

J'avais penser a sa au début mais j'ai cru comprendre dans le TP que sans argument je devais retourné 0/0

Qst : Sans cette erreur es-que le code d'origine marche avec les 3 constructeurs ?

Oui sauf que tu as un problème avec l'operateur "+", tu as confondu l'opérateur "+" qui doit être déclaré EN DEHORS de la classe dans le .h, et l'operateur "+=" qui lui doit être une méthode de la classe, regarde bien le tuto, tu as mal déclaré ta fonction " operator+", en fait tu as défini la fonction comme "operator+=", sauf que ce n'est pas operator+= :p.
"Operator+" => Zfraction operator+(Zfraction const &a, Zfraction const &b);

Oui mais a par sa tout devrais fonctionner cela est très ...

Montre ce que tu as fais en repostant tes codes, et dis les erreurs qui restent.

En faite maintenant je me casse la tête avec la fonction
void simplifie()

je ne sais pas vraiment comment faire apparemment sa devrais simplifier mais j'ai l'impression de faire compliqué dois-je faire des accesseur pour M_numérateur et m_dénominateur

EDIT:

Merci je continuerais demain a ++

Non, la méthode simplifie(), fait partie de la classe, tu peux donc utiliser ses attributs sans problèmes, tu as écris la fonction pgcd.
Pour simplifier une fraction, on divise le numérateur et le dénominateur par leur pgcd, donc en gros dans ta fonction simplifie tu fais quelquechose du genre :

int nombre = pgcd(m_numerateur,m_denominateur)
// Donc là nombre aura pour valeur le pgcd du numerateur et denominateur de ta fraction
Et :
m_numerateur /= pgcd;
m_denominateur /=pgcd;
// Tu divises le numerateur et le denominateur par le pgcd de ces 2 nombres, ta fraction sera alors irréductible.

bon je poste ce que j'ai fait pour l'instant puis je continuerais demains

main

#include <iostream>
#include <string>

#include "ZFraction.h"



using namespace std;

int main()
{
    ZFraction fraction1(4, 2), fraction2(10), resultat;

    fraction1.simplifie();
    fraction1.afficher();
    cout<<endl<<endl;
    fraction2.simplifie();
    fraction2.afficher();
    cout<<endl<<endl;

    resultat.afficher();




    cout<<endl<<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)
{

}


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

void ZFraction::afficher() const
{

    cout<<m_numerateur<<"/"<<m_denominateur;
}

ZFraction& operator+(const ZFraction &fraction)
{

}

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

}



int pgcd(int a, int b)
{
    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();

    ZFraction(int numerateur = 0, int denominateur = 1) ;
    ZFraction& operator+=(const ZFraction &fraction);
    void afficher() const;
    void simplifie();


    private:

    int m_numerateur;
    int m_denominateur;

};

ZFraction operator+(ZFraction const& a, ZFraction const& b);
int pgcd(int a, int b);

#endif // ZFRACTION_H

Ce code ne marche pas a moins que pour ZFraction resultat; je l'initialise a resultat(1) (dans le main)

Ok, bonne chance alors ( euh petite erreur de ta part) : ligne 31 à 34, c'est bon mais
ligne 26 à 29 tu as écris "operator+" au lieu de "operator+=" et c'est une méthode de la classe donc le nom de la fonction doit être : "ZFraction& ZFraction::operator+=(ZFraction const &fraction).

oui merci j'ai vu apres avoir posté

Derien, n'oublie pas que qund tu écriras le code des fonctions operator+ et operator +=, tu pourras retirer dans ton main le fraction1.simplifie(); , dans ton " operator+=" qui est une méthode de la classe, tu auras juste à écrire dans la dernière ligne un simple : simplifie(); pour appeler la fonction et qu'elle te renvoie le résultat directement simplifié.

Salut, je vois encore une erreur :
C'est peut-être un oubli, mais dans la dernière version du code que tu as posté, tu as laissé le constructeur sans argument dans la déclaration de ta classe. En fait c'est à cause de lui que tu avais l'erreur "call of overloaded 'ZFraction()' is ambiguou".
Cela est dû au fait que ton constructeur sans argument et ton constructeur avec arguments par défaut peuvent tout deux être appelés de la même façon : sans argument. Et là le compilateur fait bien de râler, parce que, comme il te le dit, il ne sais pas quelle version appeler, vu que les deux versions qu'il connait sont envisageables.
La solution : tu vires le constructeur sans argument, vu que tu en as un qui propose deux arguments par défaut, il fait lui-même le boulot pour le cas où un utilisateur ne fournirait pas d'argument.

PS : Peut-être est-ce ce que tu avais commencé à faire car je vois que tu avais enlevé la définition de ce constructeur sans argument. Va jusqu'au bout et enlève-le aussi dans ton .h (si c'est le comportement que tu attends, bien sûr)

Oui enlève le prototype du premier constructeur dans ton .h, ton compilateur ne saura toujours pas quelle version utiliser, là j'ai copié-collé ton code, tu n'as normalement aucune erreur

Te reste plus qu'à implémenter l'opérateur "<<", "+","+=","*","*=" etc..

Bonjour,

me revoila

voila encore un peu du code

main

int main()
{

    ZFraction fraction1(10, 30), fraction2(1,3), fraction3;

    cout<<fraction1;
    cout<<" + ";
    fraction2;
    cout<<" = ";
    (fraction1+fraction2).afficher();
    cout<<endl<<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
{

}

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) // *=
{
    int copie1(m_denominateur), copie2(fraction.m_numerateur);
    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;
}

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;


    private:

    int m_numerateur;
    int m_denominateur;

};


ZFraction operator+(ZFraction const& a, ZFraction const& b);
ZFraction operator*(ZFraction const& a, ZFraction const& b);
ostream &operator<<(ostream &flux, ZFraction const& fraction);// Erreur
int pgcd(int a, int b);

#endif // ZFRACTION_H

j'ai beaucoup de mal avec l'operateur << je pense pas avoir bien fait les chose

C'est beaucoup mieux
Petite remarque : Dans ZFraction.cpp, ligne 48 à 56, tu peux virer la première ligne : ZFraction copie(m_denominateur)...
Elle ne sert à rien puisque,au final tu n'utilise meme pas les objets copie1 et copie2

Oups c'est vrais un oublie de mon copie collé
En se qui concerne << je ni arrive pas

Qu'es que je fais mal???

de meme tu pourrai faire appel a ta fonction simplifie() dans le constructeur pour être sur de travailler avec des fractions déjà simplifiée et comme sa si tu veux les afficher, tu a quelque chose de correct

1-Comme il est préférable de pas utiliser "using namespace std" dans les fichiers headers(*.h), dans le prototype de ton operateur " << ", tu dois rajouter std:: aussi devant ostream ( le 1er mot de ta ligne)
Et aussi, tu as mis une accolade en trop dans ton main

L'accolade n'est que sur le site

et merci pour le std:: c'est que sa ne soit que sa

Encore une chose, le code n'affichera pas ce que tu veux , dans ton main, tu n'affiche à aucun moment "fraction2" , tu dois faire :

cout << fraction1;
cout <<"+";
cout << fraction2;
cout << "=";

Le changement se trouve à la 3e ligne de mon code// Tu as défini l'opérateur " << " et "+" avec "+=" donc remplace :

(fraction1+fraction2).afficher();

par :

cout << fraction1 + fraction2;