template<typename type>
struct b {};


template<typename type>
struct d : b<d::inner> 
{
  typedef type inner;
};

template<typename type>
struct b 
{
  typedef typename type::inner inner;
};


template<typename type>
struct d : b<d> 
{
};

template< typename T, typename S> struct test;

template< typename T, typename S = typename test<T,void>::type >
struct test {
   typedef int type;
};

int main () {
   test<int> x;
}

template<class>
class A
{
   friend void fun(const A<char> *);
};

int main()
{
   A<char> * p = 0;
   fun(p);
}

int main()
{
   A<int>a;
   A<char> *p = 0;
   fun(p);
}

int main()
{
   A<char> *p = 0;
   fun(p);
   A<int>a;

}

template <class X>
class C
{
    friend void doSomething(X &);
}

L_L>template<class>
L_L>class A
L_L>{
L_L>   friend void fun(const A<char> *);
L_L>};

L_L>int main()
L_L>{
L_L>   A<char> * p = 0;
L_L>   fun(p);
L_L>}
 
L_L>

L_L>int main()
L_L>{
L_L>   A<int>a;
L_L>   A<char> *p = 0;
L_L>   fun(p);
L_L>}
L_L>

14.6.5/2
[q]
As with non-template classes, the names of namespace-scope friend functions of a class template specialization
are not visible during an ordinary lookup unless explicitly declared at namespace scope (11.4).
Such names may be found under the rules for associated classes (3.4.2).131) [Example:
template<typename T> class number {
public:
number(int);
//...
friend number gcd(const number& x, const number& y);
//...
void g()
{
number<double> a(3), b(4);
//...
a = gcd(a,b); // finds gcd because number<double> is an
// associated class, making gcd visible
// in its namespace (global scope)
b = gcd(3,4); // ill-formed; gcd is not visible
}
 

—end example]
};
[/q]

char foo(...);

int const x = sizeof(foo(char(0)));

int foo(int);

int const y = sizeof(foo(char(0)));

double foo(char);

int const z = sizeof(foo(char(0)));

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

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

t1 x1;
t1 x2;
t1 x3;
t2 x4;
t2 x5;
t2 x6;

К>char foo(...);

К>int const x = sizeof(foo(char(0)));

К>int foo(int);

К>int const y = sizeof(foo(char(0)));

К>double foo(char);

К>int const z = sizeof(foo(char(0)));

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

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

К>t1 x1;
К>t1 x2;
К>t1 x3;
К>t2 x4;
К>t2 x5;
К>t2 x6;

template< typename T, typename S = typename T::type > struct test;
typedef test<int> error;

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();
}

R>>template<typename type>
R>>struct magic
R>>{
R>>    friend int engine(type);
R>>};

PC>template<typename type>
PC>int engine(type);

PC>template<typename type>
PC>struct magic
PC>{
PC>};

template<typename T>
struct magic
{
    typedef typename remove_ref<T>::type type;

    friend int engine(type);
};

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

E>Например, может сломаться на компиляторе, который компилит все шаблоны в одну базу на проект, а потом оттуда их переиспользует, то может и не сработать