call of overloaded operator<<(truc) is ambiguous

**DEVfan** · 01/05/2007, 18h53

Bonjour,

voilà l'erreur que je reçois et je ne comprends pas pourquoi mon compilateur (DEVC++) n'arrive pas à dissocier ma dernière classe (Cellule_2).

Voici le code pour vous faire voir. Mais avant, j'ai fait un test simple et qui marche :

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
template <class QQ>
class test1
{
 public : QQ a_;
 test1(QQ aa) {a_=aa;}
 QQ a() { return a_;}
 template <class PP> friend std::ostream& operator<<(std::ostream&,const test1<PP>&);
};
class test2
{
 protected : float b_;
 public :
 test2(float aa) {b_=aa;}
 float b() { return b_;}
 friend std::ostream& operator<<(std::ostream&,const test2&);
};
template <class QQ>
class test3 : public test1<QQ>,public test2
{
 public : 
 test3(QQ a,float b) :test1<QQ>(a),test2(b){}
 template <class PP> friend std::ostream& operator<<(std::ostream&,const test3<PP>&);
};

et dans un autre fichier les surchage de flux :

Code :

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

1
2
3
4
5
6
template <class SS> std::ostream& operator<<(std::ostream& Stream,test1<SS>& aa)
    {     return Stream<<"( "<<aa.a()<<" ) ";    }
std::ostream& operator<<(std::ostream& Stream,test2& aa)
    {     return Stream<<"( "<<aa.b()<<" ) ";    }
template <class SS> std::ostream& operator<<(std::ostream& Stream,test3<SS>& aa)
    {     return Stream<<"( "<<aa.a()<<";"<<aa.b()<<" ) ";    }

Donc ça, ça marche!
Et ça : non :

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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
class Coordonnee
{
 protected : 
 
   int coordx;
   int coordy;
 
 public :  
 
   Coordonnee(int x=1,int y=1)
     {
      coordx=x;
      coordy=y;
     }
 
   void coord(int& x,int& y)
     {
      x=coordx;
      y=coordy;
     }
 
   int x()
     {
      return coordx;
     }
 
   int y()
     {
      return coordy;
     }
 
   void change(int x,int y)
     {
      coordx=x;
      coordy=y;
     }
 
   virtual 
   bool appartient(int xmin,int xmax,int ymin,int ymax)
     {
      if(coordx>xmin && coordx<xmax && coordy>ymin && coordy<ymax)
        return true;
      else 
        return false;
     }
 
  friend std::ostream& operator<<(std::ostream&,const Coordonnee&);
  friend std::istream& operator>>(std::istream&,Coordonnee&);
};
 
/////
template <class TT>
class Case : public Coordonnee
{
 public : 
 
   TT valeur; 
 
   Case(int x=1,int y=1, TT value=0):Coordonnee(x,y)
     {
      valeur=value;
     }
   Case(Coordonnee coord, TT value=0):Coordonnee(coord)
     {
      valeur=value;
     }
 
  template<class TT2>
  friend std::ostream& operator<<(std::ostream&,const Case<TT2>&);
 
};
/////
/////
 
template <class VV>
class Case_physic : public Case<VV>
{
 private : 
   VV valmin;
   VV valmax;
 
 public : 
 
   Case_physic(int x=1,int y=1,VV value=0,VV max=65536, VV min=0) : Case<VV>(x,y,value)
     {
      if(min<=max)
        {
         valmin=min;
         valmax=max;
        }
      else
        {
         valmin=max;
         valmax=min;
        }
     }
 
   Case_physic(Case<VV> Caz,VV max=65536,VV min=0) : Case<VV>(Caz)
     {
      if(min<=max)
        {
         valmin=min;
         valmax=max;
        }
      else
        {
         valmin=max;
         valmax=min;
        }
     }
 
   virtual
   VV Min()
     {
      return valmin;
     }
 
   virtual
   VV Max()
     {
      return valmax;
     }
 
  template<class WW2>
  friend std::ostream& operator<<(std::ostream&,const Case_physic<WW2>&);
 
};
 
/////
class Neighb
{
 protected : 
 
