Lesson 0304 · 运算符重载与友元

③ 面向对象程序设计 — 第 4 课

1. 想写 a + b

你希望这样写：

Vector2 c = a + b;

而不是这样：

Vector2 c = a.add(b);

运算符重载就是给 +、==、<< 这些符号定义「对你的类怎么工作」。它不改变运算符的优先级和结合方向，只改变「作用在你的类型上时做什么」。

2. 重载 +

class Vector2 {
    int x, y;
public:
    Vector2(int x, int y) : x(x), y(y) {}

    Vector2 operator+(const Vector2& v) const {
        return Vector2(x + v.x, y + v.y);   // 两个分量分别相加
    }
};

int main() {
    Vector2 a(1, 2);
    Vector2 b(3, 4);
    Vector2 c = a + b;          // 相当于 a.operator+(b)
    cout << c.x << " " << c.y;   // 4 6
}

注意两个细节：参数写成 const Vector2& 是「只读地借用」，不复制；函数末尾的 const 表示 a 自己不被修改——加法本来就不该改左操作数。

3. 重载 ==

bool operator==(const Vector2& v) const {
    return x == v.x && y == v.y;
}

这样就能写 if (a == b)，不用再一个个比较分量。

返回 bool 是规矩：比较运算应该给出「是/否」。参数还是 const&，因为它只看不改。

4. 重载 << —— 配合 cout

想让 cout << a 直接打印 (1, 2)。但 cout << a 左边是 cout，不是你的对象，所以不能写成成员函数，要用友元函数：

class Vector2 {
    int x, y;
public:
    Vector2(int x, int y) : x(x), y(y) {}

    friend ostream& operator<<(ostream& out, const Vector2& v);
};

// 友元不是成员函数，但可以访问 private 的 x, y
ostream& operator<<(ostream& out, const Vector2& v) {
    out << "(" << v.x << ", " << v.y << ")";
    return out;              // 返回 out 才能连续 <<
}

两个参数都不能少：第一个是 ostream&（左边那台「输出机器」），第二个是要打印的对象。返回 out 的引用，是为了让 cout << c << endl 这种连续写法成立。

5. friend 是什么

friend 字面意思「朋友」：它允许一个不是成员函数的函数访问你的 private 成员。

换句话说：friend 是在封装的墙上开一扇小门，只为那些非开不可的写法准备。门开多了，封装就名存实亡。

6. 完整示例

#include <iostream>
using namespace std;

class Vector2 {
    int x, y;
public:
    Vector2(int x, int y) : x(x), y(y) {}

    Vector2 operator+(const Vector2& v) const {
        return Vector2(x + v.x, y + v.y);
    }

    bool operator==(const Vector2& v) const {
        return x == v.x && y == v.y;
    }

    friend ostream& operator<<(ostream& out, const Vector2& v);
};

ostream& operator<<(ostream& out, const Vector2& v) {
    out << "(" << v.x << ", " << v.y << ")";
    return out;
}

int main() {
    Vector2 a(1, 2), b(3, 4);
    Vector2 c = a + b;

    cout << c << endl;          // (4, 6)
    cout << (a == b) << endl;    // 0（false）

    return 0;
}

读一遍 main：c = a + b 走成员版 operator+；cout << c 走友元版 operator<<；a == b 走成员版 operator==。三个运算符，两条规则：左操作数是你的对象 → 成员；不是 → 友元。

7. 坑点清单

• 把 operator<< 写成成员函数：那第一个参数就变成了对象自己，cout << a 匹配不上，编译直接报错。
• 忘了 return out;：返回 void 的话，cout << c << endl 就断了链，写不出来。
• 参数没写 const&：按值传参会多一次拷贝；const 少了又接不住常量对象。
• 友元声明和定义签名不一致：一边有 &、一边没有，或者 const 对不上，就会变成两个不同的函数，链接时报「找不到定义」。
• 左右操作数搞反：成员版里 a 是「自己」、b 是参数；减法这类不满足交换律的运算写反了，结果会悄悄出错。
• 什么都用 friend：能用成员函数解决却硬开友元，等于把封装的墙拆了。只给 cout 这种「左边不是对象」的场景开口子。

8. 小测

9. 动手练习

本课小结

• 运算符重载：返回类型 operator符号(参数)。
• a + b = a.operator+(b)；左操作数是你的对象时，写成成员函数。
• friend 让非成员函数访问私有成员，只为「左边不是对象」的场景开。
• cout << 对象 用 friend 重载 operator<<，第一个参数是 ostream&。
• 返回 ostream& 才能连续 <<。