Discussion :

[oswalidos]

salut
je suis entrain d'ecrire une classes fraction dont j'ai besoin de surcharger les opérateur + << >> > < et () ,j'ai tout fais mais j'arrive pas a surcharger les parentheses !
l'idée est la suivante:
surchager les () pour que, par exemple (1/4) retourne un objet de type fraction.
j'espère que vous me donner un coup de main.
merci d'avance

[Florian Goo]

Bonjour,

En gros, tu voudrais pouvoir écrire ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
Fraction f(1/4);

?

[Alp]

Je doute que ce soit possible, car l'expression 1/4 sera évaluée... On pourrait se dire que surcharger "/" pour les entiers marcherait, mais je doute que ça fonctionne.

La solution qui semble la plus raisonnable, c'est :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Fraction f(1, 4);

Mais il s'agit ici du constructeur...
Surcharger les parenthèses servirait éventuellement à changer la valeur de la fraction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Fraction f(1, 4);
f(2, 3); // f = 2/3 maintenant

[Florian Goo]

J'attendais de savoir ce qu'il voulais vraiment
Ce qui est sûr c'est que l'utilisation de la surcharge de l'opérateur parenthèse ne donnera pas quelque chose de très intuitif (voire totalement contre-intuitif) !

On pourrait faire un truc avec Boost.Proto ?

[Alp]

On pourrait faire un truc avec Boost.Proto ?

Probablement

Mais pour _un seul type_ ça fait un peu lourd

[oswalidos]

merci pour vos interventions et voici le probleme :
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 !

voila j'ai commencer a essayer ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
/*********Fraction.h*************/
#include<iostream>
#include <iomanip>
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 &frac);
    bool operator>(const Fraction &frac);
    Fraction& operator+(const Fraction &frac);
 
    private:
    int m_numerateur;
    int m_denominateur;
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
/*******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 &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;
}
 
 
bool Fraction::operator>(const Fraction &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& Fraction::operator+(const Fraction &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;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
/*********main.cpp************/
#include "fraction.h"
 
ostream& operator<<(ostream& os, Fraction& frac){
    os << frac.getNumerateur();
    os << "/";
    os << frac.getDenominateur();
    return os;
}
 
istream& operator>>(istream& is, Fraction& 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 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
/*********Expression.h**************/
#include <iostream>
 
using namespace std;
 
class Expression{
    public:
    Expression();
    Expression& insert(int val);
    void affiche();
    ~Expression();
 
    struct ElementListe {
        int  donnee;
        ElementListe *suivant;
        ElementListe *precedent;
    };
 
 
    private:
    int taille;
    ElementListe *debut;
    ElementListe *fin;
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
/*********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& 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;
      }
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
/*******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;
}

ben je crois que je deviens ennuiyant maintenent !!