   int id_voisinage;
 
 public : 
 
   Neighb(char *vois="8")
     {
      if(strcmp("8",vois)==0) 
        id_voisinage=1;
      else
        if(strcmp("croixplus",vois)==0) 
          id_voisinage=2;
        else
          if(strcmp("croixfois",vois)==0) 
            id_voisinage=3;
          else
            if(strcmp("lig",vois)==0 || strcmp("-",vois)==0) 
              id_voisinage=4;
            else
              if(strcmp("col",vois)==0 || strcmp("|",vois)==0) 
                id_voisinage=5;
              else
                if(strcmp("diag1",vois)==0 || strcmp("\\",vois)==0) 
                  id_voisinage=6;
                else
                  if(strcmp("diag2",vois)==0 || strcmp("//",vois)==0) 
                    id_voisinage=7;
                  else
                    if(strcmp("perso",vois)==0 ) 
                      id_voisinage=8;
                    else
                      id_voisinage=0;
     }//fin Neighb
 
   char *voisinage()
     {
      switch(id_voisinage)
        {
         case 1 : return "8";break;
         case 2 : return "croixplus";break;
         case 3 : return "croixfois";break;
         case 4 : return "lig";break;
         case 5 : return "col";break;
         case 6 : return "diag1";break;
         case 7 : return "diag2";break;
         case 8 : return "perso";break;
         default : return " ";break;
        }
     }//fin voisinage()
 
  friend std::ostream& operator<<(std::ostream&,const Neighb&);
 
};
/////
template <class UU>
class Cellule_2 : public Case_physic<UU> , public Neighb
{
 public : 
 
 Cellule_2(int x=1,int y=1,UU value=0,UU max=65536, UU min=0,char *vois="8")
 :Case_physic<UU>(x,y,value,max,min),Neighb(vois)     {}  
 
 template<class UU2>
   friend std::ostream& operator<<(std::ostream&,const Cellule_2<UU2>&);
};

et pour les flux :

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
//Coordonnee : 
  std::ostream& operator<<(std::ostream& Stream,Iam::Coordonnee& xy)
    {
     Stream<<"( "<<xy.x()<<" ; "<<xy.y()<<" )";
     return Stream;
    }
 
  std::istream& operator>>(std::istream& Stream,Iam::Coordonnee& xy)
    {
     int a,b;
     Stream>>a>>b;
     xy.change(a,b);
     return Stream;
    }
 
//Case : 
  template<typename TT2>
  std::ostream& operator<<(std::ostream& Stream,Case<TT2>& caz)
    {
     return Stream<<"( "<<caz.x()<<" ; "<<caz.y()<<" )"<<" : "<<caz.valeur;
    }
 
//Case_physic : 
  template<typename TT2>
  std::ostream& operator<<(std::ostream& Stream,Case_physic<TT2>& caz)
    {
     return Stream<<"( "<<caz.x()<<" ; "<<caz.y()<<" )"<<" : "<<caz.valeur
     <<endl<<" [ "<<caz.Min()<<" ; "<<caz.Max()<<" ]";
    }
 
//Neighb : 
   std::ostream& operator<<(std::ostream& Stream,Neighb& neib)
    {
     return Stream<<" de voisinage "<<neib.voisinage();
    }
 
//Cellule_2 : 
 template<class UU>
   std::ostream& operator<<(std::ostream& Stream, const Cellule_2<UU>& cell2)
    {
     //Case_physic<UU> caz_phy=(Case_physic<UU>)cell2;
     //Neighb neib=(Neighb)cell2;
     //return Stream<<caz_phy<<neib;
     return Stream<<"voici : ";//<<cell2.x()<<" . "<<cell2.voisinage();
    }

Si vous trouvez où est le pb... j'suis preneur!!!

Merci d'avance.

**DEVfan** · 02/05/2007, 20h51

personne ne comprends ou c'est dans la faq (mais en fait non!!) ?

**Laurent Gomila** · 02/05/2007, 21h10

Disons que si tu pouvais extraire de tout ça seulement ce qui pose problème, ça nous aiderait.

**koala01** · 03/05/2007, 00h17

