12. 友元

C++提供了另一种形式权限友元：————> 破坏了类的封装性。
友元的目的：让一个函数或者类,访问一个类中私有成员
友元的关键字：friend

1. 友元有三种：友元函数、友元类、友元成员函数。
   友元的三种实现

• 全局函数做友元
• 类做友元
• 成员函数做友元

注：
（1）友元需要在类的内部进行说明，为了与该类的成员函数相区分，再说明时前面加上关键字friend
（2）通过让函数成为类的友元，就可以赋予该成员函数与类成员函数相同的访问权限。
（3）友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的私有成员和保护成员。

2. 友元关系不传递，不对称。友元没有this指针，比成员函数多了一个参数

3. friend <类型><友元函数名>(<参数表>)
   友元函数定义在类的外部，一般与类的成员函数定义放在一起。

1. 全局函数做友元

把全局函数声明到类内，并在前面加上关键字 friend

#include <iostream>
using namespace std;
#include <string>
class Building
{
    // goodfriend 全局函数是 Building 好朋友，可以访问Building 中的私有成员
    friend void goodfriend(Building *building);
public:
    Building() // 构造函数
    {
        m_sittingroom = "客厅";
        m_bedroom = "卧室";
    }
public:    
    string m_sittingroom; //客厅
private:
    string m_bedroom; //卧室 
};

//全局函数
void goodfriend(Building *building)
{
    cout << "好基友全局函数正在访问：" << building -> m_sittingroom <<endl;
    cout << "好基友全局函数正在访问：" << building -> m_bedroom <<endl;
}
void test01()
{
    Building building;
    goodfriend(&building);
}
int main()
{
    test01();
    system("pause");
    return 0;
}

2. 类做友元

 友元类：指类A中的所有成员均可访问类B中的私有成员，需要在类B中声明类A是类B的友元类。

#include <iostream>
using namespace std;
#include <string>
class Building
class Goodfriend
{
public:
    Goodfriend()；
    void visit(); //参观函数，访问Building中的属性 
    Building *building;
};
class Building
{
    friend class Goodfriend; //Goodfriend 是本类的好朋友
public:
    Building(); // 构造函数
public:    
    string m_sittingroom; //客厅
private:
    string m_bedroom; //卧室 
};
//类外写成员函数
Building::Building() //Building域下的构造函数
{
    m_sittingroom="客厅"
    m_bedroom="卧室"
}
Goodfriend::Goodfriend() //Goodfriend域下的构造函数
{
    //创建建筑物对象
    building = new Building ;//在堆区创建
}
void Goodfriend::visit()
{
    cout << "好基友全局函数正在访问：" << building ->m_sittingroom << endl;
    cout << "好基友全局函数正在访问：" << building ->m_bedroom << endl;
}
void test01()
{
    Goodfriend gg;
    gg.visit();
}
int main()
{
    test01();
    system("pause");
    return 0;
}

3. 成员函数做友元

 定义在一个类A中，可以访问另外一个类B的私有成员函数，类A中的成员函数要能访问到类B的私有成员，则需要能够在类B中声明，类A中该成员函数为B的友元

#include <iostream>
using namespace std;
#include <string>
class Building;
class Goodfriend
{
public:
      Goodfriend(); 
      void visit(); //让 visit 函数可以访问 Building 中私有成员
      void visit2(); //让 visit2 函数不可以访问 Building 中私有成员
      Building *building;
};
class Building
{
      friend void Goodfriend::visit();  
      //告诉编译器，Goodfriend类下的visit成员函数作为本类的好朋友，可以访问私有成员。
public:
      Building(); //类外实现；
public:    
    string m_sittingroom; //客厅
private:
    string m_bedroom; //卧室 
};
Building::Building()
{
      m_sittingroom="客厅";
      m_bedroom = "卧室";
}
Goodfriend::Goodfriend()
{
      building = new Building;
      
}
void Goodfriend::visit()
{
    cout << "visit()正在访问：" << building ->m_sittingroom << endl;
    cout << "visit()正在访问：" << building ->m_bedroom << endl;    
}
void Goodfriend::visit2()
{
    cout << "visit()正在访问：" << building ->m_sittingroom << endl;
  //cout << "visit()正在访问：" << building ->m_bedroom << endl;    不可访问
}

int main()
{
      Goodfriend gg;
      gg.visit();
      system("pause");
      return 0;
}