surcharger l'opérateur >>

Version imprimable

30/03/2009, 20h34
phenix1988

surcharger l'opérateur >>

salut
comment je peux surcharger l'opérateur >> pour qu'il puisse lire des entiers dans une classe donnée
merci
30/03/2009, 21h11
cynique
Citation:

Envoyé par phenix1988

salut
comment je peux surcharger l'opérateur >> pour qu'il puisse lire des entiers dans une classe donnée
merci
Code:

1 2 3 4 5 6 7 MaClasse &operator >>( MaClasse &source, int &entier ) { // blah blah return source; }
Tu ne dois que remplacer le "// blah blah" avec ton code qui extraire un entier de "source".
30/03/2009, 21h21
Davidbrcz

cynique >> non, ce que tu proposes est faux et ne compile même pas.

Regardez tous les deux la FAQ, ya la réponse dedans
30/03/2009, 22h45
phenix1988

david si tu postes des liens ce sera plus sympa :lol:
30/03/2009, 22h56
Goten

http://cpp.developpez.com/faq/cpp/?p...teur_affichage

(y'a une fonction recherché dans la faq..)
31/03/2009, 17h19
Davidbrcz

Goten, c'est bien pour leurs apprendre à utiliser cette fonction que je ne donne pas le lien.

Il est bien plus bénéfique de chercher par soi même (en sachant que le réponse existe) que de cliquer sur un lien tout donné car ca incite à ne faire aucun efforts de recherche.
31/03/2009, 17h24
Goten

J'ai longuement hésité à le donné... Mais en même temps le fait de tapé operator>> dans un champ de recherche c'est à la portée de tout le monde... et je suis pas sur que ça est un quelconque intérêt pédagogique.
31/03/2009, 20h29
Davidbrcz

Citation:

Envoyé par Goten

J'ai longuement hésité à le donné... Mais en même temps le fait de tapé operator>> dans un champ de recherche c'est à la portée de tout le monde... et je suis pas sur que ça est un quelconque intérêt pédagogique.

Si, car ca force à chercher et ca montre que la proframmation n'est pas un monde où les solutions viennent toutes seules en cliquant sur un lien.

Comment fera t'il quand sa solution sera au fond d'un fil sur clc++ s'il ne prend pas l'habitude de chercher dès maintenant ?

Citation:

Envoyé par Davidbrcz

cynique >> non, ce que tu proposes est faux et ne compile même pas.

Regardez tous les deux la FAQ, ya la réponse dedans

Ca compile:

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
#include <iostream>
using namespace std;
 
class MaClasse{};
 
MaClasse &operator >> ( MaClasse &source, int &entier )
{
  // blah blah
 
  return source;
}
 
MaClasse &operator << ( MaClasse &source, const int &entier )
{
  // blah blah
 
  return source;
}
 
int main () {
 
    MaClasse A;
 
    int b;
 
    A >> b;
    A << b;
 
    return 0;
}

:bug:

Si ca compile c'est car c'est comme surchager l'opérateur virgule et l'opérateur &.
Exemple:
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 #include <iostream> using namespace std; class MaClasse{}; MaClasse &operator >> ( MaClasse &source, int &entier ) { // blah blah return source; } MaClasse &operator << ( MaClasse &source, const int &entier ) { // blah blah return source; } int main () { MaClasse A; int b; A >> b; A << b; return 0; }
Il n'y a aucune différence sémantique avec ton code, sauf que >> est devenu , et que << est devenu &.

Si on fait les choses dans les règles, la FAQ est la marche ca suivre.

31/03/2009, 21h41
cynique
Citation:

Envoyé par Davidbrcz

cynique >> non, ce que tu proposes est faux et ne compile même pas.

Regardez tous les deux la FAQ, ya la réponse dedans

ça dépend. :D Mon code marche pour faire:
Code:

1 2 3 4 5 6 7 MaClasse a(...); int un_entier; int un_autre_entier; a >> un_entier >> un_autre_entier;
Je ne sais pas pourquoi on voudrait faire une telle chose. Peut-être j'ai malcompris la question. C'est possible. :oops:

Et definitivement je ne comprends pas ce que tu dis avec & et , :koi:

Citation:

Envoyé par Davidbrcz

Si ca compile c'est car c'est comme surchager l'opérateur virgule et l'opérateur &.
Exemple:

Est-ce que ça veut dire que ça marche :question:

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
57
58
59
60
61
62
63
#include <iostream>
using namespace std;
 
class MaClasse
{
    public:
        size_t taille_pile;
        int pile[10];
        bool erreur;
 
        MaClasse() : taille_pile(0), erreur(false) {
            ;
        }
        operator bool () {
            return !erreur;
        }
};
 
MaClasse &operator >> ( MaClasse &source, int &entier )
{
    if (source.taille_pile == 0)
    {
        source.erreur = true;
    } else {
        entier = source.pile[source.taille_pile];
        source.taille_pile--;
    }
 
    return source;
}
 
MaClasse &operator << ( MaClasse &source, const int &entier )
{
    if (source.taille_pile == 9)
    {
        source.erreur = true;
    } else {
        source.taille_pile++;
        source.pile[source.taille_pile] = entier;
    }
 
    return source;
}
 
int main () {
 
    MaClasse A;
 
    int b;
 
    if (!(A << 32 << 28  << 0 << 12))
    {
        cout << "Erreur lors du chargement de chiffres" << endl;
        return 1;
    }
 
    while (A >> b)
    {
        cout << "Depilage: " << b << endl;
    }
 
    return 0;
}

31/03/2009, 22h59
Davidbrcz
cynique >> Ce que tu propose est sémantiquement juste (rien n'interdit la compilation après vérification méa culpa) sauf que le modèle canonique est de réserver >> et << pour des flux sur une classe de telle sorte que ta classe soit lisible et que l'on puisse écrire dedans à partir de n'importe quel type de flux, alors que là tu ne la rends opératinel que pour un seul type d'élements.

Il est plus logique de faire
Code:

1 2 3 4 5 std::ostream& operator>>(std::ostream& flx, const Maclasse& m) { flx >> ;//; là je rentre les int et plus si je veux return flx; }
que de faire
Code:

1 2 3 4 5 Maclasse& operator>>(Maclasse& m, int n) { // là je rentre que des int return m; }
car dès que tu va vouloir rentrer un autre type, ca va être très chiant.

Et pour mes histoire de operator & et operator , je voulais juste dire que tu pouvais obtenir la même chose en surchargeant & et, à la place de >> et <<, ce ne sont que des opérateurs et autant essayer de les garders avec la syntaxte naturelle, même si ici ce n'est pas encore trop loin.