Salut,

Ainsi que l'a fait remarqué à juste titre Laurent, un code trop (complexe/massif/mal indenté) n'est pas de nature à inciter les gens à se plonger dedans, ce qui rend les candidats à une réponse potentielle tres rares...

Comme, sans doutes, pas mal de mond, je suis déjà passé plusieurs fois sur le sujet, et je n'ai jamais trouvé le courrage de me plonger définitivement dans le code

Cependant, afin de te permettre d'approcher la solution:

Typiquement, le message du compilateur t'explique ce qui ne va pas:

Dans le cas qui nous intéresse, il semblerait qu'il y ai ambiguité lors d'un appel à l'opérateur <<...

Cela signifie tout simplement qu'avec les donnnées dont il dispose le compilateur hésite entre deux manières (ou plus) pour traduire l'opérateur

Donc, pourrais tu essayer de simplifier un peu en nous mettant ce que tu as qui concerne l'opérateur << (et juste assez pour nous permettre de compiler et de reproduire le problème, éventuellement), et nous dire exactement pour quel opérateur le compilateur rechigne

**DEVfan** · 03/05/2007, 22h40

OK :

La classe est :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
template <class UU>
class Cellule_2 : public Case_physic<UU> , public Neighb
{
 public : 
 
 Cellule_2(int x=1,int y=1,UU value=0,UU max=65536, UU min=0,char *vois="8")
 :Case_physic<UU>(x,y,value,max,min),Neighb(vois)     {}  
 
 template<class UU2>
   friend std::ostream& operator<<(std::ostream&,const Cellule_2<UU2>&);
};

autrement dit un héritage de 2 classes précédemment construites et totalement sans erreur. L'une template (Case_physic) et l'autre simple (Neighb). tout est public dans la simple et l'autre possède qq éléments protected et protected

pour le flux :

Code :

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

1
2
3
4
5
 template<class UU>
   std::ostream& operator<<(std::ostream& Stream, const Cellule_2<UU>& cell2)
    {
     return Stream<<"rien ne fonctionne!";
    }

et bien comme pour tous les autres flux...

Pourtant si je fais cout<<cell2; (avec cell2 un objet de classe Cellule_2<int>)... j'obtient cette remarque du compilateur.

C'est suffisamment clair?
... Le pb c'est que j'ai fait pareil en test avec des classes basique et ça marche... alors

**Jean-Marc.Bourguet** · 03/05/2007, 23h14

Donne un exemple complet (on ne doit pas chercher ce qui manque, même si c'est évident...) et minimal (il n'y a rien d'accessoire) reproduisant le problème.

Et en passant donne le message exact et complet du compilateur.

Tu auras alors de meilleures chances d'une réponse...

**DEVfan** · 04/05/2007, 01h06

Ben... à part les #include... j'ai rien de plus et lié 2 pages, je sais très bien faire! (les classiques iostream, string.h, stdio.h,etc.). Y a pas d'autres fcontions pour le moment... si je peux déjà pas vérifier ce qu'il se passe... je fais rien! (le destructeur n'est même pas nécessaire!

)
Dans le main, il vous manque juste ça :

Cellule_2<int> cel2(4,5,50,100,0,"diag");
cout<<cel2;

... cool!!

et savoir que Iam est mon namespace dans ce test.
Le message complet, il ne vous servira pas à grand chose puisque personne ne veut lire mon premier post...où tout est

Ligne Message

In function 'int main(int, char**)'.
35 call of overloaded 'operaor<<(std::ostream&,Iam::Cellule_2<int>&' is ambiguous
note candidates are: std::ostream& operator<<(std::ostream&, Iam::Coordonnee&)
note std::ostream& operator<<(std::ostream&, Iam::Case<VV>&)[withTT2=int]
note std::ostream& operator<<(std::ostream&, Iam::Case_physic<UU>&)[with TT2=int]
note std::ostream& operator<<(std::ostream&, Iam::Neighb&)
note std::ostream& operator<<(std::ostream&, const Iam::Cellule_2<UU>&)[with TT2=int]
note std::ostream& Iam::operator<<(std::ostream&, const Iam::Cellule_2<UU2>&)[with UU=int]
note std::ostream& Iam::operator<<(std::ostream&, const Iam::Case_physic<WW2>&)[with WW2=int]
note std::ostream& Iam::operator<<(std::ostream&, const Iam::Case<TT2>&)[with TT2=int]
note std::ostream& Iam::operator<<(std::ostream&, const Iam::Neighb&)
note std::ostream& Iam::operator<<(std::ostream&, const Iam::Coordonnee&)
[Build Error] [main.o] Error 1

