C++中的友元

友元函数

解决的问题：为了实现普通函数访问该类的私有变量

1)C++中引入友元函数，是为在该类中提供一个对外（除了他自己意外）访问的窗口;
2)这个友元函数他不属于该类的成员函数，他是定义在类外的普通函数，只是在类中声明该函数可以直接访问类中的private或者protected成员。

使用友元函数声明的一般形式：

friend <返回类型> <函数名> (<参数列表>);

使用友元函数时注意的要点：

1，类中通过使用关键字friend 来修饰友元函数，但该函数并不是类的成员函数，其声明可以放在类的私有部分，也可放在共有部分。友元函数的定义在类体外实现，不需要加类限定。

2，一个类中的成员函数可以是另外一个类的友元函数，而且一个函数可以是多个类友元函数。
3，友元函数可以访问类中的私有成员和其他数据，但是访问不可直接使用数据成员，需要通过对对象进行引用。
4，友元函数在调用上同一般函数一样，不必通过对对象进行引用。

#include <iostream>
#include <cstring>
using namespace std;

class persion{
public:
      persion(const char *pn);

      //友元函数;
      friend void setweigth(persion &p,int h);//注意，参数列表中一般会有一个引用类型的形参,原因参考上面的使用要点3和4;
      void disp(); //类成员函数
private:
      char name[20];
      int weigth,age;
};

persion::persion( const char *pn)   //构造函数
{
   strcpy(name,pn);
   weigth=0;
}

void persion::disp()
{
cout<<name<<"--"<<weigth<<endl;
}


//友元函数的具体实现：这里没有类限定例如 (perion::setweigth)这种形式,这里可以与上面的disp()做个对比，一个属于类的成员，有限定，不属于类的成员函数，没有加限定。
void setweigth(persion &pn,int w)
{
//strcpy(pn.name,pn);//实现字符串复制
pn.weigth=w;       //私有成员数据赋值

}

int  main()
{
  persion p("zhansan");
  //调用实现setweigth(),与一般函数调用一致。
  setweigth(p,60);

  p.disp();  //调用类的成员函数。
  return 0;

}

二、友元类

 不仅可以将一个函数声明为一个类的“朋友”，还可以将整个类声明为另一个类的“朋友”，这就是友元类。友元类中的所有成员函数都是另外一个类的友元函数。
例如将类 B 声明为类 A 的友元类，那么类 B 中的所有成员函数都是类 A 的友元函数，可以访问类 A 的所有成员，包括 public、protected、private 属性的。

#include <iostream>
using namespace std;
class Address;  //提前声明Address类
//声明Student类
class Student{
public:
    Student(char *name, int age, float score);
public:
    void show(Address *addr);
private:
    char *m_name;
    int m_age;
    float m_score;
};
//声明Address类
class Address{
public:
    Address(char *province, char *city, char *district);
public:
    //将Student类声明为Address类的友元类
    friend class Student;
private:
    char *m_province;  //省份
    char *m_city;  //城市
    char *m_district;  //区（市区）
};
//实现Student类
Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
void Student::show(Address *addr){
    cout<<m_name<<"的年龄是 "<<m_age<<"，成绩是 "<<m_score<<endl;
    cout<<"家庭住址："<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"区"<<endl;
}
//实现Address类
Address::Address(char *province, char *city, char *district){
    m_province = province;
    m_city = city;
    m_district = district;
}
int main(){
    Student stu("小明", 16, 95.5f);
    Address addr("陕西", "西安", "雁塔");
    stu.show(&addr);
   
    Student *pstu = new Student("李磊", 16, 80.5);
    Address *paddr = new Address("河北", "衡水", "桃城");
    pstu -> show(paddr);
    return 0;
}

第 24 行代码将 Student 类声明为 Address 类的友元类，声明语句为：

friend class Student;

有的编译器也可以不写 class 关键字，不过为了增强兼容性还是建议写上。

⭐关于友元，有两点需要说明：

• 友元的关系是单向的而不是双向的。如果声明了类 B 是类 A 的友元类，不等于类 A 是类 B 的友元类，类 A 中的成员函数不能访问类 B 中的 private 成员。
• 友元的关系不能传递。如果类 B 是类 A 的友元类，类 C 是类 B 的友元类，不等于类 C 是类 A 的友元类。
• 除非有必要，一般不建议把整个类声明为友元类，而只将某些成员函数声明为友元函数，这样更安全一些。

class Building;
 class goodGay {
     public:
          goodGay(); 
          void visit(); //只让visit函数作为Building的好朋友，可以发访问Building中私有内容 
          void visit2();
           private:
          Building *building;
          };
class Building {
     //告诉编译器 goodGay类中的visit成员函数 是Building好朋友，可以访问私有内容 
     friend void goodGay::visit(); 
     public:
          Building();
     public: 
          string m_SittingRoom; //客厅
     private:
               string m_BedRoom;//卧室
        };
        
Building::Building()
 { 
     this->m_SittingRoom = "客厅"; 
     this->m_BedRoom = "卧室"; 
 }
 
 goodGay::goodGay()
  {
       building = new Building;
  }
  
  void goodGay::visit()
   { 
       cout << "好基友正在访问" << building->m_SittingRoom << endl; 
       cout << "好基友正在访问" << building->m_BedRoom << endl; 
   }
   
    void goodGay::visit2()
  {
        cout << "好基友正在访问" << building->m_SittingRoom << endl; 
        //cout << "好基友正在访问" << building->m_BedRoom << endl;
  }
 
void test01() 
{
     goodGay gg;
      gg.visit();
}
 
int main()
{ 
    test01(); 
    return 0; 
}