C++ friend关键字

ゞ浴缸里的玫瑰 2023-07-13 15:16 13阅读 0赞

**friend 的意思是朋友，或者说是好友，与好友的关系显然要比一般人亲密一些。我们会对好朋友敞开心扉，倾诉自己的秘密，而对一般人会谨言慎行，潜意识里就自我保护。在 C++ 中，这种友好关系可以用 friend 关键字指明，中文多译为“友元”，借助友元可以访问与其有好友关系的类中的私有成员。如果你对“友元”这个名词不习惯，可以按原文 friend 理解为朋友。**

### 友元函数 ###

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

友元函数可以访问当前类中的所有成员，包括 public、protected、private 属性的。  
1 将非成员函数声明为友元函数。  
示例：

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

运行结果：

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

show() 是一个全局范围内的非成员函数，它不属于任何类，它的作用是输出学生的信息。m\_name、m\_age、m\_score 是 Student 类的 private 成员，原则上不能通过对象访问，但在 show() 函数中又必须使用这些 private 成员，所以将 show() 声明为 Student 类的友元函数。

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

成员函数在调用时会隐式地增加 this 指针，指向调用它的对象，从而使用该对象的成员；而 show() 是非成员函数，必须通过参数传递对象（可以直接传递对象，也可以传递对象指针或对象引用），并在访问成员时指明对象。

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

运行结果：

小明的年龄是 16，成绩是 95.5
    家庭住址：河南省洛阳市宜阳区
    李磊的年龄是 16，成绩是 80.5
    家庭住址：河南省南阳市方城区

本例定义了两个类 Student 和 Address，程序第 27 行将 Student 类的成员函数 show() 声明为 Address 类的友元函数，由此，show() 就可以访问 Address 类的 private 成员变量了。

#### 特别注意： ####

1 . 程序第 4 行对 Address 类进行了提前声明，是因为在 Address 类定义之前、在 Student 类中使用到了它，如果不提前声明，编译器会报错，提示’Address’ has not been declared。类的提前声明和函数的提前声明是一个道理。

2 . 程序将 Student 类的声明和实现分开了，而将 Address 类的声明放在了中间，这是因为编译器从上到下编译代码，show() 函数体中用到了 Address 的成员 province、city、district，如果提前不知道 Address 的具体声明内容，就不能确定 Address 是否拥有该成员（类的声明中指明了类有哪些成员）。

**类的提前声明。一般情况下，类必须在正式声明之后才能使用；但是某些情况下（如上例所示），只要做好提前声明，也可以先使用。**

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

### 友元类 ###

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

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

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

#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 关键字，不过为了增强兼容性还是建议写上。

##### 小提示 #####

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

2 . 友元的关系不能传递。如果类 B 是类 A 的友元类，类 C 是类 B 的友元类，不等于类 C 是类 A 的友元类。