C++ 入门教程（十）：运算符重载与友元

本篇目标#

a + b、cout << obj、obj[i]——内置类型天然支持这些运算，自定义类型也可以。运算符重载让 Money + Money、Vector * Matrix 写起来像数学公式。这是 C++ 区别于多数语言的特性，用好了代码优雅，用滥了灾难现场。

一、基本概念与规则#

什么能重载、什么不能#

1
✅ 可重载：+ - * / % == != < > += -= << >> && || ! [] () -> new...
2
❌ 不可重载：:: . .* sizeof typeid ?:（三目） .*

两条硬规则：

至少一个操作数是自定义类型（不能重载 int + int）
不能发明新运算符、不能改变优先级与结合性

心法：重载后的行为要符合直觉——+ 就该是加法语义。把 + 重载成减法，同事会杀人。

成员 vs 非成员#

1
class Money {
2
    long cents_;                        // 用"分"存，避免浮点误差
3
public:
4
    // 成员函数版：左操作数必须是本类
5
    Money operator+(const Money& rhs) const {
6
        return Money(cents_ + rhs.cents_);
7
    }
8
};
9

10
// 非成员版（常配友元）：左操作数可以是其他类型
11
Money operator-(const Money& a, const Money& b);
12
std::ostream& operator<<(std::ostream&, const Money&);   // 流运算符必须非成员

选择：会修改左操作数（+=、=、[]）用成员；对称双目（+、==）与流运算符用非成员。

二、算术与比较运算符#

完整的 Fraction（分数）实现#

1
#include <iostream>
2
#include <numeric>      // std::gcd
3

4
class Fraction {
5
    long num_, den_;                        // 分子/分母
6

7
    void reduce() {                         // 内部工具：约分并规范化符号
8
        long g = std::gcd(num_, den_);
9
        if (g != 0) { num_ /= g; den_ /= g; }
10
        if (den_ < 0) { num_ = -num_; den_ = -den_; }   // 分母保持正
11
    }
12

13
public:
14
    Fraction(long n, long d = 1) : num_(n), den_(d) {
15
        if (d == 0) throw std::invalid_argument("分母为零");
16
        reduce();
17
    }
18

19
    // —— 算术：返回新对象，const ——
20
    Fraction operator+(const Fraction& r) const {
21
        return Fraction(num_ * r.den_ + r.num_ * den_, den_ * r.den_);
22
    }
23
    Fraction operator-(const Fraction& r) const {
24
        return Fraction(num_ * r.den_ - r.num_ * den_, den_ * r.den_);
25
    }
26
    Fraction operator*(const Fraction& r) const {
27
        return Fraction(num_ * r.num_, den_ * r.den_);
28
    }
29
    Fraction operator/(const Fraction& r) const {
30
        if (r.num_ == 0) throw std::invalid_argument("除以零");
31
        return Fraction(num_ * r.den_, den_ * r.num_);
32
    }
33

34
    // —— 复合赋值：修改自身，返回 *this 引用 ——
35
    Fraction& operator+=(const Fraction& r) {
36
        return *this = *this + r;           // 复用 operator+
37
    }
38

39
    // —— 比较：写成一对，其余用逻辑推导 ——
40
    bool operator==(const Fraction& r) const {
41
        return num_ == r.num_ && den_ == r.den_;   // 已约分，直接比
42
    }
43
    bool operator<(const Fraction& r) const {
44
        return num_ * r.den_ < r.num_ * den_;
45
    }
46

47
    double value() const { return double(num_) / den_; }
48
    long num() const { return num_; }
49
    long den() const { return den_; }
50
};
51

52
// 非成员：流输出
53
std::ostream& operator<<(std::ostream& os, const Fraction& f) {
54
    if (f.den() == 1) return os << f.num();
55
    return os << f.num() << "/" << f.den();
56
}
57

