C++ 友元friend

在 C++ 中，一个类中可以有 public、protected、private 三种属性的成员，通过对象可以访问 public 成员，只有本类中的函数可以访问本类的 private 成员。下面就来介绍一种例外情况——友元（friend）。借助友元，可以使得其它类中的成员函数以及全局范围内的函数访问当前类的 private 成员。

一、友元函数

在当前类以外定义的、不属于当前类的函数也可以在类中声明，但要在前面加 friend 关键字，这样就构成了友元函数。友元函数可以是不属于任何类的非成员函数，也可以是其他类的成员函数。

友元函数可以访问当前类中的所有成员，包括 public、protected、private 属性的。

下面直接看例子：

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

/* output
小明的年龄是 15，成绩是 90.6
李磊的年龄是 16，成绩是 80.5
*/

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

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

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

friend 函数不仅可以是全局函数（非成员函数），还可以是另外一个类的成员函数。下面的例子：

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

/* output
小明的年龄是 16，成绩是 95.5
家庭住址：辽宁省大连市金州区
李磊的年龄是 16，成绩是 80.5
家庭住址：四川省成都市金牛区
*/

一个函数可以被多个类声明为友元函数，这样就可以访问多个类中的 private 成员。

二、友元类

不仅可以将一个函数声明为一个类的“朋友”，还可以将整个类声明为另一个类的“朋友”，这就是友元类。友元类中的所有成员函数都是另外一个类的友元函数。

例如将类 B 声明为类 A 的友元类，那么类 B 中的所有成员函数都是类 A 的友元函数，可以访问类 A 的所有成员，包括 public、protected、private 属性的。

更改上例的代码，将 Student 类声明为 Address 类的友元类：

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

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

• 友元的关系是单向的而不是双向的。如果声明了类 B 是类 A 的友元类，不等于类 A 是类 B 的友元类，类 A 中的成员函数不能访问类 B 中的 private 成员。
• 友元的关系不能传递。如果类 B 是类 A 的友元类，类 C 是类 B 的友元类，不等于类 C 是类 A 的友元类。

除非有必要，一般不建议把整个类声明为友元类，而只将某些成员函数声明为友元函数，这样更安全一些。