C ++模板的行为和运算符重载

Question

I would like to understand the following code behavior

#define USE_FRIEND 

class Foo
{
public:
    template <typename T>
    Foo& operator<< (T val)
    {
        std::cout << "Inside Foo" << std::endl;

        return *this;
    }
};

class A
{
public:

#ifdef USE_FRIEND
    friend Foo& operator<<(Foo& f, A& a)
    {
        std::cout << "Inside A" << std::endl;

        return f;
    }
#endif
};

int main()
{
    A a;

    Foo f;

#ifdef USE_FRIEND
    std::cout << " using Friend :: ";
#else
    std::cout << " not using Friend :: ";
#endif

    f << a;

    system("pause");
    return 0;
}

The output for the above code for 2 executions, one with Using friend and another without:

case 1:

using Friend :: Inside A

case 2:

not using Friend :: Inside Foo

I can understand case 2, but can anyone explain case 1

Answer 1

Overload resolution is complicated business, but here are the two rules that are relevant:

• The overloads that are viable are:

  1. template <typename T> Foo & Foo::operator<<(T)

  2. Foo & operator<<(Foo &, A &)

• When you call operator<<(f, a) , then both overloads match, and they both match on the nose, deducing T = A in the template. There is no difference in exactness, since a reference counts as a "perfect match".

• Thus the two overloads are tied, and the resolution would appear to be ambiguous. However, there is a tie breaker: No 1 is a template and No 2 is not. In this case, the non-template is a better match.