一、写法与三个特点

class Point {
private:
    int x, y;

public:
    Point(int a = 0, int b = 0) : x(a), y(b) { }

    friend void printPoint(const Point &p);      // ★ 在这一行"点名"
};

// 类外写实现——注意：**不带 `Point::`**
void printPoint(const Point &p) {
    cout << "(" << p.x << ", " << p.y << ")" << endl;   // 能直接读私有成员
}

三个特点：

第二点特别容易反直觉：它明明能读 p.x，却必须先把 p 传进来。因为"能进这扇门"和"知道给谁办事"是两件事——通行证给了你，但你还得自己走进指定的那间房。

二、它的独门本事：一个函数、多个类的朋友

这是友元函数最独特的价值——友元类做不到，成员函数也做不到。

场景：想算"两个点之间的距离"——这个函数同时需要 p1 和 p2 的内部数据。

写法：

class Point {
private:
    int x, y;
public:
    Point(int a = 0, int b = 0) : x(a), y(b) { }
    friend double distance(const Point &a, const Point &b);     // 点名放行
};

double distance(const Point &a, const Point &b) {              // 两个点都传进来
    int dx = a.x - b.x;
    int dy = a.y - b.y;
    return sqrt(dx * dx + dy * dy);                            // 需 <cmath>
}

更关键的用法：一个函数同时是两个类的朋友

class B;                                   // 前向声明

class A {
    friend void bridge(const A &a, const B &b);    // A 放行
private:
    int va;
public:
    A(int v) : va(v) { }
};

class B {
    friend void bridge(const A &a, const B &b);    // ★ B 也放行（两边都写）
private:
    int vb;
public:
    B(int v) : vb(v) { }
};

void bridge(const A &a, const B &b) {      // 它同时看得到 a.va 和 b.vb
    cout << a.va + b.vb << endl;
}

这是友元函数"不可替代"的地方：成员函数永远只能"自己一个类"的视角（要有 this），只有友元函数能同时站在两个类的内部。 这就是为什么运算符重载（如 a + b，两个操作数来自同一个类）和"组合两个对象"的操作几乎都是友元函数。

三、什么时候用它

四、实例04：定义友元函数

目标：写一个 Complex（复数）类，用友元函数实现"两个复数相加"。

为什么不用成员函数？add(a, b) 这个动作属于"两个复数之间"，不属于某一个——用友元函数语义最准，而且两个参数的写法对称（成员函数会写成 a.add(b)，看着不对称）。

#include <iostream>
using namespace std;

class Complex {
private:
    double real;                     // 实部
    double imag;                     // 虚部

public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) { }

    void show(const char *who) const {
        cout << who << " = " << real;
        if (imag >= 0) cout << " + " << imag << "i" << endl;
        else           cout << " - " << -imag << "i" << endl;
    }

    // ★ 实例04：声明两个友元函数
    friend Complex add(const Complex &a, const Complex &b);   // 相加
    friend bool    equal(const Complex &a, const Complex &b); // 相等判断
};

// ── 友元函数实现：不带 Complex::，两个对象都当参数传进来 ──
Complex add(const Complex &a, const Complex &b) {
    return Complex(a.real + b.real, a.imag + b.imag);        // 能直接读私有成员
}

bool equal(const Complex &a, const Complex &b) {
    return (a.real == b.real) && (a.imag == b.imag);
}

int main() {
    Complex x(3, 4);
    Complex y(1, -2);

    x.show("x");
    y.show("y");

    Complex z = add(x, y);
    z.show("x + y");

    cout << "x 等于 y 吗？" << (equal(x, y) ? "是" : "否") << endl;
    cout << "x 等于 x 吗？" << (equal(x, x) ? "是" : "否") << endl;

    // 也能链式套起来用
    Complex w = add(add(x, y), Complex(2, 2));
    w.show("x + y + (2+2i)");
    return 0;
}

看到什么算成功：

x = 3 + 4i
y = 1 - 2i
x + y = 4 + 2i
x 等于 y 吗？否
x 等于 x 吗？是
x + y + (2+2i) = 6 + 4i

读结果四句话：

1. add(x, y) 和 equal(x, y) 都是普通函数的调用样子——不用 x.add(y)，两个参数地位对等。
2. 它们都能直接读 a.real、a.imag——因为被 Complex 点名放行。
3. add 的返回值又可以直接喂给 add（add(add(x, y), Complex(2,2))）——因为返回的是 Complex 对象，能继续参与运算。
4. Complex(2, 2) 这种临时对象可以在调用处直接造出来用——构造函数在起作用（10.2）。

30 秒实验：把两个 friend 声明都注释掉，重新编译。你会看到 add 和 equal 里每一处 a.real、b.imag 都报错（is private within this context）——然后你会面临选择：是加四个 getReal/getImag（开门给所有人），还是加两行 friend（只给这两个函数开门）。这个选择就是友元存在的全部理由。

五、常见误区

1. "友元函数写实现时要加 类名::"——绝对不要。友元函数不是成员，加了 :: 就变成成员函数，友元声明和它对不上。报错通常是"找不到定义"或"参数不匹配"。
2. "友元函数能用 this"——不能。它没有 this（不是成员）。要用哪个对象，就把它当参数传进来。
3. "友元函数必须在第一个朋友类里声明"——不是。每个想放行它的类，各自在自己的类里写一行 friend——两边都写，它才能同时进两扇门。
4. "友元函数比 get/set 差，因为它破坏了封装"——看情况。为了一个外部需求开四个 get（等于公开），比给它一个精确的 friend 更破坏封装。判据还是那句：影响面谁更小？
5. "一个函数只能是"这个类的朋友"，不能也是"那个类的朋友"——可以，而且这正是它的核心价值（第二节的 bridge）。这是成员函数做不到的事。

• ☐ 10.6 命名空间（下一节）

相关笔记

• 友元类 —— 上一节：整个类放行
• 命名空间 —— 下一节：给名字加姓氏，防重名
• 静态类成员 —— 同样"没有 this"的另一类成员
• 使用引用传递参数 —— 友元函数接大对象的标准姿势 const T &
• 函数的定义 —— 友元函数的"本体"就是普通函数
• 🔷 C++基础 · 索引 —— 全课路线图