... satisfait!

PS : pour compiler, il vous faudrait tout ce qui est dans le premier post + un fichier nommé TTableau.h qui fait exactement l'équivalent de stl::vector (vous pouvez le remplacer par un type int, ça fait pareil!) + les 2 lignes que je viens de rajouter dans le main + les #include qui vous semblent logiques!

**IrmatDen** · 04/05/2007, 02h51

Es-tu sûr de donner le bon code? Quand je regarde les déclarations et définitions des surcharges de flux, elles ne sont pas pareilles

(présence (pas vraiment) aléatoire du const sur le 2nd paramètre).

**JolyLoic** · 04/05/2007, 09h53

Envoyé par DEVfan

Le message complet, il ne vous servira pas à grand chose puisque personne ne veut lire mon premier post...où tout est

call of overloaded 'operaor<<(std::ostream&,Iam::Cellule_2<int>&' is ambiguous
[...]
note std::ostream& operator<<(std::ostream&, const Iam::Cellule_2<UU>&)[with TT2=int]
note std::ostream& Iam::operator<<(std::ostream&, const Iam::Cellule_2<UU2>&)[with UU=int]
[...]

Il n'y était pas dans le premier post, ce message... Et pourtant il est informatif. Moi non plus, entre ces deux opérateurs, je ne saurais que choisir. Ils correspondent tous deux parfaitement à ton paramètre, mais sont différentiés uniquement par un namespace différent. A mon avis, tu as défini des choses en trop. Enlève l'un de ces opérateurs, et ça devrait mieux aller.

**Jean-Marc.Bourguet** · 04/05/2007, 10h56

Envoyé par DEVfan

Ben... à part les #include... j'ai rien de plus et lié 2 pages, je sais très bien faire! (les classiques iostream, string.h, stdio.h,etc.). Y a pas d'autres fcontions pour le moment... si je peux déjà pas vérifier ce qu'il se passe... je fais rien! (le destructeur n'est même pas nécessaire!

)
Dans le main, il vous manque juste ça :

Cellule_2<int> cel2(4,5,50,100,0,"diag");
cout<<cel2;

... cool!!

et savoir que Iam est mon namespace dans ce test.

Tient, il n'y a rien de plus mais on introduit un namespace (alors que rien jusqu'a present n'indiquait que des namespace etaient presents)...

Le message complet, il ne vous servira pas à grand chose puisque personne ne veut lire mon premier post...où tout est

Non, tout n'est pas puisqu'il n'est pas fait mention de namespace. Et on l'aurait su a lire le message...

Comme Loic, je suppose -- on n'a toujours pas le code -- que tu as importe le namespace lam dans std et donc qu'il n'y a plus moyen de choisir entre la version dans std et la version dans lam.

Comme IrmatDen, je trouve suspect les operator<< ne prenant pas une reference constante pour le deuxieme parametre -- mais je doute que ce soit la source de l'erreur.

... satisfait!

Pas vraiment par ton attitude. Tu aurais donne un code complet et minimal tu aurais peut-etre eu ta solution tout seul en essayant de le batir. Tu aurais donne le message d'erreur complet dans ton premier message, tu aurais eu une piste dans le second...

Pourquoi est-ce que nous devons faire un effort -- et jouer aux devinettes sans avoir aucune chance de deviner correctement puisque je n'aurais jamais introduit un namespace dont il n'avait jamais ete question -- pour simplement reproduire ton probleme? On peut t'aider avec des informations completes, mais tu nous les cache et tu te plains quand on te les demande...

**DEVfan** · 05/05/2007, 00h48

