C++11 扩展的friend语法

【1】C++98的friend

参见很久以前的随笔《友元》

【2】C++11扩展的friend

直接用代码说明，示例如下：

 1 class Poly;
 2 typedef Poly P; 
 3 
 4 class LiLei 
 5 {
 6     friend class Poly; // C++98通过, C++11通过 
 7 }; 
 8 
 9 class Jim 
10 { 
11     friend Poly;       // C++98失败, C++11通过 
12 };
13 
14 class HanMeiMei 
15 { 
16     friend P;          // C++98失败, C++11通过 
17 };

声明了3个类型：LiLei、Jim和HanMeiMei，它们都有一个友元类型Poly。

主要两点：

[1] 声明一个类为另外一个类的友元时，不再需要使用class关键字

[2] 声明友元类时，甚至可以使用类的别名。

下面，主要分析一下应用变化：

（1）普通类A 的普通类B友元（一对一友好关系）：

无需前置声明class B，当class B第一次出现在friend声明中时，该类名字被隐式地认为可见。

 1 class A
 2 {
 3     friend class B;
 4 
 5     int m_a;
 6 };
 7 
 8 class B
 9 {
10 public:
11     void accessA(A& objA)
12     {
13         cout << objA.m_a << endl;
14     }
15 
16 private:
17     int m_b;
18 };

（2）如果普通类A的友元是一个实例化的特定模板，那么这个具体实例化的类在被声明为友元时，要带具体的类型参数。

正如使用vector一样，如vector<int>，类比等价于friend class B<int>。

但是，与vector<int>相比，编译器（毕竟没有那么智能）在读取class B<int>时会觉得很怪异，不知道这个<int>是什么东西，因此会报错。

为了让编译器认识它，知道它是个实例化的模板，必须在class声明之前先提前告知编译器class B原本是个模板。

而friend声明友元时才表明这只是某一个具体模板的实例化。

 1 template <typename> class B;
 2 
 3 class A
 4 {
 5     friend class B<int>;
 6 
 7     int m_a;
 8 };
 9 
10 template <typename T>
11 class B
12 {
13 public:
14     void accessA(A& objA)
15     {
16         cout << objA.m_a;
17     }
18 };

（3）普通类A的模板类B友元（一对多友好关系）：

这里普通类class A的友元是模板class B，而不是某一个具体实例化的class B<>，即只要是这个模板实例化出来的B都是A的友元。

 1 class A
 2 {
 3     template <typename T> friend class B;
 4 
 5     int m_a;
 6 };
 7 
 8 template <typename T>
 9 class B
10 {
11 public:
12     void accessA(A& objA)
13     {
14         cout << objA.m_a;
15     }
16 };

（4）实例化实例化模板类A的实例化模板类B友元（一对一友好关系）：

与第2类同理，模板类A的友元类B也是一个模板，为了让编译器识别，必须得提前声明其是模板。

另外，class A和class B使用相同模板类型参数，因此在使用相同类型实例化后得到的实例类是对应类型的一对一友好关系。

 1 template <typename> class B;
 2 
 3 template <typename T>
 4 class A
 5 {
 6     friend class B<T>;
 7 
 8     T m_a;
 9 };
10 
11 template <typename U>
12 class B
13 {
14 public:
15     void accessA(A<U>& objA)
16     {
17         cout << objA.m_a;
18     }
19 };

（5）模板类A的实例化模板类B友元（多对一友好关系）：

与第2类同理，这里模板类A的友元类B也是一个模板，为了让编译器识别，必须得提前声明其是模板。

B是一个特定的实例化的模板类，它是任意模板A实例化后的友元。

 1 template <typename> class B;
 2 
 3 template <typename T>
 4 class A
 5 {
 6     friend class B<int>;
 7 
 8     T m_a;
 9 };
10 
11 template <typename U>
12 class B
13 {
14 public:
15     void accessA(A<U>& objA)
16     {
17         cout << objA.m_a;
18     }
19 };

（6）任意实例化模板类A的模板类B友元（多对多友好关系）：

任意一个实例化的A对任意实例化的B都是友好关系。

 1 template <typename T>
 2 class A
 3 {
 4     template <typename X> friend class B;
 5 
 6     T m_a;
 7 };
 8 
 9 template <typename U>
10 class B
11 {
12 public:
13     void accessA(A<U>& objA)
14     {
15         cout << objA.m_a;
16     }
17 };

好像遗漏了一种情况？？

存在模板类A的某一特定实例化对模板类B的任意实例化都是友好关系的场景吗？

回答：不存在。

因为实例化A时，A必然已经定义过了，对于一个定义过了的模板，再去添加模板的友元，这是不符合逻辑的。

good good study, day day up.

顺序选择循环总结