Discussion :

[speedy_souris]

Bonjour à toutes et tous,

il y a quelques temps déjà, j'ai commencé a apprendre le c, puis maintenant me revoilà dans les méandres du c++,

dans mon apprentissage du c++, mon projet est une algorithme pour manipuler les fractions d'entier.

Mon code ne donne pas le résultat attendu

j'ai du mal à comprendre mon erreur

merci de m’orientè

Fichier.ccp

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
#include <iostream>
#include "Fraction.h"
 
#include <iostream>
#include "Fraction.h"
 
using namespace std;
 
//---------------CONSTRUCTEURS FRACTIONS---------------------------------------------------------------------------
 
// FRACTION A 0 (DEFAULT)
Fraction::Fraction(): m_numerateur(0), m_denominateur(1){}
 
// FRACTION A 1 ENTIER
Fraction::Fraction(int numerateur): m_numerateur(numerateur), m_denominateur(1){}
 
// FRACTION
Fraction::Fraction(int numerateur, int denominateur): m_numerateur(numerateur), m_denominateur(denominateur){}
 
//----------------------------------------------------------------------------------------------------------------
 
 
// REDEFINITION OPERATEUR POUR AFFICHER
ostream& operator<<(ostream& flux, Fraction const& fraction){
 
        fraction.afficher(flux);
 
return flux;
}
 
//--------------- OPERATEUR-------------------------------------------
 
// OPERATEUR D'ADDITION
Fraction operator+(Fraction const& a, Fraction const& b){
 
          Fraction copie(a);
          copie += b;
 
return copie;
}
 
// OPERATEUR DE MULTIPLICATION
Fraction operator*(Fraction const& a, Fraction const& b){
 
          Fraction copie(a);
          copie *= b;
 
return copie;
}
 
//--------------------------------------------------------------------
 
 
// METHODE D'AFFICHAGE
void Fraction::afficher(ostream& flux) const{
 
     if(m_denominateur == 1){
 
        flux << m_numerateur;
 
     }else{
           flux << m_numerateur << '/' << m_denominateur;
          }
}
 
//----------------------OPERATEURS--------------------------------------------------------------
 
// METHODE D'ADDITION
Fraction& Fraction::operator+=(const Fraction &b){
 
           m_numerateur = b.m_denominateur * m_numerateur + m_denominateur * b.m_denominateur;
           m_denominateur *= b.m_denominateur;
 
return *this;
}
 
// METHODE DE MULTIPLICATION
Fraction& Fraction::operator*=(const Fraction &b){
 
           m_numerateur *= b.m_denominateur;
           m_denominateur *= b.m_denominateur;
 
return *this;
}
 
//----------------------------------------------------------------------------------------------

fichier.h

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
#ifndef FRACTION_H_INCLUDED
#define FRACTION_H_INCLUDED
 
#include <iostream>
 
class Fraction{
 
public:
 
//-----------PROTOTYPES CONSTRUCTEURS FRACTIONS----------------------------
 
        // FRACTION A 0 (DEFAULT)
         Fraction();
 
         // FRACTION A 1 ENTIER
         Fraction(int numerateur);
 
 
            // FRACTION
         Fraction(int numerateur, int denominateur);
 
//------------------------------------------------------------------------
 
          // METHODE D'AFFICHAGE
         void afficher(std::ostream& flux) const;
 
         // METHODE D'ADDITION
         Fraction& operator+=(Fraction const& b);
 
         // METHODE DE MULTIPLICATION
         Fraction& operator*=(Fraction const& b);
 
 
private:
 
         int m_numerateur;
         int m_denominateur;
};
 
//-------------OPERATEURS-------------------------------------------------
 
// REDEFINITION OPERATEUR POUR AFFICHER
std::ostream& operator<<(std::ostream& flux, Fraction const& fraction);
 
//OPERATEUR D'ADDITION
Fraction operator+(Fraction const& a, Fraction const& b);
 
// OPERATEUR DE MULTIPLICATION
Fraction operator*(Fraction const& a, Fraction const& b);
 
//------------------------------------------------------------------------
 
 
 
#endif // FRACTION_H_INCLUDED

fichier main.ccp

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
#include <iostream>
#include "Fraction.h"
 
using namespace std;
 
int main(){
 
    Fraction a(4,5) ; //Déclare une fraction valant 4/5
    Fraction b(2);        //Déclare une fraction valant 2/1 (ce qui vaut 2)
    Fraction c,d;         //Déclare deux fractions valant 0
 
    c = a + b;
    cout << a << " + " << b << " = " << c << endl << endl;
 
    d = a * b;
    cout << a << " x " << b << " = " << d << endl;
 
    return 0;
}

résultat de l'addition : 9 / 5

résultat de la multiplication : 4 / 5

[Médinoc]

Ce code est suspect:

Code :

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

1
2
3
4
5
6
7
Fraction& Fraction::operator+=(const Fraction &b){
 
           m_numerateur = b.m_denominateur * m_numerateur + m_denominateur * b.m_denominateur;
           m_denominateur *= b.m_denominateur;
 
return *this;
}

Pour commencer, il n'utilise pas b.m_numerateur...

[Pierre le Grand]

Tout le monde s'attend à ce que a=a+5 et a+=5 donne le même résultat. C'est certain pour les types prédéfinis comme int et unsigned mais C++ n'offre aucune garantie pour les types définis par l'utilisateur. Les opérateurs =. + et += sont trois fonctions distinctes qui pourraient avoir été implémentées d'une manière telle que cette relation naturelle entre + et += ne soit pas respectée.

Afin d'éviter ce problème, on doit toujours implémenter l’opérateur + en se servant de l’opérateur +=

Code :

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

1
2
3
4
const Fraction operator +(const Fraction& lhs, const Fraction& rhs) //lhs left hand side, rhs , righr hand side, ce qui est à gauche et à droite du signe +
{
    return Fraction(lhs)+=rhs;
}

En fait, on peut faire beaucoup mieux, on peut régler le problème une fois pour toute pour tous les types.

Code :

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

1
2
3
4
template <typename T> inline const T operator+(const T& lhs, const T& rhs)
{
   return T(lhs)+=rhs;
}

Ce qui signifie que pour tous les types T, l’opérateur + sera généré automatiquement, lorsque cela sera nécessaire, en utilisant l'opérateur +=.

[fenkys]

@pierre : c'est exactement ce qu'il a fait, rien à dire ce côté.

@speedy_souris : tu t'es allègrement mélangé les pinceaux entre les numérateurs et dénominateur dans la redéfinition des opérateur *= et +=. Medinoc a évoqué l'erreur dans +=, il y en a aussi une dans *=.

[speedy_souris]

Bonjour Médinoc, Pierre le Grand, fenkys,

merci pour vos réponses rapides

@Médinoc, avec un autre regard et un peu de recul les erreurs sont évidentes, quand on est dans le code , il est très difficile de voir ce type d'erreur surtout en tant que débutant

je vais relire le code à tête reposé pour bien comprendre mes erreurs algorithmiques

bien à vous,

speedy_souris

[ternel]

D'ailleurs, pour les opérateurs relationnels comme >, <=, >= et !=, il existe std::rel_ops, dont on peut hériter si on dispose juste de == et <

Il y a aussi Boost.operators