友元

　　友元主要是为了访问类中的私有成员（包括属性和方法），可以分为友元函数（全局函数），友元类，友元成员函数。

全局函数做友元函数

　　友元函数是可以直接访问类的私有成员。它是定义在类外的普通函数，它不属于任何类，但需要在类的定义中加以声明，声明时在函数名称前加上关键字friend，其格式如下： friend 类型 函数名(形式参数);

　　注意：（1）友元函数声明可以在类中的任何地方，一般放在类定义的开始或结尾；（2） 一个函数可以是多个类的友元函数，只需要在各个类中分别声明；（3）友元函数在类内声明，类外定义，定义和使用时不需加作用域和类名，与普通函数无异。

 1 class Building{
 2     friend void goodGay(Building * building); //goodGay是Building的友元函数，因此goodGay可以访问building的任意成员
 3 public:
 4     Building(){
 5         m_Sittingroom = "客厅";
 6         m_Bedroom = "卧室";
 7     }
 8 
 9     string m_Sittingroom;
10 private:
11     string m_Bedroom;
12 };
13 
14 //和C语言结构体同，传参时尽量不要传递值，尽量传递指针
15 void goodGay(Building * building){
16     cout << "别人在访问" << building->m_Sittingroom << endl;
17     cout << "别人在访问" << building->m_Bedroom << endl; //当不是友元函数时，不能访问私有成员
18 }
19 
20 void test01(){
21     Building building; //或者Building *build = new Building;这里如果定义指针，需要new，否则未初始化
22     goodGay(&building);
23 }

友元类

　　友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。当希望一个类可以存取另一个类的私有成员时，可以将该类声明为另一类的友元类。定义友元类的语句格式如下：  friend class 类名;

　　注意：（1）友元不可继承；（2）友元是单向的，类A是类B的友元类，但类B不一定是类A的；（3）友元不具有传递性，类A是类B的友元类，类B是类C的友元类，但类A不一定是类C的友元类。

 1 class Building{
 2     friend class Person; //Person是Building的友元函数,因此Person可以访问Building的任意成员
 3 public:
 4     Building(){
 5         this->m_Sittingroom = "客厅";
 6         this->m_Bedroom = "卧室";
 7     }
 8 
 9     string m_Sittingroom;
10 private:
11     string m_Bedroom;
12 
13 };
14 
15 class Person{
16 
17 public:
18     void test(Building *building){
19         cout << building->m_Bedroom << endl;
20     }
21 };
22 
23 
24 void test01(){
25     Building *build = new Building;//可以在这里写定义，也可以将定义写在Person的构造函数中
26     Person p;
27     p.test(build);
28 }

友元成员函数

　　使类B中的成员函数成为类A的友元函数，这样类B的该成员函数就可以访问类A的所有成员了。

       当用到友元成员函数时，需注意友元声明和友元定义之间的相互依赖，在该例子中，类Person必须先定义，否则类Building就不能将一个Person的函数指定为友元。然而，只有在定义了类Person之后，才能定义类Person的该成员函数。更一般的讲，必须先定义包含成员函数的类，才能将成员函数设为友元。另一方面，不必预先声明类和非成员函数来将它们设为友元。

 1 //和C语言中结构体的互引用类似，需要先声明一个Building类
 2 class Building;
 3 
 4 class Person{
 5 
 6 public:
 7     void test(Building *building); 
 8     void test1(Building *building);
 9 };
10 
11 class Building{
12     friend void Person::test1(Building *building); //先将Person类定义，类友元成员函数声明后，再使用friend
13 public:
14     Building(){
15         this->m_Sittingroom = "客厅";
16         this->m_Bedroom = "卧室";
17     }
18 
19     string m_Sittingroom;
20 private:
21     string m_Bedroom;
22 
23 };
24 
25 //定义Building类后才能定义Person成员函数
26 void Person::test1(Building *building){
27     cout << building->m_Bedroom << endl; 
28 }
29 
30 void Person::test(Building *building){
31     cout << building->m_Sittingroom << endl;
32 }
33 
34 void test01(){
35     Building *build = new Building;
36     Person p;
37     p.test1(build);
38 }

　　例子中只有test1能访问Building的成员函数，test不能访问。

 

转载于:https://www.cnblogs.com/qinguoyi/p/10254263.html