template<typename type>
struct complex
{
//...
friend complex& operator + (complex, complex) {...}
//...
};

complex<int> c1, c2;
complex<int> c3 = c1 + c2;

R>>Аааа... ты про это мне хотел сказать???

L_L>А вообще, так как всем нам, похоже, одинаково некогда/лень ковыряться в стандарте и искать обоснований тех или иных утверждений, лучше подождать авторитетных мнений: Андрея Тарасевича, Павла Кузнецова, elcste (порядок указания имен произвольный ). Можно спросить на comp.lang.c++.moderated.

template<typename type>
struct complex
{
//...
friend complex& operator + (complex, complex) {...}
//...
};

complex<int> c1, c2;
complex<int> c3 = c1 + c2;

char engine(...);

template<typename type>
struct magic_base
{
    friend int engine(magic_base<type>&, type&) {return 0;};
};

template<typename type> type& create();

template<typename type = int, int id = sizeof(engine(create<magic_base<type> >(), create<type>() ))>
struct magic : magic_base<type>
{
    static const int val = id;
};

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

magic<0>::val;
magic<1>::val;
magic<2>::val;

magic<sizeof(...)>::val;
magic<sizeof(...)>::val;
magic<sizeof(...)>::val;

К>// генератор последовательности (любой)
К>template<bla-bla-bla> struct sequence { bla-bla-bla };

К>typedef t1 = sequence<>;
К>typedef t2 = sequence<>;
К>

R>Отвечаю на конкретный вопрос

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

А>>Автор упомянул ЕДГ, но я не понял, что это значит — купить его простым смертным — малореально

R>

char a[(magic<>::val != magic<>::val) && (magic<>::val != magic<>::val) ? 1 : -1]; // negative subscript

#if TEST
template <class _>
void doSomething(_ const &)
{
    std::cout << "doNothing" << std::endl;
}
#endif

template <class>
class Friendly;

template <class T>
Friendly<T>& makeFriendly();

doSomething(makeFriendly<int>()); // ?

template <class T>
class Friendly
{
    . . .

    friend void doSomething(Friendly &);
};

doSomething(makeFriendly<int>()); // ?

template <class T>
Friendly<T>& makeFriendly()
{
    return *new Friendly<T>();
}

template<class>
class A
{
   friend void fun(const A<int> &){}
};

int main()
{
   fun(A<int>());
}

template<class>
class A
{
   friend void fun(const A<int> &){}
};

int main()
{
   A<int>a;
   fun(a);
}

template<typename T> void foo (T,T);

namespace ns {
struct test {};
template<typename T> void foo (T,T);
}

int main () {
   ns::test x;
   foo (x,x);
}

struct X
{
};

struct Y
{
    friend void testy1(X const &)
    {
    }

    friend void testy0()
    {
    }
};

template <class T>
struct Z
{
    friend void testz1(T const &)
    {
    }

    friend void testz0()
    {
    }
};

int main()
{
    X x;

#if INSTANTIATE

               // g++-3.4.2 VC80 g++-4.1.2 Comeau
    testy1(x); //    OK      OK     --       --
    testy0();  //    OK      --     --       --
    testz1(x); //    --      --     --       --
    testz0();  //    --      --     --       --

#else

    Z<X> instantiate; (void)instantiate;

               // g++-3.4.2 VC80 g++-4.1.2 Comeau
    testy1(x); //    OK      OK     --      --
    testy0();  //    OK      --     --      --
    testz1(x); //    OK      OK     --      --
    testz0();  //    OK      --     --      --

#endif
}

When an unqualified name is used as the postfix-expression in a function call (5.2.2), other namespaces not
considered during the usual unqualified lookup (3.4.1) may be searched, and namespace-scope friend function
declarations (11.4) not otherwise visible may be found.

#include <iostream>

namespace ns
{
    class X
    {
    public:

        friend void testxx(X const& x)
        {
            std::cout << "An X: " << &x << std::endl;
        }

        friend void testx()
        {
            std::cout << "Just a test." << std::endl;
        }
    };
}

class Y
{
public:

    friend void testyy(Y const& y)
    {
        std::cout << "A Y: " << &y << std::endl;
    }

    friend void testy()
    {
        std::cout << "Just a test." << std::endl;
    }
};

int main()
{
    ns::X x;
    testxx(x);
 //   ns::testxx(x);

    Y y;
    testyy(y);
 //   ::testyy(x);

 /*   std::cout << (void *)&testy      << std::endl;
    std::cout << (void *)&testyy     << std::endl;
    std::cout << (void *)&ns::testx  << std::endl;
    std::cout << (void *)&ns::testxx << std::endl;

    testy();//здесь нет никаких аргументов == не может найти такое имя.
    ns::testx();*/
}