Discussion :

[spirzouf]

Bonjour,

Je débute en C++ ainsi qu'en POO depuis quelques jours et j'apprécierai grandement votre aide.
J'aborde actuellement les classes, et en particulier l'utilisation d'opérateurs.

Je me suis imaginé un exercice dans lequel j'ai une classe nommée Monnaie qui a comme variables membres 3 valeurs numériques (livre, shilling, penny) et une string utilisable par un accesseur permettant d'afficher la valeur en texte.

Le soucis vient de l'impossibilité de passer un objet Monnaie issue d'une opération arithmétique directement dans un cout malgré la surcharge de l'opérateur << de ostream. En effet, tout fonctionne dans le programme, sauf la dernière ligne de mon main qui provoque une erreur lors de la compilation (no match for ‘operator<<’ in ‘std::operator<<):

Code :

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

cout << objetMonnaie1 << " + 35 pence = " << objetMonnaie1 + 35 << endl;

Pourtant, la surcharge de operator<< fonctionne sachant que ceci passe à la compilation et au lancement :

Code :

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

cout << objetMonnaie1 << endl;

C'est donc mon opérateur + qui met apparemment le boxon.
Dans la logique du programme, objetMonnaie1 + 35 renvoie pourtant bien un objet de type Monnaie, comme objetMonnaie1...

