modification d'operateur de flux

Version imprimable

bonjour à tous,
je suis en train d'apprendre la poo en faisant un programme qui manipule des fractions, je voudrais modifier l’opérateur << pour qu'il affiche les fractions sous la forme a/b sauf que je souhaite rendre privés les attributs numérateur et dénominateur de ma fraction du coup je ne sais pas comment y accéder (enfin j'ai bien quelques idées mais je cherche la "bonne" façon de faire.

voici mon code:

Code:

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
class Fraction
{
public:
    Fraction(int numerateur, int denominateur) noexcept;
    void simplification() noexcept;
    double valeur_reelle() const noexcept;
 
private:
    int m_numerateur;
    int m_denominateur;
 
};
 
//constructeur:
Fraction::Fraction(int numerateur, int denominateur) noexcept
    : m_numerateur(numerateur), m_denominateur(denominateur)
{
    assert(m_denominateur != 0, "le denominateur ne peut pas valoir 0");
}
 
void Fraction::simplification() noexcept
{
    m_numerateur /= std::gcd(m_numerateur, m_denominateur);
    m_denominateur /= std::gcd(m_numerateur, m_denominateur);
 
}
 
double Fraction::valeur_reelle() const noexcept
{
    return double(m_numerateur) / m_denominateur;
}
 
std::ostream& operator <<(std::ostream flux, Fraction f)
{
    return flux << f.m_numerateur << '/' << f.m_denominateur; // c'est la que ça bloque
}
 
int main()
{
   //mon main
 
}

26/07/2020, 15h55
Bousk

:faq:
https://cpp.developpez.com/faq/cpp/?...eurs-mutateurs
https://cpp.developpez.com/faq/cpp/?...eurs-mutateurs

ok du coup si j'ai bien compris ma fonction simplification est un mutateur? par contre je bloque toujours, je ne vois pas comment renvoyer mes deux int sous une forme qui me permet de les utiliser dans mon modificateur de flux.

j'ai essayé avec un std::pair :

Code:

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
 
class Fraction
{
public:
    Fraction(int numerateur, int denominateur) noexcept;
    std::pair<int, int> get_fraction();
    void simplification() noexcept;
    double valeur_reelle() const noexcept;
 
private:
    int m_numerateur;
    int m_denominateur;
 
};
 
//constructeur:
Fraction::Fraction(int numerateur, int denominateur) noexcept
    : m_numerateur(numerateur), m_denominateur(denominateur)
{
    assert(m_denominateur != 0, "le denominateur ne peut pas valoir 0");
}
std::pair<int, int> Fraction::get_fraction()
{
    std::pair<int, int> fraction{ m_numerateur, m_denominateur };
    return fraction;
}
 
void Fraction::simplification() noexcept
{
    m_numerateur /= std::gcd(m_numerateur, m_denominateur);
    m_denominateur /= std::gcd(m_numerateur, m_denominateur);
 
}
 
double Fraction::valeur_reelle() const noexcept
{
    return double(m_numerateur) / m_denominateur;
}
 
std::ostream& operator <<(std::ostream flux, Fraction f)
{
    return flux << f.get_fraction().first << '/' << f.get_fraction().second;
}
 
int main()
{
    SetConsoleOutputCP(CP_UTF8);
    Fraction const f{ 4, 10 };
    std::cout << f;
 
}

j'ai essayé en créant une structure dans la classe (en gros j'ai tourné en rond):

Code:

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
class Fraction
{
public:
    Fraction(int numerateur, int denominateur) noexcept;
    struct frac
    {
        int numerateur;
        int denominateur;
    };
 
    frac get_fraction();
    void simplification() noexcept;
    double valeur_reelle() const noexcept;
 
private:
    int m_numerateur;
    int m_denominateur;
 
};
 
//constructeur:
Fraction::Fraction(int numerateur, int denominateur) noexcept
    : m_numerateur(numerateur), m_denominateur(denominateur)
{
    assert(m_denominateur != 0, "le denominateur ne peut pas valoir 0");
}
Fraction::frac Fraction::get_fraction()
{
    frac fraction{ m_numerateur, m_denominateur };
    return fraction;
}
 
