LV080-友元函数和友元类

一个类中可以有 public、protected、private 三种属性的成员，通过对象可以访问 public 成员，只有本类中的函数可以访问本类的 private 成员。现在，我们来学习一种例外情况——友元（friend）。借助友元（friend），可以使得其他类中的成员函数以及全局范围内的函数访问当前类的 private 成员。

一、友元函数

1. friend 关键字

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

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

2. 友元函数的参数

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

class student_t {
  private:
    const char *m_name;
    int         m_age;
    float       m_score;

  public:
    student_t(const char *name, int age, float score);

  public:
    friend void show(student_t *pstu); // 将 show()声明为友元函数
};

// 错误写法
void show() {
    cout << pstu->m_name << "的年龄是 " << pstu->m_age << "，成绩是 " << pstu->m_score << endl;
}

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

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

3. 将非成员函数声明为友元函数

直接看下面的示例：

#include <iostream>
using namespace std;

class student_t {
  private:
    const char *m_name;
    int         m_age;
    float       m_score;

  public:
    student_t(const char *name, int age, float score);

  public:
    friend void show(student_t *pstu); // 将 show()声明为友元函数
};

student_t::student_t(const char *name, int age, float score) : m_name(name), m_age(age), m_score(score) {}

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

int main() {
    student_t stu("小明", 15, 90.6);
    show(&stu); // 调用友元函数

    student_t *pstu = new student_t("李磊", 16, 80.5);
    show(pstu); // 调用友元函数

    return 0;
}

show() 是一个全局范围内的非成员函数，它不属于任何类，它的作用是输出学生的信息。m_name、m_age、m_score 是 student_t 类的 private 成员，原则上不能通过对象访问，但在 show() 函数中又必须使用这些 private 成员，所以将 show() 声明为 student_t 类的友元函数。我们可以测试一下，将上面程序中的第 14 行删去，观察编译器的报错信息。

app_demo.cpp: In function ‘void show(student_t*)’:
app_demo.cpp:21:19: error: ‘const char* student_t::m_name’ is private within this context
     cout << pstu->m_name << "的年龄是 " << pstu->m_age << "，成绩是 " << pstu->m_score << endl;
                   ^~~~~~
app_demo.cpp:6:17: note: declared private here
     const char *m_name;
                 ^~~~~~
#......

4. 将其他类的成员函数声明为友元函数

4.1 示例

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

#include <iostream>
using namespace std;

class address_t; // 提前声明 address_t 类

// 声明 student_t 类
class student_t {
  private:
    const char *m_name;
    int         m_age;
    float       m_score;

  public:
    student_t(const char *name, int age, float score);

  public:
    void show(address_t *addr);
};

// 声明 address_t 类
class address_t {
  private:
    const char *m_province; // 省份
    const char *m_city;     // 城市
    const char *m_district; // 区（市区）
  public:
    address_t(const char *province, const char *city, const char *district);
    friend void student_t::show(address_t *addr);// 将 student_t 类中的成员函数 show()声明为友元函数
};

student_t::student_t(const char *name, int age, float score) : m_name(name), m_age(age), m_score(score) {}
void student_t::show(address_t *addr) {
    cout << m_name << "的年龄是 " << m_age << "，成绩是 " << m_score << ", ";
    cout << "家庭住址：" << addr->m_province << "省" << addr->m_city << "市" << addr->m_district << "区" << endl;
}
// 实现 address_t 类
address_t::address_t(const char *province, const char *city, const char *district) {
    m_province = province;
    m_city = city;
    m_district = district;
}

int main() {
    student_t stu("小明", 16, 95.5f);
    address_t addr("陕西", "西安", "雁塔");
    stu.show(&addr);

    student_t *pstu = new student_t("sumu", 16, 80.5);
    address_t *paddr = new address_t("hebei", "hegnshui", "taocheng");
    pstu->show(paddr);
    return 0;
}

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

4.2 注意

（1）address_t 类进行了提前声明，是因为在 address_t 类定义之前、在 student_t 类中使用到了它，如果不提前声明，编译器会报错，提示 'Address' has not been declared。类的提前声明和函数的提前声明是一个道理。

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

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

5. 类的提前声明

一般情况下，类必须在正式声明之后才能使用；但是某些情况下（如上例所示），只要做好提前声明，也可以先使用。但是应当注意，类的提前声明的使用范围是有限的，只有在正式声明一个类以后才能用它去创建对象。如果在上面程序的第 4 行之后增加如下所示的一条语句，编译器就会报错：

address_t addr;  //企图使用不完整的类来创建对象

因为创建对象时要为对象分配内存，在正式声明类之前，编译器无法确定应该为对象分配多大的内存。编译器只有在“见到”类的正式声明后（其实是见到成员变量），才能确定应该为对象预留多大的内存。在对一个类作了提前声明后，可以用该类的名字去定义指向该类型对象的指针变量（本例就定义了 address_t 类的指针变量）或引用变量（后续会学习引用），因为指针变量和引用变量本身的大小是固定的，与它所指向的数据的大小无关。

二、友元类

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

1. 示例

示例代码如下：

#include <iostream>
using namespace std;

class address_t; // 提前声明 address_t 类

// 声明 student_t 类
class student_t {
  private:
    const char *m_name;
    int         m_age;
    float       m_score;

  public:
    student_t(const char *name, int age, float score);

  public:
    void show(address_t *addr);
};

// 声明 address_t 类
class address_t {
  private:
    const char *m_province; // 省份
    const char *m_city;     // 城市
    const char *m_district; // 区（市区）
  public:
    friend class student_t; // 将 student_t 类声明为 address_t 的友元类
  public:
    address_t(const char *province, const char *city, const char *district);
};

student_t::student_t(const char *name, int age, float score) : m_name(name), m_age(age), m_score(score) {}
void student_t::show(address_t *addr) {
    cout << m_name << "的年龄是 " << m_age << "，成绩是 " << m_score << ", ";
    cout << "家庭住址：" << addr->m_province << "省" << addr->m_city << "市" << addr->m_district << "区" << endl;
}
// 实现 address_t 类
address_t::address_t(const char *province, const char *city, const char *district) {
    m_province = province;
    m_city = city;
    m_district = district;
}

int main() {
    student_t stu("小明", 16, 95.5f);
    address_t addr("陕西", "西安", "雁塔");
    stu.show(&addr);

    student_t *pstu = new student_t("sumu", 16, 80.5);
    address_t *paddr = new address_t("hebei", "hegnshui", "taocheng");
    pstu->show(paddr);
    return 0;
}

将 student_t 类声明为 address_t 的友元类可以写成：

friend class student_t;

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

2. 总结

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

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