Tout simplement parce que le code transmis est un copié collé de ce que j'implémentais...
Que je ne comprends pas pourquoi le namespace viendrait foutre la grouille puisque toutes les classes précédentes suivent le même schéma et qu'il n'existe qu'une seule déclaration d'operator<< par classe construite. Autrement dit, il n'y a pas 2 fonctions surchargés pour un même type!
... et si je précise le namespace... ça change rien!!

Donc, je n'ai toujours pas de solution!

**JolyLoic** · 05/05/2007, 00h58

Envoyé par DEVfan

il n'existe qu'une seule déclaration d'operator<< par classe construite. Autrement dit, il n'y a pas 2 fonctions surchargés pour un même type!

Ce n'est pas ce que dit ton compilateur, et en l'occurrence, j'ai tendance à lui faire plus confiance qu'à toi. Par contre, sans voir un exemple complet compilable reproduisant la même erreur, je ne peux pas montrer où tu l'as défini deux fois.

Envoyé par DEVfan

... et si je précise le namespace... ça change rien!!

As tu exactement le même message d'erreur ? Comment précises-tu le namespace ? Tu fais bien :

Code :

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

1
2
3
Iam::operator<<(cout, cel2); 
// ou
::operator<<(cout, cel2);

**DEVfan** · 05/05/2007, 01h03

Bon, j'ai réussi à trouver le blem... pas de pb de namespace ni rien, juste qu'il faut du const dans la déclaration de la classe... et pas dans la description... allez-savoir pourquoi!!

**JolyLoic** · 05/05/2007, 01h22

Envoyé par DEVfan

Bon, j'ai réussi à trouver le blem...

J'en suis heureux pour toi, même si j'en doute très fortement.

Envoyé par DEVfan

pas de pb de namespace ni rien,

Pourtant, ton compilo t'en indiquait un. As tu fait le test que je t'ai demandé dans le post précédent ?

Envoyé par DEVfan

juste qu'il faut du const dans la déclaration de la classe... et pas dans la description... allez-savoir pourquoi!!

Si par description, tu veux dire définition, et bien, je t'informe qu'il n'y a aucun cas en C++ où il soit illégal de reporter dans la définition un const qui serait présent dans la déclaration (il y a des cas spéciaux où ce n'est pas obligatoire, mais c'est un autre sujet).

Mon hypothèse sur ton vrai problème (ça reste une hypothèse, vu que tu refuse de nous montrer le code qui pose problème), est la suivante.

Tu as toujours deux fonctions pour l'affichage de tes coordonnées, l'un dans le namespace global, l'autre dans le namespace Iam. La seule différence, c'est comme maintenant tu t'es trompé dans le report de const, ces deux fonctions ont désormais des paramètres différents :

Code :

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

1
2
std::ostream& operator<<(std::ostream&, const Iam::Cellule_2<UU>&)
std::ostream& Iam::operator<<(std::ostream&, Iam::Cellule_2<UU2>&)

Ou

Code :

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

1
2
std::ostream& operator<<(std::ostream&, Iam::Cellule_2<UU>&)
std::ostream& Iam::operator<<(std::ostream&, const Iam::Cellule_2<UU2>&)

Ce qui fait qu'il n'y a plus ambiguïté, le compilo est à même de choisir entre tes deux fonctions. Par contre, comme il y a tout à parier (ça reste un pari, vu que tu refuse de nous montrer le code qui pose problème) que pour de ces deux fonctions déclarées, une seule soit définie, je présume que le code suivant posera problème lors de la phase de lien :

Code :

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

1
2
3
Cellule_2<int> cel1(4,5,50,100,0,"diag");
Cellule_2<int> const cel2(4,5,50,100,0,"diag");
cout<<cel1<<cel2;

**DEVfan** · 05/05/2007, 01h28

Et bien je peux vous assurer que le problème venait des const et pas du namespace. Et qu'il n'existe pas 2 operator<< ou Iam::operator<< puisque je vous ai donné TOUT mon code et oui, vous savez lire ! (hormis un TTableau.h qui ne sert à rien pour comprendre!).

