C ++ ADL in spazi nomi nidificati con funzione modello

Question

Ho una domanda sulla risoluzione ADL standard in C ++.

Ecco un codice di esempio che spiega la mia richiesta:

#include <string>

// The mechanism:
namespace A {

 template< class C >
 ::std::string scope(const C*)
 { return "A"; }

 namespace B {

  template< class C >
  ::std::string scope(const C *foo)
  { return A::scope(foo)+"::B"; }

 } // namespace B
} // namespace A

::std::string scope(...)
{ return ""; }

// The test classes
struct foo {};
namespace A {
 struct foo {};
 namespace B {
  struct foo {};
 }
}

// The usage
int main()
{
  foo *Foo=0;
  A::foo *FooA=0;
  A::B::foo *FooB=0;

  scope(Foo);  // OK, returns ""
  scope(FooA); // OK, returns "A"
  scope(FooB); // On one compiler, OK returns "A::B" ; On another, compiler error "Ambiguous call" between A::scope() and A::B::scope()
}

Quindi, la mia domanda è qual è lo standard riguardante ADL? Dovrebbero essere trovate tutte le funzioni dagli spazi dei nomi dei genitori dell'argomento, o solo le funzioni disponibili nello spazio dei nomi (nidificato) dell'argomento + le funzioni globali?

Questo programma è stato testato su MSVC 2008 (e compila con SP ma non senza ...)

Answer 1

Secondo lo standard, ADL funziona (modulo un paio di regole speciali) "come se" il nome della funzione è stato preceduto dallo spazio dei nomi; Nella tua ultima riga, la ricerca dovrebbe precedere come se avessi scritto A::B::scope. Che non guarda negli spazi dei nomi circostanti.

Si noti che anche all'interno dello spazio dei nomi A::B, non ci sarebbe ambiguità; inA::B, A::B::scope nasconde A::scope. La ricerca del nome non qualificata si ferma nell'ambito in cui trova per la prima volta il nome.