Discussion :

[aperikub]

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 :

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
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
 
}

[Bousk]

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

[aperikub]

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 :

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
 
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 :

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
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 :

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

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

[foetus]

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

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

Et pour l'implémentation

Code :

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

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;
}

[aperikub]

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

on y trouve aussi beaucoup de conneries...

mais merci d'avoir répondu.

[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.

[foetus]

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

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 la notion friend permet juste d'avoir accès à toute la classe avec 1 surcharge avec 1 fonction libre.

[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.

[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
- 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

[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

-
> des accesseurs pour chaque champ seraient encore mieux

tu veux dire une fonction get_numerateur et une get_denominateur?