Ein Fehler in C++ - Überladungsauflösungsregeln?

Question

Betrachten Sie den folgenden Code ein:

#include <iostream> 

namespace ns1 
{ 
    struct A 
    { 
    }; 

    template <class T> 
    std::ostream& operator << (std::ostream& os, const T& t) 
    { 
     return os << "ns1::print" << std::endl; 
    } 
} 

namespace ns2 
{ 
    template <class T> 
    std::ostream& operator << (std::ostream& os, const T& t) 
    { 
     return os << "ns2::print" << std::endl; 
    } 

    void f (const ns1::A& a) 
    { 
     std::cout << a; 
    } 
} 


int main() 
{ 
    ns1::A a; 

    ns2::f (a); 

    return 0; 
} 

Compilation nicht mit "mehrdeutig Überlastung Fehler" gemäß der Norm.

Aber warum? Sicherlich sollte der "gleich gute" Operator im Heimat-Namespace von A Vorrang haben. Gibt es einen logischen Grund, es nicht zu tun?

Answer 1

Wenn Sie die Überladung in namespace A bevorzugen möchten, müssen Sie etwas hinzufügen, um es tatsächlich besser zu machen. Sprich, indem sie sie nicht eine Vorlage machen:

namespace ns1 
{ 
    std::ostream& operator<<(std::ostream&, const A&); 
} 

Ansonsten gibt es wirklich keinen konzeptionellen Grund zu sehen, warum ein Funktions-Template in einem Namensraum zu einer Funktionsvorlage in einem anderen Namensraum bevorzugt werden würde, wenn beide genau gleich sind. Warum sollte die Funktionsvorlage im Namespace von A "besser" sein als die Funktionsvorlage im f Namespace? Würde der Implementierer von f "besser wissen"? Die ausschließliche Verwendung der Funktionssignatur verhindert dieses Problem.

Answer 2

Wenn Sie sorgfältig die Compiler-Fehler zu lesen, sind die Mehrdeutigkeit Fehler nicht zwischen den operator<< Versionen in ns1 und ns2, sondern zwischen der operator<<(os, const char*) Instanziierung von ns1 und die exakt gleichen Überlastung von namespace std. Letzteres wird von ADL unter std::ostream eingezogen.

Der beste Ansatz ist die Empfehlung von @Barry und de-templatize der operator<< im Namensraum ns1, zu verwenden, sondern auch alle Funktionen hinzufügen, um ns1::A (wie f(A)) bezogen in den gleichen Namensraum:

#include <iostream> 

namespace ns1 
{ 
    struct A {}; 

    std::ostream& operator << (std::ostream& os, const A& t) 
    { 
     return os << "ns1::print" << std::endl; 
    } 

    void f (const A& a) 
    { 
     std::cout << a; 
    }  
} 

int main() 
{ 
    ns1::A a; 
    f(a); // rely on ADL to find ns1::operator<<(os, A) 
} 

ns1

Live Example

Namespace dann wirkt, wenn die allgemeine Schnittstelle von class A durch ADL.