Voici le code source complet, également fourni en pièce jointe zippée :
(NB: les remarques sur l'amélioration du code pour le reste du programme sont bienvenues)

main.cpp

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
#include <iostream>
#include "include/Monnaie.h"
 
using namespace std;
 
int main()
{
    Monnaie monArgent(3,45,15);
    cout << "3 livres 45 shillings 15 pence = " << monArgent.str() << endl;
    monArgent.vaut(6,19,13);
    cout << "6 livres 19 shillings 13 pence = " << monArgent.str() << endl;
    cout << endl;
 
    Monnaie tonArgent(4,1);
    cout << "Ton argent : " << tonArgent.str() << endl;
    tonArgent.vaut(1);
    cout << "En fait, ton argent vaut " << tonArgent.str() << endl;
    cout << endl;
 
    Monnaie gain(20,20,20);
    Monnaie finDeMois(monArgent + gain);
    cout << "Si je travaillais, je pourrais gagner " << gain.str();
    cout << " et avoir un total de " << finDeMois.str() << endl;
 
    monArgent += tonArgent;
    cout << "C'est plus facile de te piquer ton argent, et j'ai maintenant " << monArgent.str();
    cout << " en poche" << endl;
 
    monArgent /= 2;
    cout << "Comme je dois partager à part égale avec ma femme, il ne me reste que ";
    cout << monArgent.str() << "..." << endl << endl;
 
    // utilisation de la surcharge sur l'opérateur +=
    Monnaie objetMonnaie1(1,1,1), objetMonnaie2(2,13,11);
    // - ajout d'un objet Monnaie à un autre
    cout << objetMonnaie1.str() << " + " << objetMonnaie2.str() << " = ";
    objetMonnaie1 += objetMonnaie2;
    cout << objetMonnaie1.str() << endl;
    // - ajout de 35 pence à un objet Monnaie
    cout << objetMonnaie1.str() << " + 35 pence = ";
    objetMonnaie1 += 35;
    cout << objetMonnaie1.str() << endl;
 
    // utilisation de l'opérateur de flux sortant qui réduit à 1 ligne les 3 lignes précédentes
    cout << objetMonnaie1 << " + 35 pence = " << objetMonnaie1 + 35 << endl;
 
    return 0;
}

Monnaie.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
#ifndef MONNAIE_H
#define MONNAIE_H
 
#include <string>
 
class Monnaie
{
    public:
        Monnaie(int livre = 0, int shilling = 0, int penny = 0);
        ~Monnaie();
        void vaut(int livre = 0, int shilling = 0, int penny = 0);
        std::string str();
        Monnaie &operator+=(Monnaie const &autreMonnaie);
        Monnaie &operator+=(int const pennyEnPlus);
        Monnaie &operator/=(double const &diviseur);
 
    private:
        int m_livre, m_shilling, m_penny;
        std::string m_string;
};
 
Monnaie operator+(Monnaie const &monnaie1, Monnaie const &monnaie2);
Monnaie operator+(Monnaie const &monnaie, int const pennyEnPlus);
/*
* À noter que operator+ n'intervient pas sur un objet déjà existant,
* n'appartient pas à l'espace de nom Monnaie,
* et est déclaré en dehors de la classe comme une simple fonction
* basée sur operator+= qui lui appartient à la classe.
*/
std::ostream& operator<<(std::ostream &fluxSortant, Monnaie &monnaie);
 
#endif // MONNAIE_H

Monnaie.cpp

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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
#include "../include/Monnaie.h"
#include <sstream>
#include <iostream>
 
void format(int &livre, int &shilling, int &penny, std::string &chaine)
/*
* Conversion livre - shilling - penny
* 1 livre = 20 shilling
* 1 shilling = 12 penny
*
* Affectation à une string nommée chaine de
* "xx livre(s) xx shilling(s) xx penny/pence"
* représentant la valeur de Monnaie
*/
{
    // formatage numérique
    if (penny > 11)
    {
        shilling += penny/12;
        penny %= 12;
    }
    if (shilling > 19)
    {
        livre += shilling/20;
        shilling %= 20;
    }
 
    // formatage string
    // - flux de sortie pour string
    std::ostringstream fluxSortantString;
    // - écriture dans le flux
    if (livre != 0)
    {
        fluxSortantString << livre << " livre";
        if (livre > 1) {fluxSortantString << "s";}
        if (shilling != 0 || penny != 0) {fluxSortantString << " ";}
    }
    if (shilling != 0)
    {
        fluxSortantString << shilling << " shilling";
        if (shilling > 1) {fluxSortantString << "s";}
        if (penny != 0) {fluxSortantString << " ";}
    }
    if (penny != 0)
    {
        fluxSortantString << penny;
        if (penny > 1) {fluxSortantString << " pence";}
        else {fluxSortantString << " penny";}
    }
    // - récupération de la string
    chaine = fluxSortantString.str();
}
 
Monnaie::Monnaie(int livre, int shilling, int penny) : m_livre(livre), m_shilling(shilling), m_penny(penny)
{
    //constructeur
    format(m_livre, m_shilling, m_penny, m_string);
}
 
Monnaie::~Monnaie()
{
    //destructeur vide
}
 
void Monnaie::vaut(int livre, int shilling, int penny)
{
    m_livre = livre;
    m_shilling = shilling;
    m_penny = penny;
    format(m_livre, m_shilling, m_penny, m_string);
 
}
 
std::string Monnaie::str()
{
    return m_string;
}
 
Monnaie& Monnaie::operator+=(Monnaie const &autreMonnaie)
{
    // ajout des valeurs de autreMonnaie
    m_livre += autreMonnaie.m_livre;
    m_shilling += autreMonnaie.m_shilling;
    m_penny += autreMonnaie.m_penny;
    // formatage et retour
    format(m_livre, m_shilling, m_penny, m_string);
    return *this;
}
 
Monnaie& Monnaie::operator+=(int const pennyEnPlus)
{
    // ajout des pennyEnPlus
    m_penny += pennyEnPlus;
    // formatage et retour
    format(m_livre, m_shilling, m_penny, m_string);
    return *this;
}
 
Monnaie operator+(Monnaie const &monnaie1, Monnaie const &monnaie2)
/*
* operator+ n'intervient pas sur un objet déjà existant et n'appartient pas à l'espace de nom Monnaie
*/
{
    // affectation des valeurs de monnaie1 à une copie
    Monnaie copieMonnaie(monnaie1);
    // ajout des valeurs de monnaie2
    copieMonnaie += monnaie2;
    // retour (formatage effectué par l'opérateur +=)
    return copieMonnaie;
}
 
Monnaie operator+(Monnaie const &monnaie, int const pennyEnPlus)
/*
* operator+ n'intervient pas sur un objet déjà existant et n'appartient pas à l'espace de nom Monnaie
*/
{
    // affectation des valeurs de monnaie1 à une copie
    Monnaie copieMonnaie(monnaie);
    // ajout des valeurs de monnaie2
    copieMonnaie += pennyEnPlus;
    // retour (formatage effectué par l'opérateur +=)
    return copieMonnaie;
}
 
Monnaie& Monnaie::operator/=(double const &diviseur)
{
    // division des valeurs de Monnaie
    m_livre /= diviseur;
    m_shilling /= diviseur;
    m_penny /= diviseur;
    // formatage et retour
    format(m_livre, m_shilling, m_penny, m_string);
    return *this;
}
 
std::ostream& operator<<(std::ostream &fluxSortant, Monnaie &monnaie)
/*
* cout est passé en référence dans fluxSortant
* l'objet de type Monnaie est passé en référence dans la variable monnaie
*/
{
    fluxSortant << monnaie.str(); // passage dans le flux de monnaie.m_string grace à son accesseur
    return fluxSortant;
}

[Invité]

C'est bien la surcharge de ton operateur << qui est mal faite : elle n'accepte pas d'objet Monnaie temporaire (en l'occurence, celui renvoyé par l'opérateur+). Si tu en voir le coeur net essaie ceci :

Code :

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

cout << Monnaie(3, 45, 15) << endl;

L'erreur vient du fait que son second paramètre est une rvalue-reference non constante (i.e. qui ne peut référer à un objet temporaire ); pour avoir une sémantique correcte il faut qu'elle soit constante.
Cette modification entrainera une seconde erreur de compilation : il faut indiquer que ta méthode str() ne modifie pas l'objet en la qualifiant elle aussi de constante

[spirzouf]

donc prototype de l'opérateur << modifié ainsi :

Code :

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

std::ostream& operator<<(std::ostream &fluxSortant, Monnaie const &monnaie);

et celui de la fonction str() comme cela :

Code :

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

std::string str() const;

Tout est en string const et peut être envoyé dans le flux de sortie cout.

Que du bonheur, ça fonctionne ! Merci beaucoup pour l'explication.

En plus je viens de tilter qu'on pouvait mettre const à la fin d'une fonction... Du coup, j'imagine que par principe, une fonction accesseur est toujours mise en const puisque qu'elle sert simplement à renvoyer la valeur d'une variable membre sans qu'on puisse la modifier ?

[3DArchi]

Salut,

Du coup, j'imagine que par principe, une fonction accesseur est toujours mise en const puisque qu'elle sert simplement à renvoyer la valeur d'une variable membre sans qu'on puisse la modifier ?

Par principe, les accesseurs sont bannis car ils violent l'encapsulation

Sinon, effectivement, il faut respecter la constance de tes fonctions au même titre que de tes variables. Cela est indispensable pour un design correct. Son nom respect est souvent source de bug et de calvitie (longues heures d'arrachage de cheveux).

[spirzouf]

Salut,
Par principe, les accesseurs sont bannis car ils violent l'encapsulation ;.

Bonjour,

Je croyais justement que l'accesseur permettait de respecter l'encapsulation car si il donnait effectivement "en lecture" l'accès à une caractéristique de l'objet, il empêchait toute modification

Dans mon exemple, il faudrait donc par principe bannir l'utilisation publique de ma fonction Monnaie.str() qui renvoie la valeur de Monnaie.m_string, et la mettre en private ? Mais dans ce cas,je vais être ennuyé par "std::ostream& operator<<" qui est déclaré hors classe Monnaie et fais appel à la fonction Monnaie.str() pour intégrer la représentation string de mon objet dans le flux cout ?

Qu'ont prévus les dieux du C++ pour me délivrer de cette impasse ?? Mon petit doigt me dit que je devrais reprendre le code de ma fonction format qui prend les variables de Monnaie pour renvoyer une chaîne directement au flux, sans une fonction accesseur... Je vais creuser l'idée, merci de me dire si je suis dans le vrai !

[spirzouf]

Désolé, je sèche complètement...

Ce que j'ai fait :

1. J'ai supprimé l'accesseur str() de la classe Monnaie

2. J'ai créé une fonction de la classe Monnaie nommée sortieVersFluxOstream, de type void et constante, qui prend en argument un flux ostream passé en référence et injecte dans ce flux les données à afficher.

3. J'ai modifié le contenu de la fonction surchargeant l'opérateur<< d'ostream et qui se limite désormais à l'appel à la fonction sortieVersFluxOstream sus-décrite et au return.

Et maintenant, j'ai la même erreur que dans mon post d'origine.

Code :

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

undefined reference to `operator<<(std::basic_ostream<char, std::char_traits<char> >&, Monnaie const&)'

Pourtant, je crois avoir bien fait attention aux const ?
Quelle erreur ai-je commis ?

Voici les sources (aussi en pièce jointe) :

main.cpp

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
#include <iostream>
#include "include/Monnaie.h"
 
using namespace std;
 
int main()
{
    // utilisation de l'opérateur de flux << d'ostream pour afficher un objet Monnaie
 
    Monnaie monArgent(3,45,15);
    cout << "3 livres 45 shillings 15 pence = " << monArgent << endl;
    monArgent.vaut(6,19,13);
    cout << "6 livres 19 shillings 13 pence = " << monArgent << endl;
    cout << endl;
 
    Monnaie tonArgent(4,1);
    cout << "Ton argent : " << tonArgent << endl;
    tonArgent.vaut(1);
    cout << "En fait, ton argent vaut " << tonArgent << endl;
    cout << endl;
 
    Monnaie gain(20,20,20);
    Monnaie finDeMois(monArgent + gain);
    cout << "Si je travaillais, je pourrais gagner " << gain;
    cout << " et avoir un total de " << finDeMois << endl;
 
    monArgent += tonArgent;
    cout << "C'est plus facile de te piquer ton argent, et j'ai maintenant " << monArgent;
    cout << " en poche" << endl;
 
    monArgent /= 2;
    cout << "Comme je dois partager à part égale avec ma femme, il ne me reste que ";
    cout << monArgent << "..." << endl << endl;
 
    // utilisation de la surcharge sur l'opérateur += de Monnaie
    Monnaie objetMonnaie1(1,1,1), objetMonnaie2(2,13,11);
    // - ajout d'un objet Monnaie à un autre
    cout << objetMonnaie1 << " + " << objetMonnaie2 << " = ";
    objetMonnaie1 += objetMonnaie2;
    cout << objetMonnaie1 << endl;
    // - ajout de 35 pence à un objet Monnaie
    cout << objetMonnaie1 << " + 35 pence = " << objetMonnaie1 + 35 << endl;
 
    return 0;
}

Monnaie.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
#ifndef MONNAIE_H
#define MONNAIE_H
 
#include <iostream>
 
class Monnaie
{
    public:
        Monnaie(int livre = 0, int shilling = 0, int penny = 0);
        ~Monnaie();
        void vaut(int livre = 0, int shilling = 0, int penny = 0);
        Monnaie &operator+=(Monnaie const &autreMonnaie);
        Monnaie &operator+=(int const pennyEnPlus);
        Monnaie &operator/=(double const &diviseur);
        void sortieVersFluxOstream(std::ostream &fluxSortant) const;
 
    private:
        int m_livre, m_shilling, m_penny;
};
 
Monnaie operator+(Monnaie const &monnaie1, Monnaie const &monnaie2);
Monnaie operator+(Monnaie const &monnaie, int const pennyEnPlus);
/*
* À noter que operator+ n'intervient pas sur un objet déjà existant,
* n'appartient pas à l'espace de nom Monnaie,
* et est déclaré en dehors de la classe comme une simple fonction
* de surcharge de operator+ et est basée sur Monnaie::operator+=
* qui elle appartient à la classe Monnaie
*/
 
std::ostream& operator<<(std::ostream &fluxSortant, Monnaie const &monnaie);
 
#endif // MONNAIE_H

Monnaie.cpp

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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
#include "../include/Monnaie.h"
#include <iostream>
 
 
void format(int &livre, int &shilling, int &penny)
/*
* Conversion livre - shilling - penny
* 1 livre = 20 shilling
* 1 shilling = 12 penny
*/
{
    // formatage numérique
    if (penny > 11)
    {
        shilling += penny/12;
        penny %= 12;
    }
    if (shilling > 19)
    {
        livre += shilling/20;
        shilling %= 20;
    }
}
 
Monnaie::Monnaie(int livre, int shilling, int penny) : m_livre(livre), m_shilling(shilling), m_penny(penny)
{
    //constructeur
    format(m_livre, m_shilling, m_penny);
}
 
Monnaie::~Monnaie()
{
    //destructeur vide
}
 
void Monnaie::vaut(int livre, int shilling, int penny)
{
    m_livre = livre;
    m_shilling = shilling;
    m_penny = penny;
    format(m_livre, m_shilling, m_penny);
 
}
 
void Monnaie::sortieVersFluxOstream(std::ostream &fluxSortant) const
{
    // fonction publique ayant accès aux variablesm_livre, m_shilling et m_penny,
    // permettant le passage dans fluxSortant d'une représentation string de l'objet monnaie
    if (m_livre != 0)
    {
        fluxSortant << m_livre << " livre";
        if (m_livre > 1) {fluxSortant << "s";}
        if (m_shilling != 0 || m_penny != 0) {fluxSortant << " ";}
    }
    if (m_shilling != 0)
    {
        fluxSortant << m_shilling << " shilling";
        if (m_shilling > 1) {fluxSortant << "s";}
        if (m_penny != 0) {fluxSortant << " ";}
    }
    if (m_penny != 0)
    {
        fluxSortant << m_penny;
        if (m_penny > 1) {fluxSortant << " pence";}
        else {fluxSortant << " penny";}
    }
}
 
Monnaie& Monnaie::operator+=(Monnaie const &autreMonnaie)
{
    // ajout des valeurs de autreMonnaie
    m_livre += autreMonnaie.m_livre;
    m_shilling += autreMonnaie.m_shilling;
    m_penny += autreMonnaie.m_penny;
    // formatage et retour
    format(m_livre, m_shilling, m_penny);
    return *this;
}
 
Monnaie& Monnaie::operator+=(int const pennyEnPlus)
{
    // ajout des pennyEnPlus
    m_penny += pennyEnPlus;
    // formatage et retour
    format(m_livre, m_shilling, m_penny);
    return *this;
}
 
Monnaie operator+(Monnaie const &monnaie1, Monnaie const &monnaie2)
/*
* operator+ n'intervient pas sur un objet déjà existant et n'appartient pas à l'espace de nom Monnaie
*/
{
    // affectation des valeurs de monnaie1 à une copie
    Monnaie copieMonnaie(monnaie1);
    // ajout des valeurs de monnaie2
    copieMonnaie += monnaie2;
    // retour (formatage effectué par l'opérateur +=)
    return copieMonnaie;
}
 
Monnaie operator+(Monnaie const &monnaie, int const pennyEnPlus)
/*
* operator+ n'intervient pas sur un objet déjà existant et n'appartient pas à l'espace de nom Monnaie
*/
{
    // affectation des valeurs de monnaie1 à une copie
    Monnaie copieMonnaie(monnaie);
    // ajout des valeurs de monnaie2
    copieMonnaie += pennyEnPlus;
    // retour (formatage effectué par l'opérateur +=)
    return copieMonnaie;
}
 
Monnaie& Monnaie::operator/=(double const &diviseur)
{
    // division des valeurs de Monnaie
    m_livre /= diviseur;
    m_shilling /= diviseur;
    m_penny /= diviseur;
    // formatage et retour
    format(m_livre, m_shilling, m_penny);
    return *this;
}
 
std::ostream& operator<<(std::ostream &fluxSortant, Monnaie &monnaie)
/*
* cout est passé en référence dans fluxSortant
* l'objet de type Monnaie est passé en référence dans la variable monnaie
*/
{
    // Passage dans fluxSortant d'une représentation string de l'objet monnaie
    // via la fonction publique sortieVersFluxOstream() qui a accès aux variables
    // m_livre, m_shilling et m_penny
    monnaie.sortieVersFluxOstream(fluxSortant);
    // retour obligatoire d'un flux cf prototype de cette fonction de surcharge d'opérateur
    // pour un objet ostream
    return fluxSortant;
}