void Fraction::simplification() noexcept
{
    m_numerateur /= std::gcd(m_numerateur, m_denominateur);
    m_denominateur /= std::gcd(m_numerateur, m_denominateur);
 
}
 
double Fraction::valeur_reelle() const noexcept
{
    return double(m_numerateur) / m_denominateur;
}
 
std::ostream& operator <<(std::ostream flux, Fraction f)
{
    return flux << f.get_fraction().numerateur << '/' << f.get_fraction().denominateur;
}
 
int main()
{
    SetConsoleOutputCP(CP_UTF8);
    Fraction const f{ 4, 10 };
    std::cout << f;
 
}

et j'ai toujours la même erreur:

Code:

1
2
 
Erreur (active)	E1776	impossible de faire référence à fonction "std::basic_ostream<_Elem, _Traits>::basic_ostream(const std::basic_ostream<_Elem, _Traits> &) [avec _Elem=char, _Traits=std::char_traits<char>]" (déclaré à la ligne 60 de "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.26.28801\include\ostream") -- fonction supprimée	projet poo 2	C:\Users\aperi\source\repos\projet poo 2\main.cpp	64

26/07/2020, 19h53
foetus
Vas-y fais 1 effort, la surcharge de l'opérateur de flux << se trouve facilement sur internet :calim2: :weird: :koi:

Dans ta classe, il faut mettre friend std::ostream& operator<<(std::ostream&, const Fraction&); (<- note friend, & et const &)

Et pour l'implémentation
Code:

1 2 3 4 5 std::ostream& operator <<(std::ostream& os, const Fraction& f) { os << f.get_fraction().numerateur << '/' << f.get_fraction().denominateur; return os; }
26/07/2020, 20h25
aperikub

Citation:

Envoyé par foetus

Vas-y fais 1 effort, la surcharge de l'opérateur de flux << se trouve facilement sur internet :calim2: :weird: :koi:

on y trouve aussi beaucoup de conneries...

mais merci d'avoir répondu.
26/07/2020, 20h33
jo_link_noir

friend n'est utilisable que si le prototype est déclaré dans la classe, ce n'est pas le cas ici. En réalité, on utilise cette façon essentiellement pour accéder aux champs privés car friend autorise la fonction à y accéder.

get_fraction devrait être const.
26/07/2020, 20h59
foetus

Citation:

Envoyé par jo_link_noir

En réalité, on utilise cette façon essentiellement pour accéder aux champs privés car friend autorise la fonction à y accéder.

:mrgreen: pour les opérateurs, friend ~~contrairement à 1 méthode, sert à ne pas fixer l'ordre des paramètres et pouvoir les intervertir ... et pour le flux, les chaîner.~~

Édit : Effectivement, j'ai dit n'importe quoi :oops: la notion friend permet juste d'avoir accès à toute la classe avec 1 surcharge avec 1 fonction libre.
26/07/2020, 23h13
jo_link_noir

Ça ne change pas qu'une fonction libre fait tout aussi bien l'affaire sans avoir besoin de la mettre en amie. Pas de raison de l'utiliser.
27/07/2020, 05h44
Bousk

- la surcharge de << est couverte dans la faq
- ajouter des accesseurs/getters sur les champs est ici préférable imo
> vouloir connaître le numérateur ou dénominateur d'une fraction ne me parait pas être aberrant de toute façon
> friend devient donc superflu et n'a aucun intérêt
- le chaînage est assuré par le fait que qu'elle retourne le flux et l'interface de la std oblige à ce que ce soit une fonction libre, friend n'a rien à voir ici :weird:
- get_fraction doit être const
- une pair suffit, ta structure interne est superflue
> les champs d'une pair sont first & second
> des accesseurs pour chaque champ seraient encore mieux
- le flux en paramètre d'un opérateur << est une référence
27/07/2020, 14h36
aperikub

effectivement pas besoin de friend (je me coucherais quand même moins con ce soir) j'avais oublié de mettre les paramètres de la surcharge en référence :?

Citation:

Envoyé par Bousk

-
> des accesseurs pour chaque champ seraient encore mieux

tu veux dire une fonction get_numerateur et une get_denominateur?