C++ - 类模板(class template)友元(friend) 的 全部六种形式 及 代码

类模板(class template)友元(friend) 的 全部六种形式 及 代码

原文地址: http://blog.csdn.net/caroline_wendy/article/details/16916441

 

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

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

主要包含六种形式:

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

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

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

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

5. 模板类 - 友元: 类;

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

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

代码如下:

[cpp]  view plain  copy

1. /* 
2.  * cppprimer.cpp 
3.  * 
4.  *  Created on: 2013.11.24 
5.  *      Author: Caroline 
6.  */  
7.   
8. /*eclipse cdt, gcc 4.8.1*/  
9.   
10. #include <iostream>  
11. #include <string>  
12.   
13. template <typename T> class Pal; //pal朋友  
14.   
15. class C {  
16.     friend class Pal<C>; //"以类C实例化"的Pal类, 为C的友元  
17.     template <typename T> friend class Pal2; //Pal2类的所有实例化, 都为C的友元  
18. private:  
19.     void print() { std::cout << "class C" << std::endl; }  
20. };  
21.   
22. template <typename T>  
23. class C2 {  
24.     friend class Pal<T>; //"与C2类相同实例化"的Pal类, 为C2的友元  
25.     //Pal2类的所有实例化, 都为C2的友元, 注意模板参数(X)不能相同  
26.     template <typename X> friend class Pal2;  
27.     friend class Pal3; //普通友元  
28.     friend T; //C++11 模板类型参数友元  
29. private:  
30.     void print() { std::cout << "class C2" << std::endl; }  
31. };  
32.   
33. template <typename T>  
34. class Pal {  
35.     C myC;  
36.     C2<T> myC2; //必须为T  
37.     //C2<double> myC2; //实例化不同, 无法使用  
38. public:  
39.     void printC() {  
40.         std::cout << "this is class Pal : ";  
41.         myC.print();  
42.     }  
43.     void printC2() {  
44.         std::cout << "this is class Pal : ";  
45.         myC2.print();  
46.     }  
47. };  
48.   
49. template <typename T>  
50. class Pal2 {  
51.     C myC;  
52.     C2<double> myC2;  
53. public:  
54.     void printC() {  
55.         std::cout << "this is class Pal2 : ";  
56.         myC.print();  
57.     }  
58.     void printC2() {  
59.         std::cout << "this is class Pal2 : ";  
60.         myC2.print();  
61.     }  
62. };  
63.   
64. class Pal3 {  
65.     C2<double> myC2;  
66. public:  
67.     void printC2() {  
68.         std::cout << "this is class Pal3 : ";  
69.         myC2.print();  
70.     }  
71. };  
72.   
73. class Pal4 {  
74.     C2<Pal4> myC2; //注意Pal4是C2类的模板参数  
75. public:  
76.     void printC2() {  
77.         std::cout << "this is class Pal4 : ";  
78.         myC2.print();  
79.     }  
80. };  
81.   
82. int main (void) {  
83.   
84.     std::cout << "Hello Mystra!" << std::endl;  
85.   
86.     Pal<C> pc; //Pal类必须实例化为C  
87.     pc.printC(); //可以使用  
88.     //Pal<int> pci;  
89.     //pci.print(); //报错, 访问了私有成员  
90.   
91.     Pal2<int> pi2; //Pal2类可以随意实例化  
92.     pi2.printC();  
93.   
94.     Pal<int> pi; //有相同的示例化, 在类声明C2<T>  
95.     pi.printC2();  
96.   
97.     pi2.printC2(); //注意, Pal2类被实例化为<int>, 内部C2类被实例化为<double>;  
98.   
99.     Pal3 p3;  
100.     p3.printC2();  
101.   
102.     Pal4 p4;  
103.     p4.printC2();  
104.   
105.     return 0;  
106. }  

输出:

[plain]  view plain  copy

1. Hello Mystra!  
2. this is class Pal : class C  
3. this is class Pal2 : class C  
4. this is class Pal : class C2  
5. this is class Pal2 : class C2  
6. this is class Pal3 : class C2  
7. this is class Pal4 : class C2