Friend name injection

Version imprimable

Salut,

Voilà, je lis actuellement C++ template: The complete guide (très bon livre soit dit en passant) et dans cet ouvrage il est question du problème de l'injection des noms lors d'une déclaration d'amitié dans le namespace qui englobe la classe dans laquelle a lieu cette déclaration. Pour voir si j'ai bien compris le problème j'ai donc fait un petit programme qui illustre ce thème :
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 #include <iostream> #ifdef _WIN32 #define __PRETTY_FUNCTION__ __FUNCTION__ #endif void print(); namespace A { class Test { friend void print(); //Injection de print dans A friend void print2(const Test &); //Injection de print2 dans A }; void callPrint() { print(); //Normalement ici A::print n'est pas visible c'est donc ::print qui est appelée print2(Test()); //Ici A::print2 est visible grâce à l'ADL c'est donc A::print2 qui est appelée et l'édition de lien doit échouer puisque A::print2 n'est pas définie } } void print() { std::cout << __PRETTY_FUNCTION__ << std::endl; } void print2(const A::Test &) { std::cout << __PRETTY_FUNCTION__ << std::endl; } int main(void) { A::callPrint(); return 0; }
Le problème c'est qu'avec le compilateur de Visual C++ 2005 j'ai un message à l'édition de lien qui m'indique que A::print n'est pas définie. Ma question est donc : est-ce que je n'ai rien compris ou bien est-ce un "bug" du compilateur de Windows ?

D'avance merci pour vos réponses

Lorsque le compilo fait son boulot,
au niveau de call_print il tombe sur une fonction non définie

==>
a mon avis ca devrais marcher si tu défini comme ca:

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
 namespace A
{
  class Test
  {
    friend void print(); //Injection de print dans A
    friend void print2(const Test &); //Injection de print2 dans A
  };
 
  void print()
   {
     std::cout << __PRETTY_FUNCTION__ << std::endl;
   }
 
   void print2(const A::Test &)
   {
     std::cout << __PRETTY_FUNCTION__ << std::endl;
   } 
 
 
  void callPrint()
  {
    print(); //Normalement ici A::print n'est pas visible c'est donc ::print qui est appelée
    print2(Test()); //Ici A::print2 est visible grâce à l'ADL c'est donc A::print2 qui est appelée et l'édition de lien doit échouer puisque A::print2 n'est pas définie
  }
}

balises [code] ajoutées par r0d

Citation:
Envoyé par loicounet
Lorsque le compilo fait son boulot,
au niveau de call_print il tombe sur une fonction non définie

