C++友元函数和友元类！

1、友元函数是什么？

首先，得有个比较总体的认识，我个人认为友元函数是一个补丁。

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

但是c++中依旧保留了，独立的函数，也就是不依赖某个class存在（你可以理解为c中的函数），如果此时我们函数需要调用某一个class中定义的变量，这时就无法实现这个功能。所以友元函数或友元类就出现了，专门来打这个补丁。

小结：友元函数即针对访问某一个class中的成员变量和成员函数。

2、友元函数的关键字friend

其中友元函数按照定义或声明的位置来区分，可以分为两种：

（1）：class外定义的函数

（2）：其他类中定义的成员函数

2.1、class外定义的函数在某个class中说明为这个类的友元函数

标题看起来有点拗口，但是却很好的解释了，这个友元函数定义和声明的状态？

闲话少说，直接看代码

#include <iostream>
using namespace std;
class Student{
public:
    Student(char *name, int age, float score); //构造函数
public:
    friend void show(Student *pstu);  //将show()声明为类Student的友元函数
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;
}

友元函数的声明：

shennd void show(Student *pstu); //将show()声明为类Student的友元函数

友元函数的定义：

void show(Student *pstu){

cout<<pstu->m_name<<"的年龄是 "<<pstu->m_age<<"，成绩是 "<<pstu->m_score<<endl;

}

注意看，我标红的地方，即友元函数的形参，是class类型的指针。具体函数的代码中，使用指针和->来调用类中的成员函数或成员变量。

除了上面说的，还有几点需要额外说明

*1）、友元函数，可以声明在任何位置，public，private，protect，而且都不会影响

*2）、如果函数不声明为友元函数，但是形参是class类型的指针，则也可以访问其public成员或函数。

友元函数的调用：

我们在主函数中调用，注意此时的形参，先声明一个实例，然后取这个实1例的地址作为实参，这是因为成员函数在调用时会隐式地增加 this 指针，指向调用它的对象，从而使用该对象的成员；而 show() 是非成员函数，没有 this 指针，编译器不知道使用哪个对象的成员，要想明确这一点，就必须通过参数传递对象（可以直接传递对象，也可以传递对象指针或对象引用），并在访问成员时指明对象。

2.2、 将其他类的成员函数声明为友元函数

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

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

friend void Student::show(Address *addr);

这是在Address中声明Student中的show（）函数为，Address的友元函数

3、友元类

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

注意第6行中，定义一个友元类，结构上简单的多，就是在此class中，+一个声明语句即可" friend class Student;"

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

将代码运行，将得到如下结果：

小明的年龄是 16，成绩是 95.5
家庭住址：陕西省西安市雁塔区
李磊的年龄是 16，成绩是 80.5
家庭住址：河北省衡水市桃城区

这里的核心在于，这一条语句：pstu -> show(paddr); 其中pstu是时Student的实例对象指针，使用->符号，来直接调用show函数。

此时我们跳到show函数中，

void Student::show(Address *addr){

cout<<m_name<<"的年龄是 "<<m_age<<"，成绩是 "<<m_score<<endl;

cout<<"家庭住址："<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"区"<<endl;

我们发现其中地址信息（province，city，district）即省市区这3个变量，其实是Address中定义的类型。而我们又将Student声明为Address的友元类，即Student中所有的函数都是Address中的友元函数。show()函数是Address的友元函数，在show（）函数中，可以访问Address中定义的成员变量。

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

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