生活中你的家有客厅(Publick), 有你的卧室(pravite)
    客厅所有人都可以访问的， 卧室是私有的只有自己可以访问。
    但是你也可以允许你自己的（好朋友或闺蜜或发小）进去访问。

    在程序中，有一些私有的属性 也想让类外的一些特殊的函数访问，那么这就需要用到友元技术了

    友元的目的是让一个函数或者类，访问另一个类中的私有成员。

    友元的关键字为：friend

    友元的三种实现：
    1：全局函数做友元。
    2：类做友元。
    3：成员函数做友元。

    若是A为类B的友元函数则A可以访问类B中的私有成员；
    而B类却不能访问A；

    示例： 1第一种情况 全局函数做友元

    1. #include<iostream>
    2. #include<string>
    3. using namespace std;
    4. class Building
    5. {
    6.     friend void test(Building &building);//声明此函数为这个类的友元函数   所以此函数就可以访问这个类的私有成员。 
    7.     public:
    8.     Building()
    9.     {
    10.         parlou="客厅";
    11.         bedroom="卧室"; 
    12.     }
    13.     string parlou;
    14.     private:
    15.     string bedroom;
    16. };
    17. //全局函数 
    18. void test(Building &building)
    19. {
    20.     cout<<"你的好朋友全局函数正在访问你的："<<building.parlou<<endl;
    21.     cout<<"你的好朋友全局函数正在访问你的："<<building.bedroom<<endl;
    22. }
    23. void test0()
    24. {
    25.     Building p;
    26.     test(p);
    27.     return ;
    28. }
    29. int main()
    30. {
    31.     test0();
    32.     return 0; 
    33. }

    2：第二种情况 类做友元：

    1. #include<iostream>
    2. #include<string>
    3. using namespace std;
    4. //class Building;
    5. class Building
    6. {
    7.     friend class Goodbay;
    8.     public:
    9.     string parlou;
    10.     Building();
    11.     private:
    12.     string bedroom;
    13. };
    14. class Goodbay
    15. {
    16.     public:
    17.     Goodbay();
    18.     void visit();
    19.     Building *building;
    20. };
    22. Building::Building()
    23. {
    24.     parlou="客厅";
    25.     bedroom="卧室";
    26. }
    27. Goodbay::Goodbay()
    28. {
    29.     building= new Building;
    30. }
    31. void Goodbay::visit()
    32. {
    33.     cout<<"你的好朋友正在参观 ："<<building->parlou<<endl;
    34.     cout<<"你的好朋友正在参观 ："<<building->bedroom<<endl;
    35. }
    36. void show()
    37. {
    38.     Goodbay p;
    39.     p.visit(); 
    40. }
    42. int main()
    43. {
    44.     show();
    45.     return 0;
    46. }

    3：成员函数做友元：

    1. #include<iostream>
    2. #include<string>
    3. using namespace std;
    4. class Building;
    5. class GoodGay
    6. {
    7.     public:
    8.     GoodGay();
    9.     void visit0();//可以访问building里面的私有成员 。 
    10.     void visit1();//不可以访问building里面的私有成员。 
    11.     Building *building;
    12. };
    13. class Building
    14. {
    15.     //作用是告诉Building这是GoodGay类下的成员函数。 
    16.     friend void GoodGay::visit0();
    17.     public:
    18.     Building();
    19.     string m_parlou;
    20.     private:
    21.     string m_bedroom;
    22. };
    24. Building::Building()
    25. {
    26.     m_parlou="客厅";
    27.     m_bedroom="卧室";
    28. }
    29. GoodGay::GoodGay()
    30. {
    31.     building= new Building;
    32. }
    33. void GoodGay::visit0()
    34. {
    35.     cout<<"零号正在访问你的："<<building->m_parlou<<endl;
    36.     cout<<"壹号正在访问你的："<<building->m_bedroom<<endl; 
    37. }
    38. void GoodGay::visit1()
    39. {
    40.     cout<<"零号正在访问你的："<<building->m_parlou<<endl;
    41. //    cout<<"壹号正在访问你的："<<building->m_bedroom<<endl; 
    42. }
    43. void show ()
    44. {
    45.     GoodGay p;
    46.     p.visit0();
    47.     p.visit1();
    48. } 
    49. int main()
    50. {
    51.     show();
    52.     return 0;
    53. }

    网址1：
    https://www.bilibili.com/video/BV1et411b73Z?p=118
    网址2：
    https://www.bilibili.com/video/BV1et411b73Z?p=119
    网址3：
    https://www.bilibili.com/video/BV1et411b73Z?p=120