Merci tout de même de vos réponses et DSL d'être sorti de mes gonds pour que des réponses affluent... c'est bien la réponse d'IrmatDen qui m'a mis sur la voie (même s'il en doute!)

**JolyLoic** · 05/05/2007, 03h18

Et je peux t'assurer du contraire. Que tu aies réussi à contourner un problème d'une manière n'indique pas que là était la source du problème.

Tu n'as pas donné tout ton code (tu n'as pas indiqué les namespaces). Tu as 2 opérateurs <<, même si tu ne le sais pas. Tu n'as pas indiqué les résultats des 2 tests que je t'ai suggérés, tu ne tiens pas compte dans tes réponses des arguments que j'ai pu exposer.

Je comprends que tu sois content d'avoir réussi à faire tant bien que mal "tomber en marche" ton code, mais je dis et maintient que tu as un problème qui va ressurgir un jour où l'autre, problème qui pourrait se résoudre avec un peu de collaboration de ta part.

Juste une question, à ton avis, dans le code suivant, j'ai déclaré combien d'opérateurs << ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
namespace toto
{
class A
{
  friend ostream &operator<< (ostream &os, A const &a);
};
}
 
ostream &operator<< (ostream &os, toto::A const &a)
{
};

Indice : Le bonne réponse n'est pas 1.

(Edit : Correction de typos dans le code...)

**DEVfan** · 05/05/2007, 11h43

Bien, je suis plein de bonne volonté et près à tracker le pb... s'il existe

Dans ton cas : 2
->Le premier est une méthode de la classe A (juste défini)
->Le deuxième est une fonction qui utilise la classe A (définition+description)

PS : je me suis inspiré de la FAQ C++ sur les templates... qui possède une rubrique flux.

**Jean-Marc.Bourguet** · 05/05/2007, 12h58

Envoyé par JolyLoic

Par contre, comme il y a tout à parier (ça reste un pari, vu que tu refuse de nous montrer le code qui pose problème) que pour de ces deux fonctions déclarées, une seule soit définie

Elles sont templates, les deux sont vraissemblablement définies lors de la déclaration.

**Jean-Marc.Bourguet** · 05/05/2007, 13h35

Envoyé par DEVfan

Bien, je suis plein de bonne volonté et près à tracker le pb... s'il existe

Dans ton cas : 2
->Le premier est une méthode de la classe A (juste défini)

Où ça?

**DEVfan** · 05/05/2007, 16h15

euh soit je ne comprends pas la dernière remarque, soit il s'agit d'une méprise... je ne réponds pas 2 à "ql est le nb de pb?" mais à "j'ai déclaré combien d'opérateurs << ?"

...ah si , c'est pas vraiment une méthode, OK!

J'ai été voir l'EDIT... ok
J'ai essayé en rajoutant des Iam::operator dans ma description et j'obtient des messages genre :
`std::ostream& Iam::operator<<(std::ostream&, Iam::Coordonnee&)' should have been declared inside `Iam'
...oui je l'ai fait QUE pour ma classe de base qui est Coordonnee.

Version qui tourne :
LE code étant dans la déclaration du namespace Iam et de la classe Coordonnee : (fichier A.h)
friend std::ostream& operator<<(std::ostream&,const Coordonnee&);
Le code utilisant le namespace Iam (et std) : (fichier B.h #incluant à A.h)
std::ostream& operator<<(std::ostream& Stream,Iam::Coordonnee& xy)
{
Stream<<"( "<<xy.x()<<" ; "<<xy.y()<<" )";
return Stream;
}

Version qui tourne plus:
LE code étant dans la déclaration du namespace Iam et de la classe Coordonnee : (fichier A.h)
friend std::ostream& operator<<(std::ostream&,const Coordonnee&);
Le code utilisant le namespace Iam (et std) : (fichier B.h #incluant à A.h)
std::ostream& Iam::operator<<(std::ostream& Stream,Iam::Coordonnee& xy)
{
Stream<<"( "<<xy.x()<<" ; "<<xy.y()<<" )";
return Stream;
}

call of overloaded operator<<(truc) is ambiguous

C++

Discussions similaires

Partager

Partager