Discussion :

[soccersoft]

Bonjour,

Je me suis lancé à regarder des cours (livres, tut, faq, vidéos) en C++ , puis j'essaye de pratiquer par moi même via du code que je teste, il y a une notion que je ne comprends pas bien. J'essaye de surcharger l'operator<< pour afficher un objet de type point avec ses coordonnées x,y ! J'ai simplifié le code en retirant la classe fille, je ne m'en sers pas pour cet exemple, d'où le fait que les variables soient en "protected"...pour quand je la réutiliserai... Voilà le code du fichier d'en tête HPP, pas de problème dessus à priori...

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
namespace pt
    {
 
        class point
        {
            public:
                point(int x = 0, int y = 0);
                ~point() {}
                point(point& p);
 
                void disp();
                point operator+(const point& a);
                point operator=(const point& a);
 
                friend std::ostream& operator<<(std::ostream &flux, const point& p);
 
            protected:
                int m_x;
                int m_y;            
        };
 
    }

Voilà ce que je souhaite surcharger dans le CPP :

Code :

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

1
2
3
4
5
6
std::ostream& operator<<(std::ostream &flux, const pt::point& p)
{
    flux << "x : " << p.m_x << " - y : " << p.m_y;
 
    return flux;
}

il me dit que pt::point::m_x et pt::point::m_y sont inaccessibles...par contre, ça marche très bien quand je fais ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
namespace pt
{
     std::ostream& operator<<(std::ostream &flux, const pt::point& p)
     {
          flux << "x : " << p.m_x << " - y : " << p.m_y;
 
          return flux;
     }
}

Mon hypothèse est que j'ai déclaré cette fonction en tant qu'amie dans la classe point pour accéder à ses membres m_x et m_y sous le namespace pt et qu'il faut donc que cette fonction soit aussi dans le namespace pt....mais j'aurais aimé voir si je pouvais mettre des opérateurs de résolution de portée, mais il n'en veut pas...

Code :

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

1
2
3
4
5
6
std::ostream& pt::operator<<(std::ostream &flux, const pt::point& p)
     {
          flux << "x : " << p.m_x << " - y : " << p.m_y;
 
          return flux;
     }

j'ai essayé de mettre des pt:: un peu partout devant ou après les std ou à la place, mais il n'en veut pas, pourtant l'opérateur de portée pt:: devrait me permettre d'éviter de mettre la fonction dans namespace pt {} !???

Fonction amie + namespace + classe + surcharge operateur<< y a plusieurs principes que je ne maîtrise pas quand tout est combiné ensemble...!

Merci.

[foetus]

Je viens de regarder sur les Internets et cela semble complexe Mais ce que je soupçonne, c'est que l'opérateur de résolution de portée (::) ne sert qu'à spécifier 1 ""élément"" déjà défini.
Et donc tu ne peux pas définir 1 ""élément"" avec cet opérateur.

Édit: Namespaces, lien cppreference.com en anglais
Ce n'est pas très clair , mais c'est écrit

Names introduced by friend declarations within a non-local class X become members of the innermost enclosing namespace of X, but they do not become visible to ordinary name lookup (neither unqualified nor qualified) unless a matching declaration is provided at namespace scope, either before or after the class definition. Such name may be found through ADL which considers both namespaces and classes.

Only the innermost enclosing namespace is considered by such friend declaration when deciding whether the name would conflict with a previously declared name.

En gros (si je comprends bien), comme ta fonction amie est dans 1 classe dans 1 espace de noms, il faut que cette fonction amis soit également dans l'espace pour qu'elle soit trouvée lors de la résolution de nom.

Tu peux par contre, sortir 1 ""élément"" de l'espace de noms, en mettant :: devant. En gros, on spécifie l'espace de noms global.
Regarde l'exemple:

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
#include <iostream>
 
#include <cstdlib>
 
 
// Forward Declarations
namespace pt { class Dummy; }
std::ostream& operator<<(std::ostream&, const pt::Dummy&);
 
 
// Namespace + class
namespace pt {
class Dummy
{
public:
 
    Dummy(size_t input_val=726) : val (input_val) {}    
 
public:
 
    friend std::ostream& ::operator<<(std::ostream&, const pt::Dummy&); // here, ::operator<<, not operator<<
 
private:
 
    size_t val;
};
}
 
 
// Friend operator
std::ostream& operator<<(std::ostream& os, const pt::Dummy& d) {
    os << d.val;
 
    return os;
}
 
 
int main()
{
    pt::Dummy d(500);
 
    std::cout<< "test: " << d << std::endl;
 
 
    return EXIT_SUCCESS;
}

[soccersoft]

ok, c'est noté, j'ai finalement décidé de mettre cette fonction dans l'espace de nom dans le HPP...ce qui revient à faire comme ton exemple.