A flaw in C++ overload resolution rules?

Question

Consider the following code:

#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 fails with "ambiguous overload error" as per standard.

But why? Surely "equally good" operator in A's 'home' namespace should take precedence? Is there any logical reason not to do it?

Answer 1

If you want the overload in namespace A to be preferred than you'll have to add something to it to make it actually better. Say, by making it not a template:

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

Otherwise, there's really no conceptual reason to see why a function template in one namespace would be preferred to a function template in another namespace if both are exactly equivalent. After all, why would the function template in A's namespace be "better" than the function template in f's namespace? Wouldn't the implementer of f "know better"? Relying solely upon function signature sidesteps this issue.