58
int main() {
59
    Fraction a(1, 2), b(3, 4);
60

61
    std::cout << a << " + " << b << " = " << a + b << "\n";   // 5/4
62
    std::cout << a << " * " << b << " = " << a * b << "\n";   // 3/8
63
    std::cout << a << " - " << b << " = " << a - b << "\n";   // -1/4
64
    std::cout << (a < b ? "a<b" : "a>=b") << "\n";
65

66
    Fraction c(2, 4);        // 自动约分成 1/2
67
    std::cout << c << "\n";  // 1/2
68
}

省力技巧（C++20 <=>）：三路比较一行顶六行：

1
// C++20：自动生成 == != < <= > >=
2
auto operator<=>(const Fraction&) const = default;   // 需成员逐一可比较

三、流运算符 << 与 >>#

1
// << 必须是非成员（左操作数是 ostream，不是我们的类）
2
std::ostream& operator<<(std::ostream& os, const Fraction& f) {
3
    return os << f.num() << "/" << f.den();   // 返回 os 引用 → 支持链式
4
}
5

6
// >> 输入版
7
std::istream& operator>>(std::istream& is, Fraction& f) {
8
    long n, d;
9
    char slash;
10
    if (is >> n >> slash >> d && slash == '/')
11
        f = Fraction(n, d);                   // 输入合法才更新
12
    else
13
        is.setstate(std::ios::failbit);       // 标记失败
14
    return is;
15
}
16
// 用法：std::cout << a << " " << b << "\n";  链式全靠返回 os

四、下标、调用与类型转换运算符#

operator[]：让对象像数组#

1
class IntArray {
2
    std::vector<int> data_;
3
public:
4
    explicit IntArray(size_t n) : data_(n) {}
5

6
    int& operator[](size_t i) { return data_.at(i); }          // 可写版本
7
    const int& operator[](size_t i) const { return data_.at(i); }  // 只读版本
8

9
    size_t size() const { return data_.size(); }
10
};
11

12
IntArray arr(5);
13
arr[0] = 42;                  // 调可写版
14
std::cout << arr[0];          // 调只读版（const 场景）

operator()：仿函数（函数对象）#

1
class Multiplier {                    // "行为像函数的对象"
2
    int factor_;
3
public:
4
    explicit Multiplier(int f) : factor_(f) {}
5
    int operator()(int x) const {     // 重载调用运算符
6
        return x * factor_;
7
    }
8
};
9

10
Multiplier triple(3);
11
std::cout << triple(10);              // 30——像调用函数一样使用对象
12

13
// STL 中 lambda 本质就是编译器生成的仿函数类！
14
auto quadruple = [](int x) { return x * 4; };

类型转换运算符#

1
class Fraction {
2
    // ...
3
public:
4
    explicit operator double() const {      // 显式转 double
5
        return double(num_) / den_;
6
    }
7
};
8

9
Fraction f(1, 2);
10
double d = static_cast<double>(f);   // ✓ 显式转换
11
// double e = f;                    // ❌ explicit 禁止隐式转换（防意外）

五、友元（friend）#

问题：非成员函数想访问私有成员#

1
class BankAccount {
2
    friend std::ostream& operator<<(std::ostream&, const BankAccount&);
3
    // ↑ 声明这个函数是"朋友"：允许它访问我的 private
4

5
private:
6
    std::string owner_;
7
    double balance_;
8

9
public:
10
    BankAccount(std::string o, double b) : owner_(std::move(o)), balance_(b) {}
11
};
12

13
// 友元函数不是成员函数，但能访问私有成员
14
std::ostream& operator<<(std::ostream& os, const BankAccount& acc) {
15
    return os << acc.owner_ << ": ¥" << acc.balance_;   // ✓ 访问 private
16
}
17

18
int main() {
19
    BankAccount a("小明", 100.5);
20
    std::cout << a << "\n";    // 小明: ¥100.5
21
}

友元类与要点#

1
class Matrix;
2
class MatrixIterator {
3
    friend class Matrix;      // Matrix 的所有成员函数都可访问我的私有
4
    // ...
5
};

