友元与模板类

友元成员函数模板：

#include <iostream>

using namespace std;

template<class T> class A;    //当用到友元成员函数时，需注意友元声明与友元定义之间的互相依赖。这是类A的声明
template<class T>
class B
{
public:
	void set_show(int x, A<T> &a);             //该函数是类A的友元函数
};
template<class T> //A的这个T决定了对于B的T类型友元，并且只友元A<T>类型
class A
{
public:
	friend void B<T>::set_show(int x, A<T> &a);   //该函数是友元成员函数的声明
private:
	int data;
	void show() { cout << data << endl; }
};
template<class T>
void B<T>::set_show(int x, A<T> &a)       //只有在定义类A后才能定义该函数，毕竟，它被设为友元是为了访问类A的成员
{
	a.data = x;
	cout << a.data << endl;
}

int main(void)
{
	class A<int> a;//B的set_show只能访问A<int>类型，只对这个类型友元
	class B<int> b;//B必须是int才能访问a的成员，否则不行

	b.set_show(1, a);
	getchar();
	return 0;
}

类模板(class template)的友元(friend)和普通类的友元, 有很多区别,

主要原因是类模板包含模板参数(template parameter), 就会导致友元和类模板有很多匹配形式;

主要包含六种形式:

1. 类 - 友元(friend): "模板参数是当前类"的类模板;

2. 类 - 友元: "模板参数任意"的模板类;

3. 模板类 - 友元: "模板参数相同"的模板类;

4. 模板类 - 友元: "模板参数任意"的模板类

5. 模板类 - 友元: 类;

6. 模板类 - 友元: 当前模板参数(类); (C++11)

具体使用参见代码及注释,

代码如下:

/*
 * cppprimer.cpp
 *
 *  Created on: 2013.11.24
 *      Author: Caroline
 */

/*eclipse cdt, gcc 4.8.1*/

#include <iostream>
#include <string>

template <typename T> class Pal; //pal朋友

class C {
	friend class Pal<C>; //"以类C实例化"的Pal类, 为C的友元
	template <typename T> friend class Pal2; //Pal2类的所有实例化, 都为C的友元
private:
	void print() { std::cout << "class C" << std::endl; }
};

template <typename T>
class C2 {
	friend class Pal<T>; //"与C2类相同实例化"的Pal类, 为C2的友元
	//Pal2类的所有实例化, 都为C2的友元, 注意模板参数(X)不能相同
	template <typename X> friend class Pal2;
	friend class Pal3; //普通友元
	friend T; //C++11 模板类型参数友元
private:
	void print() { std::cout << "class C2" << std::endl; }
};

template <typename T>
class Pal {
	C myC;
	C2<T> myC2; //必须为T
	//C2<double> myC2; //实例化不同, 无法使用
public:
	void printC() {
		std::cout << "this is class Pal : ";
		myC.print();
	}
	void printC2() {
		std::cout << "this is class Pal : ";
		myC2.print();
	}
};

template <typename T>
class Pal2 {
	C myC;
	C2<double> myC2;
public:
	void printC() {
		std::cout << "this is class Pal2 : ";
		myC.print();
	}
	void printC2() {
		std::cout << "this is class Pal2 : ";
		myC2.print();
	}
};

class Pal3 {
	C2<double> myC2;
public:
	void printC2() {
		std::cout << "this is class Pal3 : ";
		myC2.print();
	}
};

class Pal4 {
	C2<Pal4> myC2; //注意Pal4是C2类的模板参数
public:
	void printC2() {
		std::cout << "this is class Pal4 : ";
		myC2.print();
	}
};

int main (void) {

	std::cout << "Hello Mystra!" << std::endl;

	Pal<C> pc; //Pal类必须实例化为C
	pc.printC(); //可以使用
	//Pal<int> pci;
	//pci.print(); //报错, 访问了私有成员

	Pal2<int> pi2; //Pal2类可以随意实例化
	pi2.printC();

	Pal<int> pi; //有相同的示例化, 在类声明C2<T>
	pi.printC2();

	pi2.printC2(); //注意, Pal2类被实例化为<int>, 内部C2类被实例化为<double>;

	Pal3 p3;
	p3.printC2();

	Pal4 p4;
	p4.printC2();

	return 0;
}