友元类

友元类

声明友元类:
class class_a
{friend class class_b;
... };

声明位置可以位于公有、私有和保护部分，其所在的位置无关紧要。

友元类(class_b)的所有方法都可以访问原始类(class_a)的私有成员和保护成员。

由于class_b类提到了class_a类，所以编译器必须了解class_a类后，才能处理class_b类，为此，最简单的方法是首先定义class_a类。另一种方法是，使用前向声明(forward declaration)。

友元成员函数

让特定的类成员成为另一个类的友元:
(必须小心排列各种声明和定义的顺序)
class class_a
{friend void class_b::set(class_a & A,int c);
... };

要使编译器能够处理这条语句，它必须知道class_b的定义。这意味着应将class_b的定义放到class_a的定义前面。但class_b的方法提到了class_a对象，而这又意味着class_a定义应当位于class_b定义之前。避开这种循环依赖的方法是，使用前向声明(forward declaration)。为此，需要在class_b定义的前面插入下面的语句:
class class_a; //forward declaration
class class_b {...};
class class_a {...};

假如class_b声明包含了内联代码调用class_a方法:
void show(class_a & A) {A.show();}

由于这将调用class_a的一个方法，所以编译器此时必须已经看到了class_a类的声明，这样才能知道class_a有哪些方法，但class_a的声明现在却位于class_b声明的后面。解决方法是，类中只包含方法声明，并将实际的定义放在class_a类之后:
class class_a; //forward declaration
class class_b {...}; //void show(class_a & A);
class class_a {...};
//put class_b method definitions here
inline void class_b::show(class_a & A){A.show();}
(通过在方法定义中使用inline关键字，仍然可以使其成为内联方法)

内联函数的链接性是内部的，这意味着函数定义必须在使用函数的文件中，或者位于头文件中，并在使用函数的文件中包含该头文件。

其他友好关系

相互友元成员函数，即类class_a的一些方法作为类class_b的友元，同时类class_b的一些方法也作为类class_a的友元。对于使用class_b对象的class_a方法，其原型可在class_b类声明之前声明，但必须在class_b类声明之后定义，以便编译器有足够的信息来编译该方法:

class class_a
{ friend class class_b;
public: void use(class_b & B);
void show()const;
... };

class class_b
{ friend class class_a;
public: void set(class_a & A) {A.show();}
... };

inline void class_a::use(class_b & B) { ... }

由于class_b的声明位于class_a声明的后面，所以可以在类声明中定义class_b::set()，但class_a::use()方法必须在class_a声明的外部定义，使其位于class_b声明的后面。

共同的友元，即当函数需要访问两个类的私有数据时。它可以是一个类的成员，同时是另一个类的友元。不过有时将函数作为两个类的友元更合理:

class class_a; //forward declaration
class class_b
{ friend void sync(class_a & A,const class_b & B); //sync A to B
friend void sync(class_b & B,const class_a & A); //sync B to A
...};

class class_a
{ friend void sync(class_a & A,const class_b & B); //sync A to B
friend void sync(class_b & B,const class_a & A); //sync B to A
...};

// define the friend functions
inline void sync(class_a & A,const class_b & B) {...}
inline void sync(class_b & B,const class_a & A) {...}

(向前声明使编译器看到class_b类声明中的友元声明时，知道class_a是一种类型)