Problem de surcharge des ()

Signaler
Messages postés
13
Date d'inscription
lundi 11 août 2008
Statut
Membre
Dernière intervention
13 décembre 2008
-
Messages postés
13
Date d'inscription
lundi 11 août 2008
Statut
Membre
Dernière intervention
13 décembre 2008
-
salut :)
je travaille sous xp avec code::blocks
mon probleme est le suivant
l'utilisateur doit donner une expression , exemp : (1/7)+(2/3)+(4/3)
je suis demandé de :
-stocker les fractions dans une liste doublement chainée circulaire
-surcharger les opérateurs << >> < > + ()
-ce travail doit me permettre de manipuler l'expression comme calculer la somme des fractions , comparer les fractions etc

logiquement la surcharge des () doit porter sur les fractions .
pour le moment j'ai essayer de surcharger << et >> sur le type Fraction et ça marche mais avec un surcharge de () je crois
que le compilateur doit etre capable de prendre du flux entrant tout un (1/7) et la stocker comme Fraction dans une
cellule de la liste.
j'èspere que j'ai bien mis au point le probleme,si mon idée parait non faisable veuillez me dire pourquoi et me proposer une autre si c'est possible :)
a propos ! c'est vraiment un forum vivant ! :king:

voila j'ai commencer a essayer ça :
/*********Fraction.h*************/
#include
#include 
using namespace std;

class Fraction{
    public:
    Fraction();
    Fraction(int numerateur);
    Fraction(int numerateur, int denominateur);
    int getNumerateur();
    int getDenominateur();
    void setNumerateur(int );
    void setDenominateur(int );
    bool operator<(const Fraction &amp;frac);
    bool operator>(const Fraction &amp;frac);
    Fraction&amp; operator+(const Fraction &amp;frac);

    private:
    int m_numerateur;
    int m_denominateur;
};

/*******Fraction.cpp**************/
#include "fraction.h"

Fraction::Fraction(int numerateur,int denominateur){
    m_numerateur=numerateur;
    m_denominateur=denominateur;
}

Fraction::Fraction(int numerateur){
    m_numerateur=numerateur;
    m_denominateur=1;
}

Fraction::Fraction(){
    m_numerateur=0;
    m_denominateur=0;
}


int Fraction::getNumerateur(){
    return m_numerateur;
}

int Fraction::getDenominateur(){
    return m_denominateur;
}

void Fraction::setNumerateur(int numerateur){
    m_numerateur=numerateur;
}

void Fraction::setDenominateur(int denominateur){
    m_denominateur=denominateur;
}

bool Fraction::operator<(const Fraction &amp;frac){
    int numerateur=m_numerateur;
    int denominateur=m_denominateur;
    int num=frac.m_numerateur;
    num=frac.m_numerateur*denominateur;
    numerateur=numerateur*frac.m_denominateur;
    denominateur=frac.m_denominateur*denominateur;
    num=denominateur;
    if (numerateur<m_numerateur) return="" true;="" else="" false;="" }="" bool="" fraction::operator="">(const Fraction &amp;frac){
    int numerateur=m_numerateur;
    int denominateur=m_denominateur;
    int num=frac.m_numerateur;
    num=frac.m_numerateur*denominateur;
    numerateur=numerateur*frac.m_denominateur;
    denominateur=frac.m_denominateur*denominateur;
    num=denominateur;
    if (numerateur>m_numerateur) return true;
    else return false;
}


Fraction&amp; Fraction::operator+(const Fraction &amp;frac){
    int numerateur=m_numerateur;
    int denominateur=m_denominateur;

    numerateur=frac.m_numerateur*denominateur+numerateur*frac.m_denominateur;
    denominateur=frac.m_denominateur*denominateur;

    Fraction res(numerateur,denominateur);

    return res;
}

/*********main.cpp************/
#include "fraction.h"

ostream&amp; operator<<(ostream&amp; os, Fraction&amp; frac){
    os << frac.getNumerateur();
    os << "/";
    os << frac.getDenominateur();
    return os;
}

istream&amp; operator>>(istream&amp; is, Fraction&amp; frac){
    int a;
    cout << "Entrez une fraction " << endl;
    is >> setw(1) >> a;
    frac.setNumerateur(a);
    is.ignore();
    is >> setw(1) >> a;
    frac.setDenominateur(a);
    return is;
}


int main(){
    Fraction frac1;
    cin >> frac1;
    Fraction frac2;
    cin >> frac2;
    Fraction res;
    res=frac1+frac2;
    cout << frac1 << " + " << frac2 << " = " << res << endl;
    if (frac1<frac2) cout=""><< frac1 << " < " << frac2 << endl;
    if (frac1>frac2) cout << frac1 << " > " << frac2 << endl;
    return 0;
}

