const int i = some::val;
typedef some::type type;

const int i = some<char, 5>::val;
typedef some<int, 15>::type type;

char engine(...);

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

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

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

// Просто получаем значение счётчика
int i = cnt<>::val;

// Заводим "личный" счётчик
struct my_tag;
int j = cnt<my_tag>::val;

// Генерируем последовательность степеней двойки
struct my_tag2;
enum x
{
  val1 = cnt<my_tag2, pow2gen>::val,
  val2 = cnt<my_tag2, pow2gen>::val,
  val3 = cnt<my_tag2, pow2gen>::val
};

// Создали массив из 3 случайных чисел от 5 до 20 
int data[] = {rnd<5, 20>::val, rnd<5, 20>::val, rnd<5, 20>::val};

struct person
{
    prop<person, int> m1;
    prop<person, char> m2;
    prop<person, std::string> m3;
    prop<person, char> m4;
    prop<person, int> m5;
};

struct person
{
    prop<person, int, 0> m1;
    prop<person, char, 5> m2;
    prop<person, std::string, 8> m3;
    prop<person, char, 40> m4;
    prop<person, int, 44> m5;
};

typedef struct {} _false;
typedef struct {} _true;

char engine( ... );

template<int id = sizeof( engine( _true() ) )>
struct magic
{
    friend int engine(_true);
    static const int val = id;
};

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

class complex
{
  ...
  friend complex operator + (complex, complex);
};

complex c1, c2;
c1 + c2;

IRO>>Будь проще и люди подтянутся

R>А зачем они мне?

error C2065: 'lin_gen' : undeclared identifier

void fun()
{
name;
name;
}

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

C:\tect>g++ -Wall -o "mag" "mag.cpp"
mag.cpp:13: warning: friend declaration `int engine(magicc&, type&)' declares a non-template function
mag.cpp:13: warning: (if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) -Wno-non-template-friend disables this warning
mag.cpp: In function `int main()':
mag.cpp:21: warning: unused variable 'a'

friend int engine(magicc&, type&);

T>Нет обещанного чуда:

   friend int engine(magicc&, type&) { return 0; }

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

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

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

E>За то, что я прав, голосует ещё и то, что даже у M$ не всё так классно. Если бы всё было так, как ты думаешь, то в функции engine вроде как не был бы нужен второй аргумент...

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>>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>>}
NB>

template <class X>
X& make(); // для sizeof сойдет и без тела

. . .

engine(make<magicc>(), make<type>())

template<typename type = int, int id = sizeof( engine( make< magic<type,-1> >() ) ) >
struct magic {
    friend int engine( magic<type,-1> );
    static const int val = id;
};

R>

typedef struct {} _false;
typedef struct {} _true;

char engine( ... );

template<int id = sizeof( engine( _true() ) )>
struct magic
{
    friend int engine(_true);
    static const int val = id; //*
};

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

typedef struct {} _false;
typedef struct {} _true;

char engine( ... );
int  engine(_true);

template<int id = sizeof( engine( _true() ) )>
struct magic
{
    static const int val = id; //*
};

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

R>>

PC>typedef struct {} _false;
PC>typedef struct {} _true;

PC>char engine( ... );

PC>template<int id = sizeof( engine( _true() ) )>
PC>struct magic
PC>{
PC>    friend int engine(_true);
PC>    static const int val = id; //*
PC>};

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

PC>typedef struct {} _false;
PC>typedef struct {} _true;

PC>char engine( ... );
PC>int  engine(_true);

PC>template<int id = sizeof( engine( _true() ) )>
PC>struct magic
PC>{
PC>    static const int val = id; //*
PC>};

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

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

template<typename type = int, int id = sizeof( engine( new magic<type,-1> ) ) >
struct magic {
    friend int engine( magic<type,-1> * );
    static const int val = id;
};

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

template<typename type>
int engine(type);

template<typename type>
struct magic
{
};

"ComeauTest.c", line 9: warning: "int engine(magicc &, type &)" declares a
non-template function -- add <> to refer to a template instance
friend int engine(magicc&, type&);
^

"ComeauTest.c", line 15: error: the size of an array must be greater than zero
char a[magic<>::val != magic<>::val ? 1 : -1];
^

"ComeauTest.c", line 15: warning: variable "a" was declared but never referenced
char a[magic<>::val != magic<>::val ? 1 : -1];
^

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

magicc& get_some_magic();

R>>С такими тезисами обращайся в Философию, там можно такое обсудить на пару сотен постов Или лучше сразу в холивары Покрайней мере к С++ это отношения не имеет.

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>Например, может сломаться на компиляторе, который компилит все шаблоны в одну базу на проект, а потом оттуда их переиспользует, то может и не сработать

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>}