Friend declaration construction

template <typename T1, typename T2>
void combine(T1, T2);
 
class Mixer
{
    friend void combine<>(int, int);
    friend void combine<int, int>(int, int);
    friend void combine<char>(char, int);
 
    // errors
    friend void combine<char>(char&, int);
    friend void combine<>(long, long) {  }
};

void multiply(void*);
 
template <typename T>
void multiply(T);
 
class Pride
{
public:
    friend void multiply(int) { }           /* имя не полное, может быть определением */
    friend void ::multiply(void*);        /* имя полное, ссылается на обычную функцию */
    friend void ::multiply(int);            /* имя полное, ссылается на шаблон функции для типа int */
    friend void ::multiply<double*>(double*); /* также могут быть и угловые скобки */
};

    friend void ::multiply(int);  /* имя полное, ссылается на шаблон функции для типа int */

void multiply(void*);
 
template <typename T>
void multiply(T);
 
class Pride
{
    int p;
public:
    friend void multiply(int) { }
    friend void ::multiply(void*);
    friend void ::multiply(int);
    friend void ::multiply<double*>(double*);
};
 
template <>
void multiply(double*)
{
    Pride pr;
    pr.p = 0; /* тут все нормально */
}
 
template <>
void multiply(int)
{
    Pride pr;
    pr.p = 0; /* а тут ошибка, то есть эта специализация не является дружественной */
}

class A;
 
namespace Foo
{
    template<class T> void foo(A& a, T l, T r);
    void foo(A& a, int l, int r);
}
 
class A
{
    int a;
    friend void Foo::foo<int>(A&, int, int); // Friend declaration 1
    friend void Foo::foo(A&, int, int); // Friend declaration 2
};
 
namespace Foo
{
    template<class T>
    void foo(A& a, T l, T r)
    {
        a.a = l + r;
    }
    void foo(A& a, int l, int r)
    {
        a.a = l + r;
    }
}
 
int main()
{
    A a;
    Foo::foo(a, 1, 2); // Call 1
    Foo::foo<int>(a, 1, 2); // Call 2
}

#include <iostream>
 
class A;
 
namespace Foo
{
    template<class T> void foo(A& a, T l, T r);
}
 
class A
{
    int a;
    friend void Foo::foo(A&, int, int); // По стандарту этот код должен работать, а работает только в студии.
//    friend void Foo::foo<>(A&, int, int); // А работает кросплатформенно только этот.
};
 
namespace Foo
{
    template<>
    void foo<int>(A& a, int l, int r)
    {
        a.a = l + r;
    }
}
 
int main()
{
    A a;
    Foo::foo(a, 1, 2); // Call 1
}

#include <iostream>
 
class A;
 
template<typename T> void f1(A& a, T v);
template<typename T> void f1_1(A& a, T v);
template<typename T> void f3(A& a, T v);
void f2(A& a, int v);
 
class A
{
    int a;
    friend void ::f1<>(A&, int); // первое правило - привязывает к шаблонам
    friend void f1_1<>(A&, int); // также первое правило - привязывает к шаблонам, т.е квалификация не обязательна.
    friend void ::f2(A&, int); // второе правило - привязывает к обычным функциям
    friend void ::f3(A&, int); // третье правило - если (2)-ой вариант не сработал - обязаны попытаться привязать к шаблону. Юзая классическую дедукцию аргументов шаблона.
    friend void f4(A&, int); // четвертое правило - компилятор сам объявит эту функцию.
};
 
template<>
void f1<int>(A& a, int v)
{
    a.a = v;
    std::cout << a.a;
}
 
template<>
void f1_1<int>(A& a, int v)
{
    a.a = v;
    std::cout << a.a;
}
 
void f2(A& a, int v)
{
    a.a = v;
    std::cout << a.a;
}
 
template<>
void f3<int>(A& a, int v)
{
    a.a = v;
    std::cout << a.a;
}
 
void f4(A& a, int v)
{
    a.a = v;
    std::cout << a.a;
}
 
int main()
{
    A a;
    f1(a,10);
    f1_1(a,11);
    f2(a,12);
    f3(a,13);
    f4(a,14);
}