在 C++ 中，一个类中可以有 public、protected、private 三种属性的成员，通过对象可以访问 public 成员，只有本类中的函数可以访问本类的 private 成员。

借助友元（friend），可以使得其他类中的成员函数以及全局范围内的函数访问当前类的 private 成员。

1. 友元函数: 非成员函数声明¶

在当前类以外定义的、不属于当前类的函数也可以在类中声明，但要在前面加 friend 关键字。这样就构成了友元函数。
友元函数可以是不属于任何类的非成员函数，也可以是其他类的成员函数。
友元函数可以允许访问当前类中的所有成员（通过类的传参），包括 public、protected、private 属性的。
但友元函数的声明必须是公有的，非成员函数必须是全局可被调用的。

#include <iostream>
using namespace std;

class Student{
public:
    Student(char *name, int age, float score);
public:
    friend void show(Student *pstu); //将show()声明为友元函数
private:
    char *m_name;
    int m_age;
    float m_score;
};

//外部非成员函数，构造函数
Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }

//非成员函数
void show(Student *pstu){
    cout<<pstu->m_name<<"的年龄是 "<<pstu->m_age<<"，成绩是 "<<pstu->m_score<<endl;
}

int main(){
    Student stu("小明", 15, 90.6);
    show(&stu); //调用友元函数
    Student *pstu = new Student("李磊", 16, 80.5);
    show(pstu); //调用友元函数

 return 0;
}

2.友元函数：其他类成员函数声明为友元函数¶

前提条件： - 提前声明：在 Address 类定义之前、在 Student 类中使用到了它，如果不提前声明，编译器会报错。

类的提前声明的使用范围是有限的，只有在正式实现一个类以后才能用它去创建对象。编译器只有在“见到”类的正式声明后（其实是见到成员变量），才能确定应该为对象预留多大的内存。 - 友元函数需要指定其他类及其成员函数 ，提供访问途径。 - 友元函数的声明，以及相关成员函数的声明都需要是公有（public）的：目标成员函数需要通过传入类的对象来实现对类私有变量的访问。 - 一个函数可以被多个类声明为友元函数，这样就可以访问多个类中的 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{
private:
 char *m_province; //省份
 char *m_city; //城市
 char *m_district; //区（市区）
public:
 Address(char *province, char *city, char *district);
 //将Student类中的成员函数show()声明为友元函数
 friend void Student::show(Address *addr);
};

//实现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;
}

3. 友元类¶

直接声明一个类作为友元：该类可以随便调用自己的所有成员除非有必要，一般不建议把整个类声明为友元类，而只将某些成员函数声明为友元函数，这样更安全一些。

#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;
}

4. 友元的限制¶

注意，友元函数不同于类的成员函数，在友元函数中不能直接访问类的成员，必须要借助对象。下面的写法是错误的：

 void show(){
 cout<<m_name<<"的年龄是 "<<m_age<<"，成绩是 "<<m_score<<endl;
 }

成员函数在调用时会隐式地增加 this 指针，指向调用它的对象，从而使用该对象的成员；而 show() 是非成员函数，没有 this 指针，编译器不知道使用哪个对象的成员，要想明确这一点，就必须通过参数传递对象（可以直接传递对象，也可以传递对象指针或对象引用），并在访问成员时指明对象。