#include <iostream>
using namespace std;

namespace A {
     template <typename T>
     void foo(T*)
     {
       cout << "void foo(T*)\n";
     }
};

class B {
public:

     friend void A::foo<>(B*);
private:
     int b_;
};

int main()
{
  B b;
  foo(&b);

  return 0;
}

t.cpp:15: error: `void A::foo(B*)' should have been declared inside `A'
t.cpp: In function `int main()':
t.cpp:23: error: `foo' undeclared (first use this function)
t.cpp:23: error: (Each undeclared identifier is reported only once for each function it appears in.)

namespace A {
     template <typename T>
     void foo(T*p)
     {
       cout << "void foo(T*)\n";
     }
     
     class B {
     public:

          template<typename T> friend void foo(T*);
     private:
          int b_;
     };
}

int main()
{
  A::B b;
  foo(&b);
}

     template<typename T> friend void A::foo(B*);

template <typename T>
     void foo(T* t)
     {
       cout << t->b_;
     }

#include <iostream>
using namespace std;

namespace A {
     template <typename T>
     void foo(T* val)
     {
       val->b_ = 2;
       cout << val->b_;
     }
};

class B {
public:

     friend void A::foo<>(B*);
private:
     int b_;
};

int main()
{
  B b;
  A::foo(&b);

  return 0;
}

J>     template<typename T> friend void A::foo(B*);
J>

template<typename T> friend void A::foo<T>(B*);

struct B;

namespace A {
    template <typename T>
        void foo(B *) {}
}

struct B {
    template<typename T>
        friend void A::foo(B *);
};

namespace A
{
    template <typename T>
        void foo(T*) {}
}

struct B
{
    template<typename T>
        friend void A::foo(B *);
};

When the declarator-id is qualified, the declaration shall refer to a previously declared member of the class or namespace to which the qualifier refers, and the member shall not have been introduced by a using-declaration in the scope of the class or namespace nominated by the nested-name-specifier of the declarator-id.

If a friend declaration in a non-local class first declares a class or function [footnote 83: this implies that the name of the class or function is unqualified] the friend class or function is a member of the innermost enclosing namespace. The name of the friend is not found by simple name lookup until a matching declaration is provided in that namespace scope (either before or after the class declaration granting friendship). If a friend function is called, its name may be found by the name lookup that considers functions from namespaces and classes associated with the types of the function arguments (3.4.2).

struct X
{
    friend void f(X) {}
    friend void f(int) {}
};

int main()
{
    f(X()); // well-formed: f не находится через unqualified lookup, но находится через ADL
    f(0);   // ill-formed: f не находится ни через unqualified lookup, ни через ADL
}