Surcharge operateur C++

**speedy_souris** · 01/12/2015, 15h06

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** · 02/12/2015, 13h20

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** · 02/12/2015, 18h01

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** · 03/12/2015, 12h05

@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** · 03/12/2015, 15h41

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** · 03/12/2015, 16h09

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

**speedy_souris** · 03/12/2015, 16h44

Re,

hey voila mon code une fois mes erreurs corriger

et la cerise sur le gateau j'ai le résultat attendu

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
// METHODE D'ADDITION
Fraction& Fraction::operator+=(const Fraction &b){
 
           m_numerateur = m_numerateur * b.m_denominateur + b.m_numerateur * m_denominateur;
           m_denominateur *= b.m_denominateur;
 
return *this;
}
 
// METHODE DE MULTIPLICATION
Fraction& Fraction::operator*=(const Fraction &b){
 
           m_numerateur *= b.m_numerateur;
           m_denominateur *= b.m_denominateur;
 
return *this;
}

**foetus** · 03/12/2015, 17h28

Pour la culture générale, et parce que tu travailles avec des fractions, tu as d'autres opérateurs

Code :

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

1
2
3
Fraction::operator int() { return (int) std::floor(m_numerateur / m_denominateur); }
 
Fraction::operator double() { return (double) (m_numerateur / m_denominateur); }

Édit: white_tentacle m'a repris

, mais c'est à titre d'exemple: on peut prendre en compte d'autres PODs que int et double, et faire d'autres conversions.

**white_tentacle** · 03/12/2015, 18h51

Code :

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

1
2
3
Fraction::operator int() { return m_numerateur / m_denominateur; }
 
Fraction::operator double() { return ((double)m_numerateur / m_denominateur); }

Pour la conversion en int, ça revient à effectuer la division entière (enfin, ça dépend comment on traite les négatifs -1/2 doit donner zéro ou un ?).

Pour la conversion en double, il faut caster en double avant la division, sinon c’est une division entière qui sera effectuée.

**Pierre le Grand** · 03/12/2015, 23h32

Envoyé par white_tentacle

Code :

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

1
2
3
Fraction::operator int() { return m_numerateur / m_denominateur; }
 
Fraction::operator double() { return ((double)m_numerateur / m_denominateur); }

Il est dangereux de définir une fonction de conversion implicite de cette manière. Supposons que le concepteur de la classe Fraction ait oublié de surcharger << mais qu'il ait défini uniquement la fonction de conversion en double. Ce qui suit va imprimer 0.5

Code :

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

1
2
Fraction f(1,2)
std::cout<<f<<end;

Lorsque le gentil compilateur découvre l'absence de l'opérateur << pour la classe Fraction, il fait un grand effort pour que le code soit légal. Il cherche un moyen de convertir l'instance de Fraction vers un autre type qui est imprimable. Comme la conversion en double existe, elle est utilisée. Le problème est que cela n'est pas notre décision consciente. C'est le compilateur qui décide quand ce type de fonction sera appelée en utilisant des règles complexes.

Il est préférable de coder dans le style de Lazarus/Delphi en utilisant une fonction.

Code :

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

1
2
3
4
5
double Fraction::AsDouble() const
{ 
   return ((double)m_numerateur / m_denominateur); 
 
}

Cela a le grand avantage de permettre de décider quand cette fonction sera appelée au lieu de laisser le compilateur décider. Ce n'est pas un hasard si std::string utilise la fonction c_str() au lieu d'une conversion directe en char*. Cette conversion serait trop dangereuse.

Le code original comporte aussi deux constructeurs de trop, on peut tout regrouper en un seul constructeur.

Code :

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

1
2
// FRACTION
explicit Fraction::Fraction(int numerateur=0, int denominateur=1): m_numerateur(numerateur), m_denominateur(denominateur){}

Tant qu'à parler de conversion, le explicit a pour but de bloquer une autre conversion implicite problématique. Tout constructeur qui peut être appelé avec un seul argument définit automatiquement une conversion implicite vers le type de cet argument. Ce code serait donc légal si le mot explicit avait été omis.

Code :

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

Fraction f=2; //effectue une conversion implicite des entiers vers les fractions avec le constructeur Fraction(2)

Cela peut sembler pratique jusqu'à ce que quelqu'un essaye.

Code :

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

1
2
Fraction f=0.2;
assert(f==Fraction(2,10); //Échec

Le compilateur, ne découvrant pas de conversion des réels vers les fractions, va effectuer un gros effort pour rendre la déclaration légale. Il va tout d'abord convertir 0.5 en entier, ce qui donne 0 et ensuite convertir 0 en fraction. Ce n'est pas ce que l'on désirait. Ceci démontre que ces conversions implicites par constructeur sont dangereuses. Encore une fois, c'est le compilateur qui décide quand les utiliser. Avec le mot explicit, il faut appeler le constructeur explicitement et la déclaration

Code :

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

Fraction f=0.2; //Erreur de compilation

est illégale.

**Iradrille** · 03/12/2015, 23h44

Envoyé par Pierre le Grand

Code :

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

1
2
3
4
5
double Fraction::AsDouble() const
{ 
   return ((double)m_numerateur / m_denominateur); 
 
}

Cela a le grand avantage de permettre de décider quand cette fonction sera appelée au lieu de laisser le compilateur décider. Ce n'est pas un hasard si std::string utilise la fonction c_str() au lieu d'une conversion directe en char*. Cette conversion serait trop dangereuse.

Ou mieux : un cast explicite.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
struct Foo {
	explicit operator int() const {
		return 42;
	}
};
 
void bar(int) { }
 
Foo f;
bar(f); // error C2664: 'void bar(int)'*: impossible de convertir l'argument 1 de 'Foo' en 'int'
bar(int(f)); // ok

Mais tant qu'on en abuse pas, c'est très bien les casts implicites. Çà évite une syntaxe lourde pour rien.

Surcharge operateur C++

C++

Discussions similaires

Partager

Partager