ça marche bien mais maintenant je doit le fait évoluer pour qu'il prend tout une expression et la stocke dans une liste que je l'ai déja écrit a part :
/*********Expression.h**************/
#include 

using namespace std;

class Expression{
    public:
    Expression();
    Expression&amp; insert(int val);
    void affiche();
    ~Expression();

    struct ElementListe {
        int  donnee;
        ElementListe *suivant;
        ElementListe *precedent;
    };


    private:
    int taille;
    ElementListe *debut;
    ElementListe *fin;
};

/*********Expression.cpp*************/
#include "Expression.h"

Expression::Expression(){
    debut = NULL;
    fin = NULL;
    taille = 0;
}

Expression::~Expression(){
    /* si la liste est vide, il n'y a rien à faire
     * il n'y a que si elle ne l'est pas qu'il faudra tout libérer
     */
    if(debut!=0)
    {
        /* il va nous falloir deux pointeurs "temporaires":
         * le premier pour représenter l'élément à supprimer,
         * le second pour représenter l'élément qui suit celui que l'on
         * s'apprête à supprimer
         *
         * Le premier élément que nous supprimerons sera... le premier
         * de la liste
         * et, fatalement, son suivant sera celui qui le suit
         */
        ElementListe *todel = debut;
        ElementListe *suivant = todel->suivant;
        /* nous allons maintenant travailler jusqu'à ce que l'élément qui
         * suit celui qu'on a supprimé (ou qu'on est sur le point de
         * supprimer) ne nous ramène sur le premier
        */
        do
        {
            /* pour etre propre, mettons les liens à NULL */
            todel->precedent = NULL;
            todel->suivant = NULL;
            /* et effacons l'élément */
            delete todel;
            /* l'élément suivant devient celui qui devra etre supprimé
             */
            todel = suivant;
            /* et l'élément qui le suit devient l'élément... qui suit celui
             * qui doit être supprimé
             */
            suivant = todel->suivant;
        } while( suivant==debut );
    } // fin de la vérification de liste vide
    /* pour etre propre, mettons debut et fin à NULL */
    debut = NULL;
    fin = NULL;
    cout << "everything is deleted !" ;
}

Expression&amp; Expression::insert(int val)
{
    /* création de l'élément à rajouter */
    ElementListe *toadd = new ElementListe;
    /*initialisation des membres */
    toadd->donnee = val;
    /* l'élément qui le précède est de toutes manière le dernier de la liste */
    toadd->precedent = fin;
    /* et celui qui le suit, étant donné que nous sommes dans une
     * liste circulaire est de toutes manières le premier de la liste */
    toadd->suivant = debut;
    /* il est temps d'insérer l'élément dans la liste */
    /* S'il existe un dernier élément dans la liste, nous faisons pointer sa
     * référence "suivant" vers le nouvel élément*/
    if(fin)
        fin->suivant = toadd;
    /* S'il existe un premier élément dans la liste, nous faisons pointer sa
     * référence "precedent sur le nouvel element*/
    if(debut)
        debut->precedent = toadd;
    else
    {
        /* par contre, si la liste est vide, le nouvel élément devient le
         * premier de la liste, et ses deux références pointent vers
         * lui-même
         */
        debut = toadd;
        toadd->precedent = toadd;
        toadd->suivant = toadd;
    }
    /* quoi qu'il en soit, l'élément ajouté devient le dernier élément de
     * la liste et nous mettons le nombre d'éléments à jour
     */
    fin = toadd;
    taille++;
    /* nous pouvons maintenant renvoyer une référence sur notre liste
     * circulaire
     */
    return  *this;
}

void Expression::affiche(){
  ElementListe *courant;
  courant = this->debut;
  int i=0;
  if (!this->taille)
      cout << "la liste est vide !" << endl;
      else{
          cout << "[ " ;
          while(i<(this->taille)){
          cout << courant->donnee <<" " ;
          courant = courant->suivant;
          i++;
          }
          cout << "]" << endl;
      }
}

/*******main.cpp***********/
#include "Expression.h"

int main()
{
    Expression expr;
    expr.affiche();

    expr = expr.insert(5);
    expr.affiche();

    expr = expr.insert(2);
    expr.affiche();

    expr = expr.insert(1);
    expr.affiche();

    return 0;
}


merci d'avance :)</frac2)></m_numerateur)>

5 réponses

Messages postés
180
Date d'inscription
mercredi 22 décembre 2004
Statut
Membre
Dernière intervention
16 août 2012
2
Salut,

