Partage

Erreur constructeur ???

Sujet résolu
Le 27 décembre 2011 à 20:18:57

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 :-)
Publicité
Le 27 décembre 2011 à 20:18:57
Le 27 décembre 2011 à 20:31:28

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 ?
L'informaticien intelligent évite le codage inutile !! Pensez aux autres : utilisez le bouton Sujet Résolu et les +1
Le 27 décembre 2011 à 20:39:26

"ZFraction resultat();" ne déclare pas une variable... vire les parenthèses.
Le 27 décembre 2011 à 20:45:36

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
Le 27 décembre 2011 à 20:52:05

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é)
Le 27 décembre 2011 à 20:55:11

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()
Le 27 décembre 2011 à 21:03:07

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
Le 27 décembre 2011 à 21:09:58

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
Le 27 décembre 2011 à 21:18:27

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".
Le 27 décembre 2011 à 21:31:04

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

Le 27 décembre 2011 à 21:37:09

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 :)
Le 27 décembre 2011 à 21:43:33

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 ?
Le 27 décembre 2011 à 21:47:07

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);
Le 27 décembre 2011 à 21:55:28

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

Le 27 décembre 2011 à 22:02:26

Montre ce que tu as fais en repostant tes codes, et dis les erreurs qui restent.
Le 27 décembre 2011 à 22:08:45

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 ++
Le 27 décembre 2011 à 22:13:00

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.
Le 27 décembre 2011 à 22:49:55

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)
Le 27 décembre 2011 à 22:56:43

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).

:)
Le 27 décembre 2011 à 23:18:18

oui merci j'ai vu apres avoir posté
Le 27 décembre 2011 à 23:25:28

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é.
Le 28 décembre 2011 à 1:16:48

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)
Le 28 décembre 2011 à 12:24:50

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.. :pirate:
Le 28 décembre 2011 à 15:39:34

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 o_O
Le 28 décembre 2011 à 15:44:12

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
:)
Le 28 décembre 2011 à 15:49:02

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

Qu'es que je fais mal???
Le 28 décembre 2011 à 15:57:15

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
Le 28 décembre 2011 à 15:59:28

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
:)
Le 28 décembre 2011 à 16:04:57

L'accolade n'est que sur le site

et merci pour le std:: c'est :colere: que sa ne soit que sa :pirate:
Le 28 décembre 2011 à 16:09:33

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;

Erreur constructeur ???

× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
  • Editeur
  • Markdown