template<typename T>
class FriendFake {
    friend void foo( T ) {}
};

R>Пришло время очередного ресёрча

R>char engine(...);

R>template<typename, int> struct magic;
R>typedef magic<char, -1> magicc;

R>template<typename type = int, int id = sizeof(engine(*(magicc*)0, *(type*)0))>
R>struct magic
R>{
R>    friend int engine(magicc&, type&);
R>    static const int val = id;
R>};

R>int main()
R>{
R>    char a[magic<>::val != magic<>::val ? 1 : -1];
R>}
R>

template<typename T>
class FriendHack {
    friend foo( T ) { }  //  разве foo -- шаблонная?
};

void foo( ... ) { cout << "no"; }
template<typename T>wraper { friend foo( T ) { cout << "yes"; }

f1() { foo( 1 ); }
warper<int> q;
f2() { foo( 1 ); }

int main(int, char**)
{
    f1();
    f2();
}

7.3.1.2/3

Every name first declared in a namespace is a member of that namespace. If a friend declaration in a
non-local class first declares a class or function 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). When looking for a prior
declaration of a class or a function declared as a friend, and when the name of the friend class or
function is neither a qualified name nor a template-id, scopes outside the innermost enclosing namespace
scope are not considered. [Example:

// Assume f and g have not yet been defined.
void h(int);
template <class T> void f2(T);
namespace A {
class X {
friend void f(X); // A::f(X) is a friend
class Y {
friend void g(); // A::g is a friend
friend void h(int); // A::h is a friend
// ::h not considered
friend void f2<>(int); // ::f2<>(int) is a friend
};
};
// A::f, A::g and A::h are not visible here
X x;
void g() { f(x); } // definition of A::g
void f(X) { /* ... */} // definition of A::f
void h(int) { /* ... */ } // definition of A::h
// A::f, A::g and A::h are visible here and known to be friends
}

E>template<typename T>
E>class FriendFake {
E>    friend void foo( T ) {}
E>};

E>template<typename T>
E>class FriendFake {
E>    friend void foo( FriendFake<int>, T ) {}
E>};

E>ИМХО поиск и участие таких функций в разрешении неоднозначнойстей при вызове -- нифига в шаблоне не специфицированы и являются особенностью реализации шаблонов в компилятрое

E>>template<typename T>
E>>class FriendFake {
E>>    friend void foo( FriendFake<int>, T ) {}
E>>};
NB>

void foo( FriendFake<int>, FriendFake<float> );

class CFoo {
    friend void foo( int, float );
};

void foo( int, float );

E>>ИМХО поиск и участие таких функций в разрешении неоднозначнойстей при вызове -- нифига в шаблоне не специфицированы и являются особенностью реализации шаблонов в компилятрое

NB>а вот и нет

NB>>>>назови хоть один, который компилит правильно

А>Хех, для начала надо попытаться обосновать, почему это неправильно

template<typename type = int, int id = sizeof(engine(*(magicc*)0, *(type*)0))>
struct magic
{
    friend int engine(magicc&, type&);
    static const int val = id;
};