il faut que tu remplaces

Fraction& Fraction::operator+(const Fraction &frac);

par

Fraction Fraction::operator+(const Fraction &frac);
Messages postés
180
Date d'inscription
mercredi 22 décembre 2004
Statut
Membre
Dernière intervention
16 août 2012
2
Re-salut,

En général, on surcharge l'opérateur () lorsqu'on manipule des objets fonction ; or, une fraction n'est pas vraiment un objet fonction.
En me torturant un peu l'esprit, il y a deux significations qui me viennent :
- l'opérateur () servirait pour la multiplication,  pour donner un sens à l'expression ( a + b )( c + d ) ;
- l'opérateur () servirait pour l'évaluation de la fraction, sous forme réelle par exemple.

Mais je suis peu convaincu, car dans le premier cas, il serait plus naturel et judicieux d'utiliser l'opérateur * et dans le second l'opérateur double().

Quant à ton interprétation, elle me semble peu probable, car l'opérateur () ne serait pas un opérateur de Fraction.

Pourrais-tu mettre l'énoncé entier en ligne ?
Messages postés
13
Date d'inscription
lundi 11 août 2008
Statut
Membre
Dernière intervention
13 décembre 2008

Travaux Pratiques Conception et Programmation Orienté-Objets - TP1 - Le but de ce travail consiste à réaliser un mini éditeur offrant quelques traitements sur des expressions formées d'une somme de fractions.
Description des fonctionnalités
Il s’agit d'offrir à l'utilisateur la possibilité de faire les commandes suivantes :
1. Saisir deux expressions :
o Exemple :
donner la 1ère expression : (1/3)+(7/3)+(2/9)+(7/5) donner la 2ème expression : (2/3)+(1/3)
2. Afficher les deux expressions.
3. Trier les fractions des deux expressions selon l'un des modes de son choix (croissant ou décroissant):
-Dans, l'ordre croissant.
o Exemple :
1ère expression : (2/9)+(1/3)+(7/5)+(7/3) 2ème expression : (1/3)+(2/3)
-Dans l’ordre décroissant, le tri est un peu particulier ! En effet, dans cet ordre le tri se fait principalement en fonction des numérateurs des fractions dans leur ordre décroissant et en cas d'égalité des numérateurs, les fractions sont triées dans l'ordre croissant de leur dénominateur.
o Exemple :
1ère expression : (7/3)+(7/5) +(2/9)+(1/3) 2ème expression : (2/3)+(1/3)
4. Evaluer la somme de la 1ère expression. Il s’agit de calculer la somme des fractions et d’afficher le résultat.
o Exemple :
Evaluation de la 1ère expression : (183/45)
5. Echanger les deux expressions (cad copier 1ère expression dans 2ème et 2ème dans 1ère)
6. Enregistrer dans le fichier dénommé « data.frc » les 2 expressions saisies.
7. Charger depuis le fichier dénommé « data.frc » les 2 expressions sauvegardées.
8. Quitter.
Instructions de conception :
-Une expression est une suite de somme de fractions. Cette suite est à gérer par une collection de type « Liste doublement chaînée circulaire ».
-Surcharger les opérateurs : +, (), <, >, <<, >>
-Il est possible de faire plusieurs fois les commandes de 1 à 7.
N.B. : Une fraction en mode saisie s’écrit sous la forme a/b ou a ? I et b? I*. I = {0,1,2,3,4,5,6,7,8,9}
Instructions d’implémentation
- Utiliser l'environnement visual C++ ou un environnement équivalent. Pour visual C++, créer un projet « Win32 Console Application» intitulé Editeur.
-Utiliser les bibliothèques ?stream et non pas stdio.
-Donner les fichiers contenant les classes Fraction, Expression, Editeur et le main().
Messages postés
180
Date d'inscription
mercredi 22 décembre 2004
Statut
Membre
Dernière intervention
16 août 2012
2
Après lecture de l'énoncé, je comprends un peu mieux.

les opérateurs à surcharger + , <<, >>, >, < et () sont ceux de la classe Expression et non pas ceux de la classe Fraction.
Ta classe Expression doit surcharger l'opérateur () de la manière suivante :

class Expression
{
    //...
public:
    Fraction operator()()
    {
        //Retourne l'évaluation de l'expression sous la forme de fraction
    }
    //...
};
Messages postés
13
Date d'inscription
lundi 11 août 2008
Statut
Membre
Dernière intervention
13 décembre 2008

est ce que je peux ajouter une piece jointe ici pour mettre le pdf de l'enoncé ? je crois que ce que j'ai mis n'est pas vraiment lisible.