C++进阶教程：运算符重载与类型转换

发布时间：2026-08-28 18:12:04

🕒 阅读时间：16 分钟📝 字数：2336👀 阅读量：Loading...

本文是 C++ 系列教程的第 7 篇。上一篇深入了类与对象（深拷贝、static、this、友元），本篇讲解运算符重载与类型转换：可重载运算符清单、常用重载（==、<、<<、[]、()、++、–）、explicit 关键字、类型转换运算符。

一、运算符重载基础

1.1 什么是运算符重载

运算符重载是让 +、==、<< 等运算符可以作用于自定义类型，使代码更自然、更直观。例如 c1 + c2 让复数相加，cout << obj 直接打印对象。

1.2 可重载与不可重载运算符

可重载	不可重载
`+ - * / %` `== != < >` `<< >>` `[] () ++ --` `= += -=` `&&

规则：不能发明新运算符；至少一个操作数是自定义类型；不能改变优先级与结合性。

1.3 两种形式：成员函数 vs 友元函数

1
#include <iostream>
2
using namespace std;
3

4
class Point {
5
private:
6
    int x, y;
7

8
public:
9
    Point(int a, int b) : x(a), y(b) {}
10

11
    // 成员函数形式：左操作数是 this，只接受一个参数
12
    Point operator+(const Point &other) const {
13
        return Point(x + other.x, y + other.y);
14
    }
15

16
    // 友元函数形式：需要两个参数，能处理对称操作
17
    friend bool operator==(const Point &a, const Point &b);
18
    friend ostream &operator<<(ostream &os, const Point &p);
19
};
20

21
bool operator==(const Point &a, const Point &b) {
22
    return a.x == b.x && a.y == b.y;
23
}
24

25
ostream &operator<<(ostream &os, const Point &p) {
26
    os << "(" << p.x << ", " << p.y << ")";
27
    return os;
28
}
29

30
int main() {
31
    Point p1(1, 2), p2(3, 4);
32
    Point p3 = p1 + p2;          // 成员函数重载
33
    cout << "p3 = " << p3 << endl;  // (4, 6)
34

35
    cout << (p1 == Point(1, 2)) << endl;  // 1
36
    cout << (p1 == p2) << endl;           // 0
37
    return 0;
38
}

二、常用运算符重载

2.1 关系运算符 == 和 <

1
#include <iostream>
2
using namespace std;
3

4
class Student {
5
private:
6
    string name;
7
    int score;
8

9
public:
10
    Student(string n, int s) : name(n), score(s) {}
11

12
    // == 判断分数相同
13
    bool operator==(const Student &other) const {
14
        return score == other.score;
15
    }
16

17
    // < 按分数比较（用于排序）
18
    bool operator<(const Student &other) const {
19
        return score < other.score;
20

21
  }
22

23
    // > 可以用 < 实现
24
    bool operator>(const Student &other) const {
25
        return other < *this;
26
    }
27

28
    int getScore() const { return score; }
29
};
30

31
int main() {
32
    Student s1("张三", 88), s2("李四", 88), s3("王五", 92);
33
    cout << "s1 == s2: " << (s1 == s2) << endl;   // 1
34
    cout << "s1 < s3: " << (s1 < s3) << endl;     // 1
35
    cout << "s3 > s1: " << (s3 > s1) << endl;     // 1
36
    return 0;
37
}

2.2 输出运算符 <<

1
#include <iostream>
2
using namespace std;
3

4
class Complex {
5
private:
6
    double real;
7
    double imag;
8

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

12
    // 重载 << 打印复数
13
    friend ostream &operator<<(ostream &os, const Complex &c) {
14
        os << c.real;
15
        if (c.imag >= 0) os << "+" << c.imag << "i";
16
        else os << c.imag << "i";
17
        return os;
18
    }
19
};
20

21
int main() {
22
    Complex c1(3, 4);
23
    Complex c2(2, -5);
24
    cout << "c1 = " << c1 << endl;   // 3+4i
25
    cout << "c2 = " << c2 << endl;   // 2-5i
26
    return 0;
27
}

2.3 下标运算符 []

1
#include <iostream>
2
#include <stdexcept>
3
using namespace std;
4

5
class IntArray {
6
private:
7
    int data[10];
8
    int size;
9

10
public:
11
    IntArray() : size(0) {}
12

13
    void add(int v) {
14
        if (size < 10) data[size++] = v;
15
    }
16

17
    // 下标运算符：返回引用以便修改
18
    int &operator[](int index) {
19
        if (index < 0 || index >= size) {
20
            throw out_of_range("下标越界");
21
        }
22
        return data[index];
23
    }
24

25
    // const 版本（只读对象可用）
26
    const int &operator[](int index) const {
27
        if (index < 0 || index >= size) {
28
            throw out_of_range("下标越界");
29
        }
30
        return data[index];
31
    }
32

33
    int getSize() const { return size; }
34
};
35

36
int main() {
37
    IntArray arr;
38
    arr.add(10);
39
    arr.add(20);
40
    arr.add(30);
41

42
    cout << arr[0] << " " << arr[1] << " " << arr[2] << endl;  // 10 20 30
43
    arr[1] = 99;    // 通过引用修改
44
    cout << arr[1] << endl;  // 99
45
    return 0;
46
}

2.4 自增自减 ++ 和 –

1
#include <iostream>
2
using namespace std;
3

4
class Counter {
5
private:
6
    int value;
7

8
public:
9
    Counter(int v = 0) : value(v) {}
10

11
    // 前置 ++：返回引用（支持链式）
12
    Counter &operator++() {
13
        ++value;
14
        return *this;
15
    }
16

17
    // 后置 ++：参数 int 占位区分，返回旧值副�
18
��
19
    Counter operator++(int) {
20
        Counter temp = *this;
21
        ++value;
22
        return temp;
23
    }
24

25
    int get() const { return value; }
26
};
27

28
int main() {
29
    Counter c(5);
30
    cout << "c = " << c.get() << endl;      // 5
31
    cout << "++c = " << (++c).get() << endl; // 6（前置：先增后取）
32
    cout << "c++ = " << (c++).get() << endl; // 6（后置：先取后增）
33
    cout << "c = " << c.get() << endl;      // 7
34
    return 0;
35
}

2.5 函数调用运算符 ()

1
#include <iostream>
2
using namespace std;
3

4
// 仿函数：像函数一样调用对象
5
class AddBy {
6
private:
7
    int base;
8

9
public:
10
    AddBy(int b) : base(b) {}
11

12
    // operator() 让对象可像函数调用
13
    int operator()(int value) const {
14
        return value + base;
15
    }
16
};
17

18
int main() {
19
    AddBy add10(10);
20
    AddBy add100(100);
21

22
    cout << add10(5) << endl;    // 15（对象当函数用）
23
    cout << add100(5) << endl;   // 105
24
    return 0;
25
}

三、赋值运算符与自赋值

3.1 完整的赋值运算符

1
#include <iostream>
2
#include <cstring>
3
using namespace std;
4

5
class Buffer {
6
private:
7
    char *data;
8
    int length;
9

10
public:
11
    Buffer(const char *s = "") {
12
        length = strlen(s);
13
        data = new char[length + 1];
14
        strcpy(data, s);
15
    }
16

17
    Buffer(const Buffer &other) {
18
        length = other.length;
19
        data = new char[length + 1];
20
        strcpy(data, other.data);
21
    }
22

23
    // 赋值运算符必须处理：自赋值、资源释放、深拷贝
24
    Buffer &operator=(const Buffer &other) {
25
        if (this == &other) return *this;   // 自赋值检查（关键！）
26
        delete[] data;                       // 释放旧资源
27
        length = other.length;
28
        data = new char[length + 1];
29
        strcpy(data, other.data);
30
        return *this;                        // 返回引用支持链式
31
    }
32

33
    ~Buffer() { delete[] data; }
34

35
    const char *get() const { return data; }
36
};
37

38
int main() {
39
    Buffer b1("Hello");
40
    Buffer b2("World");
41
    b1 = b2;          // 赋值
42
    b1 = b1;          // 自赋值（安全）
43
    cout << b1.get() << endl;  // World
44
    return 0;
45
}

3.2 =default 与 =delete（C++11）

1
#include <iostream>
2
using namespace std;
3

4
class NoCopy {
5
public:
6
    NoCopy() = default;   // 使用编译器生成的默认构造
7

8
    // 禁用拷贝（=delete）
9
    NoCopy(const NoC
10
opy &) = delete;
11
    NoCopy &operator=(const NoCopy &) = delete;
12
};
13

14
class Dummy {
15
public:
16
    int value;
17
    Dummy() = default;              // 显式要求默认构造
18
    Dummy(int v) : value(v) {}
19
};
20

21
int main() {
22
    NoCopy n1;
23
    // NoCopy n2 = n1;  // 错误！拷贝已被删除
24

25
    Dummy d;
26
    d.value = 42;
27
    cout << d.value << endl;  // 42
28
    return 0;
29
}

四、类型转换

4.1 explicit 关键字（防止隐式转换）

1
#include <iostream>
2
using namespace std;
3

4
class Money {
5
private:
6
    double amount;
7

8
public:
9
    // 非 explicit：int 可隐式转 Money
10
 // Money(double a) : amount(a) {}
11

12
    // explicit：禁止隐式转换，必须显式构造
13

14
    explicit Money(double a) : amount(a) {}
15

16
    double get() const { return amount; }
17
};
18

19
void pay(const Money &m) {
20
    cout << "支付 " << m.get() << " 元" << endl;
21
}
22

23
int main() {
24
    Money m1(100.0);        // 显式构造
25
    // Money m2 = 200.0;     // 错误！explicit 禁止隐式转换
26
    // pay(300.0);           // 错误！不能隐式转 Money
27
    pay(Money(300.0));       // 显式转换后调用
28
    return 0;
29
}

4.2 类型转换运算符

1
#include <iostream>
2
using namespX�H�‚��\����X�[ۈœ�]�]N��[��[Nˆ[�[�‚�X�X΂���X�[ۊ[��[�
3
H��[J�K[�
4
H�B����9�n�g��/k9�h�/�9���)��&���X�[ۈO��X�B��\�]܈�X�J
5
H�ۜ�ˆ�]\���]X���\��X�O��[JH�[�ˆB������X�[ۈO����;�"9b)9��y�+�d)�..��'�b!��l;�"B�^X�]�\�]܈���
6

7
H�ۜ�ˆ�]\���[HOHˆB����Y���
8
H�ۜ�ˆ��]�[H�Ȉ[��H��]X���\��X�O�
9
�\�H[�ˆB�N‚�[�XZ[�
10
Hˆ��X�[ۈ��
11
Nˆ�X�HH����:f�9o#�/k�X�B���]��X�H9`/��[������B�������
12
N�����H��B����Y�9�hy.��a�9a`z+����:/k9�h��"^X�]���9g*9�i9g.��k�d"9��{�"B�Y�
13
�Hˆ��]�b!�kd:gg�f툈[�ˆB��]\��ŸB�����9.�8� y��9d"9k��/���&�i#y�l9�n‚���9d"9�+9���aj:`�9��z+��#9k���9k�9�m9�9i#y�l9�n��&������[��YH[���X[O��\�[���[Y\�X�H�‚��\����\^œ�]�]N���X�H�X[ˆ�X�H[XY�‚�X�X΂���\^
14
�X�H�H�X�HHH
15
H��X[
16
�K[XY�JH�B����9���+�/�9���"9�$9df9a�y�l;�"B���\^�\�]܊��ۜ���\^  ��H�ۜ�ˆ�
17
turn Complex(real + c.real, imag + c.imag);
18
    }
19
    Complex operator-(const Complex &c) const {
20
        return Complex(real - c.real, imag - c.imag);
21
    }
22
    Complex operator*(const Complex &c) const {
23
        // (a+bi)(c+di) = (ac-bd) + (ad+bc)i
24
        return Complex(real * c.real - imag * c.imag,
25
                       real * c.imag + imag * c.real);
26
    }
27

28
    // 比较（友元）
29
    friend bool operator==(const Complex &a, const Complex &b) {
30
        return a.real == b.real && a.imag == b.imag;
31
    }
32

33
    // 输出（友元）
34
    friend ostream &operator<<(ostream &os, const Complex &c) {
35
        os << c.real;
36
        if (c.imag >= 0) os << "+" << c.imag << "i";
37
        else os << c.imag << "i";
38
        return os;
39
    }
40

41
    // 输入（友元）
42
    friend istream &operator>>(istream &is, Complex &c) {
43
        cout << "输入实部: ";
44
        is >> c.real;
45
        cout << "输入虚部: ";
46
        is >> c.imag;
47
        return is;
48
    }
49
};
50

51
int main() {
52
    Complex a(3, 4);
53
    Complex b(1, -2);
54

55
    cout << "a = " << a << endl;           // 3+4i
56
    cout << "b = " << b << endl;           // 1-2i
57
    cout << "a + b = " << (a + b) << endl; // 4+2i
58
    cout << "a - b = " << (a - b) << endl; // 2+6i
59
    cout << "a * b = " << (a * b) << endl; // 11-2i
60
    cout << "a == b: " << (a == b) << endl; // 0
61
    return 0;
62
}

总结

本篇讲解了运算符重载的基础（可重载清单、成员/友元两种形式）、常用重载（==、<、<<、W]、()、++/–）、赋值运算符的完整实现（自赋值、深拷贝）、=default/=delete、explicit 关键字和类型转换运算符，并用复数类串联实战。重点掌握：成员 vs 友元的选择、自赋值检查、前置/后置 ++ 的区别、explicit 防止意外转换。

下一篇将讲解继承与多态（虚函数、抽象类、RTTI），敬请期待！