C++ - globaler Namespace-Zugriff von innerhalb eines anderen Namespace

Question

Im folgenden C++ - Code wird foobar zuerst für einen einzelnen double-Parameter und dann wieder für einen einzelnen Parameter vom Typ Foo definiert. Beide sind im globalen Namespace definiert.

Innerhalb des Namensraums one ist eine weitere Überlast von foobar definiert, mit einem einzelnen Parameter vom Typ Bar. Ab dieser Version von foobar schlägt ein unqualifizierter Aufruf an foobar mit einem double Argument (42.0) fehl. Ein ähnlicher Aufruf an foobar, der diesmal mit dem (: :) Scope Resolution Operator, ebenfalls mit einem double Argument, qualifiziert ist, wird jedoch gelingen.

Auf der anderen Seite ist ein unqualifizierter Aufruf von foobar mit einem Argument vom Typ Foo erfolgreich. Ein Aufruf an foobar mit einem Argument Foo, das vom Operator für die Auflösung des Bereichs genehmigt wurde, ist ebenfalls erfolgreich.

Warum verhalten sich die beiden Szenarien unterschiedlich? Ich benutze sowohl gcc 4.7 und clang ++ 3.2.

struct Foo {}; 
struct Bar {}; 

double foobar(double x) { return x; } 
Foo foobar(Foo f) { return f; } 

namespace one { 

    Bar foobar(Bar b) { 
    //foobar(42.0); // error: can't convert to Bar 
    ::foobar(42.0); 

    Foo f; 
     foobar(f); // no problem 
    ::foobar(f); 
    return b; 
    } 
}; 

Answer 1

Argument dependent lookup.

Im Aufruf foobar(f) werden Funktionen aus dem Namensraum Foo berücksichtigt.

Funktioniert nicht für double, da dieser Typ in keinem Namespace deklariert ist.