==>
a mon avis ca devrais marcher si tu défini comme ca:
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 namespace A { class Test { friend void print(); //Injection de print dans A friend void print2(const Test &); //Injection de print2 dans A }; void print() { std::cout << __PRETTY_FUNCTION__ << std::endl; } void print2(const A::Test &) { std::cout << __PRETTY_FUNCTION__ << std::endl; } void callPrint() { print(); //Normalement ici A::print n'est pas visible c'est donc ::print qui est appelée print2(Test()); //Ici A::print2 est visible grâce à l'ADL c'est donc A::print2 qui est appelée et l'édition de lien doit échouer puisque A::print2 n'est pas définie } }
Ben non justement, si j'ai bien compris le truc ton code ne doit pas compiler puisque la fonction A::print injecté par la déclaration friend n'est pas visible pour callPrint. Mais bizarrement ton code compile parfaitement avec Visual C++ 2005. Je réitère donc ma question : est ce moi qui suis à côté de la plaque ou bien le compilateur Windows ?

je viens de lire dans mon bouquin:

Une classe amie doit préalablement etre declaree dans la portee dans laquelle elle se trouve incluse, ou etre definie dans la portee hors classe de premier niveau englobant la classe qui la declare comme amie. par exemple:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class X{/*...*/} //amie de Y namespace N { class Y{ friend class X; friend class Z; friend class AE; }; class Z{...} //amie de Y } class AE{...} //pas amie
===>
Code:

1 2 3 4 5 6 7 8 9 10 11 12 #include <iostream> #ifdef _WIN32 #define __PRETTY_FUNCTION__ __FUNCTION__ #endif void print(); void print2(const A::Test &); //il manquait celle la? namespace A { ...
bon apres faut se poser la question si call_print a bien acces a print()
:
ya pas de notation du style possible?
Code:

1 2 3 4 5 void callPrint() { Test::print(); Test::print2(Test()); }

Salut,

si tu déclarais toutes tes fonctions avant de les définir, tu n'aurais aucun problème ;)

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
#include <iostream>
 
#ifdef _WIN32
#define __PRETTY_FUNCTION__ __FUNCTION__
#endif
 
namespace A
{
    class Test;
}
 
void print();
void print2(const A::Test &);
 
namespace A
{
  class Test
  {
    friend void ::print(); //Injection de print dans A
    friend void ::print2(const Test &); //Injection de print2 dans A
  };
 
  void callPrint()
  {
    print(); //Normalement ici A::print n'est pas visible c'est donc ::print qui est appelée
    print2(Test()); //Ici A::print2 est visible grâce à l'ADL c'est donc A::print2 qui est appelée et l'édition de lien doit échouer puisque A::print2 n'est pas définie
  }
}
 
void print()
{
  std::cout << __PRETTY_FUNCTION__ << std::endl;
}
 
void print2(const A::Test &)
{
  std::cout << __PRETTY_FUNCTION__ << std::endl;
}
 
int main(void)
{
  A::callPrint();
  return 0;
}

Les '::' sont pour dire que print et print2 ne font pas partie du namespace A, mais du namespace global.

Je crois que je ne me suis pas bien fait comprendre. Le code ci-dessous :
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> #ifdef _WIN32 #define __PRETTY_FUNCTION__ __FUNCTION__ #endif void print(); namespace A { class Test { friend void print(); //Injection de print dans A }; void callPrint() { print(); //Normalement ici A::print n'est pas visible c'est donc ::print qui est appelée } } void print() { std::cout << __PRETTY_FUNCTION__ << std::endl; } int main(void) { A::callPrint(); return 0; }
devrait, si j'ai bien compris le principe du friend name injection, compilé. Or avec Visual C++ 2005 ce n'est pas le cas. Le linker se plaint de ne pas trouver la définition de A::print. (Je viens de tester ce code avec gcc 4.3.0 il compile parfaitement mais avec d'autre compilateur ça ne fonctionne pas). J'aimerais donc savoir, si possible, qui a tort et qui a raison.

Salut,

Quand tu fais ça:
Code:

1 2 3 4 5 6 7 namespace A { void callPrint() { print(); //Normalement ici A::print n'est pas visible c'est donc ::print qui est appelée } }
Ca dépend des compilateurs, mais la fonction print n'étant pas déclarée, certains la traitent comme A::print (vu que ni A::print, ni print n'existent encore)

C'est pourquoi ceci:
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> #ifdef _WIN32 #define __PRETTY_FUNCTION__ __FUNCTION__ #endif void print(); namespace A { class Test { friend void print(); //Injection de print dans A }; void callPrint() { ::print(); //Normalement ici A::print n'est pas visible c'est donc ::print qui est appelée } } void print() { std::cout << __PRETTY_FUNCTION__ << std::endl; } int main(void) { A::callPrint(); return 0; }
marche normalement. (sous minGW)
Avec le temps, peut-être que tous les compilateurs auront plus d'intelligence :mrgreen:

Néanmoins, affaire de goût personnel, j'ai préféré déclarer print avant, dans mon post précédent.

Apparement ici, le problème ne vient donc pas du friend mais de la fonction A::CallPrint().

Citation:
Envoyé par coyotte507
Salut,

Quand tu fais ça:
Code:

1 2 3 4 5 6 7 namespace A { void callPrint() { print(); //Normalement ici A::print n'est pas visible c'est donc ::print qui est appelée } }
Ca dépend des compilateurs, mais la fonction print n'étant pas déclarée, certains la traitent comme A::print (vu que ni A::print, ni print n'existent encore)

C'est pourquoi ceci:
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> #ifdef _WIN32 #define __PRETTY_FUNCTION__ __FUNCTION__ #endif void print(); namespace A { class Test { friend void print(); //Injection de print dans A }; void callPrint() { ::print(); //Normalement ici A::print n'est pas visible c'est donc ::print qui est appelée } } void print() { std::cout << __PRETTY_FUNCTION__ << std::endl; } int main(void) { A::callPrint(); return 0; }
marche normalement. (sous minGW)
Avec le temps, peut-être que tous les compilateurs auront plus d'intelligence :mrgreen:

Néanmoins, affaire de goût personnel, j'ai préféré déclarer print avant, dans mon post précédent.

Apparement ici, le problème ne vient donc pas du friend mais de la fonction A::CallPrint().
Normalement, le compilateur ne devrait pas voir A::print et donc sélectionner ::print si bien j'ai bien interprété le standard ... Je trouvais ça étrange qu'un compilateur aussi utilisé que celui de Windows ne respecte pas cette règle. Voilà pourquoi j'ai lancé ce topic je me demandais juste si mon interprétation était erronée ou pas.

25/04/2008, 17h55
coyotte507

Oulala, j'avais zappé la première ligne de code.
print est bien déclaré avant le namespace A et la fonction callPrint.

Effectivement c'est un comportement bizarre pour un compilateur aussi utilisé!