1. 友元类

传统友元类的概念是：让某个类B成为另外一个类A的友元类，这样的话，类B就可以在其成员函数中访问类A的所有成员（成员变量、成员函数），而不管这些成员在类A中是用什么修饰符（private、protected、public）修饰的。如果现在类A和类B都变成了类模板，那么能否让类模板B成为类模板A的友元类模板呢？这要分3种情况讨论。

1．让类模板的某个实例成为友元类

template<typename T>
classA {
private:
    int data;
};

template<typename U>
classB {
public:
    void callBAF(){
        A<int> atmpobj;
        atmpobj.data = 5;
        std::cout << atmpobj.data << std::endl;
    }
};

在main()主函数中添加代码：

B<long>bobj;
bobj.callBAF();

上面这段代码编译后会报错，因为类模板B的callBAF()成员函数要访问类模板A的私有成员变量data，这是不允许的。那么，如果类模板B成为类模板A的朋友，显然就会解决编译出错的问题。于是，调整类模板A的代码，增加一个friend声明，调整后的类模板A的代码如下。

template<typename T>
classA{
    friend classB<long>;//不需要任何public、private等修饰符修饰
private:
    intdata;
};

此外，还需要在类模板A定义的前面增加针对类模板B的声明（如果B不是类模板，而只是一个普通类，就不需要增加针对类B的声明）。

template<typename U> class B; // 类模板B声明

从上面的代码中可以看到，实际是让类模板B的特定类模板实例（也就是B<long>）成为类模板A的友元类。也就是说，B<long>实际上代表的是一个具体的类（如果B不是类模板，而是普通类，就不需要增加针对类B的声明）。

2．让类模板成为友元类模板

前面的代码只是让B<long>成为类模板A的友元类，如果调整main()主函数中的代码B<long>为B<int>，则再次运行会报错。因为B<int>并不是类模板A的友元类，如果把整个类模板B变成类模板A的友元类模板，这个问题就解决了，而且不需要再类模板A定义前增加针对类模板B的声明。

template<typename T>
class A{
    template<typename> friend class B;
public:
    int data;
};

现在，类模板B成立类模板A的友元类模板。

2. 友元函数

函数模板可以被声明为友元函数，首先定义一个普通的函数模板。

template<typename U, typename V>
void func(U val1, V val2) {
    cout << "val1=" << val1 << endl;
    cout << "val2=" << val2 << endl;
}

当要调用func()函数时：

func(2, 3);
func<float>(4.6f, 5)
func<int, float>(4, .8f)

现在，在func()函数模板的前面增加一个Men类的定义：

class Men {
private:
    void funcmen() const {
        cout << "Men::funcmen被调用了" << endl;
    }
};

修改func()函数模板中的代码：

template<typename U, typename V>
void func(U val1, V val2) {
    Men mymen;
    mymen.funcmen(); // func()不是Men类的友元函数，不能访问Men类的私有成员函数
}

1. 让函数模板的某个实例成为友元函数

在main()函数中，func(2, 3)会实例化出void func<int, int>(int, int) {...}。所以把实例化后的func<int, int>函数声明为Men类的友元，在Men类中添加代码：

friend func<int, int>(int, int);

尖括号中的内容叫做模板实参，两个模板实参可以从func()的圆括号指定的实参推导出来，因此尖括号中的内容可以省略，也可以保留一个，但是尖括号不能省略。

同时，在Men类定义的上面添加函数模板func()的声明：

template<typename U, typename V> void func(Uval1, val2);

2. 友元模板

上面的实例中，只是将函数模板func()的某个实例成为Men类模板的友元函数。为了应对不同的情况，可以让函数模板成为Men类模板的友元模板。

方法是在Men类模板的定义中添加代码行：

template<typename U, typename V> friend void fun(U val1, V val2);

如此则不需要在类模板Men定义的前面增加针对函数模板的声明。

3. 在类模板中定义友元函数

可以在一个类模板中定义（不是声明）一个友元函数，这种友元函数是能够被调用的，而且只有在被调用时，编译器才会实例化这个函数。虽然下面的函数func2()的定义写在了Men类模板中，但是应该把它看作一个全局函数，不接受Men类模板的限制。

template<typename z>
class Men {
    friend void func2(Men<z> &tmpmen) {
        tmpmen.funcmen();
    }
    ...
};

在main()函数中添加代码：

Men<double> mymen2;
func2(mymen2);
Men<int> mymen3;
func2(mymen3)

值得一提的是，如果func2()的代码非常简单，编译器会将func2()当作内联函数来处理。

可以看到，虽然func2()是写在了Men类模板的定义中（好处是可以访问类模板中的私有成员），但它的作用域是全局作用域，所以func2()是一个全局函数。