友元三原则：friend 是”授予”而非”索取”（类自己声明谁是我朋友）；友元破坏封装，能不用就不用；合法场景：运算符重载、紧密协作的类对（Container 与它的 Iterator）。

友元不被继承、不是双向的、不传递。

六、何时不该重载#

场景	建议
数学类型（向量/分数/矩阵/复数）	✅ 重载 + - * /，天然合适
逻辑比较（排序、去重需要）	✅ `<` `==`（配 STL 容器）
输出调试	✅ `<<`
`&&` `
逗号 `，`、取地址 `&`	❌ 语义迷惑，别碰
为了少打字把 `+` 当”追加”用于文件/网络	⚠ 语义存疑，用命名方法 `append` 更清晰

七、实战：二维向量 Vector2D 完整版#

1
#include <iostream>
2
#include <cmath>
3

4
class Vec2 {
5
    double x_, y_;
6
public:
7
    Vec2(double x = 0, double y = 0) : x_(x), y_(y) {}
8

9
    Vec2 operator+(const Vec2& r) const { return {x_ + r.x_, y_ + r.y_}; }
10
    Vec2 operator-(const Vec2& r) const { return {x_ - r.x_, y_ - r.y_}; }
11
    Vec2 operator*(double k) const { return {x_ * k, y_ * k}; }        // 数乘
12
    Vec2 operator-() const { return {-x_, -y_}; }                       // 取负
13

14
    bool operator==(const Vec2& r) const { return x_==r.x_ && y_==r.y_; }
15

16
    double dot(const Vec2& r) const { return x_ * r.x_ + y_ * r.y_; }
17
    double length() const { return std::sqrt(dot(*this)); }             // 复用 dot
18

19
    double& operator[](size_t i) { return i == 0 ? x_ : y_; }           // v[0]/v[1]
20

21
    friend std::ostream& operator<<(std::ostream& os, const Vec2& v) {
22
        return os << "(" << v.x_ << ", " << v.y_ << ")";
23
    }
24
};
25

26
Vec2 operator*(double k, const Vec2& v) { return v * k; }   // 3*v 也成立
27

28
int main() {
29
    Vec2 a(1, 2), b(3, 4);
30

31
    std::cout << "a=" << a << " b=" << b << "\n";
32
    std::cout << "a+b=" << a + b << "\n";       // (4, 6)
33
    std::cout << "a·b=" << a.dot(b) << "\n";    // 11
34
    std::cout << "|b|=" << b.length() << "\n";  // 5
35
    std::cout << "3a=" << 3 * a << "\n";        // (3, 6)
36

37
    Vec2 c = a + b * 2;                          // 数学式表达式
38
    std::cout << c[0] << "," << c[1] << "\n";   // 7,10
39
}

小练习#

给 Fraction 补全 >= <= > !=（用 < 和 == 组合实现）
实现 Temperature 类：内部存摄氏，operator+、转华氏方法、<< 输出两种温标
实现 Str 简易字符串类：operator+ 拼接、operator[] 访问、operator== 比较
写 Accumulator 仿函数：每次 () 调用累加并返回累计值（对比第六篇闭包计数器）
（思考）为什么 operator<< 不能是成员函数？为什么 operator+= 通常是成员而 operator+ 常是非成员？

本篇小结#

可重载绝大多数运算符，但语义必须符合直觉；&&/|| 别重载（失短路）
修改自身用成员（+= = [] ()），对称与流用非成员（+ == << >>）
算术返回新值 const，复合赋值返回 *this&
<< 返回 ostream 引用支撑链式；C++20 <=> 一行生成全套比较
friend 授予外部访问私有的权限，仅用于运算符/姊妹类
仿函数 operator() 是 lambda 的本质

下一篇：STL 标准模板库总览——容器、迭代器与算法的完整武器库。

本系列为 Cyber先锋社原创教程。Fraction 与 Vec2 是面试白板题常客，建议默写一遍。