运算符重载是C++的一项强大特性，为自定义类型（如类或结构体）赋予了与内置类型相似的运算符行为。
通过运算符重载，可以使自定义类对象的操作更加直观与简洁，从而提高代码的可读性与可维护性。
本文将系统介绍C++运算符重载的概念、规则、分类及实现方法，并给出相应示例。
1. 运算符重载简介
1.1 概念说明
在C++中，运算符重载（Operator Overloading）允许程序员针对特定类型重新定义已有运算符的行为。例如，通过对“+”号的重载，我们可以直接使用 a + b 来表示两个用户自定义类型对象的相加操作，而不必调用函数 a.add(b)。
1.2 重载的目的
重载运算符的主要目的是提高代码的自然度和可读性。对自定义类型而言，使用运算符进行操作往往比调用类成员函数更直观，有助于编写简洁易懂的代码。
2. 重载运算符的基本规则
2.1 可重载与不可重载运算符
几乎所有C++运算符都可被重载，如 +、-、*、/、%、[]、() 、<<、>> 等。但以下运算符不可重载：
- 作用域解析运算符
:: - 成员访问运算符
.和.* - 条件运算符
?: sizeof- 类型信息运算符（如
typeid）
2.2 成员函数与非成员函数重载
运算符重载既可通过类的成员函数实现，也可通过非成员函数（如全局友元函数）实现。通常：
- 当需要访问类的私有成员或以类对象为左操作数时，使用成员函数更为方便。
- 当需要对称性（如
a + b和b + a）或隐式类型转换时，使用非成员函数往往更灵活。
2.3 运算符优先级与结合性
重载运算符并不会改变该运算符原有的优先级与结合性。也就是说，即使重载了 “+” 运算符，它仍保持与内置类型加法相同的优先级和结合性。
3. 运算符重载的常见分类与示例
3.1 算术运算符
可重载 +、-、*、/、% 等用于数学运算的运算符。
示例（复数相加）：
class Complex {
public:double real, imag;Complex(double r = 0, double i = 0) : real(r), imag(i) {}// 重载 + 运算符（成员函数版本）Complex operator+(const Complex& other) const {return Complex(real + other.real, imag + other.imag);}
};
3.2 关系与比较运算符
可重载 ==、!=、<、>、<=、>= 等，以比较自定义对象的大小或等价性。
示例（复数相等性判断）：
class Complex {
public:double real, imag;Complex(double r = 0, double i = 0) : real(r), imag(i) {}friend bool operator==(const Complex& lhs, const Complex& rhs) {return (lhs.real == rhs.real) && (lhs.imag == rhs.imag);}friend bool operator!=(const Complex& lhs, const Complex& rhs) {return !(lhs == rhs);}
};
3.3 赋值及复合赋值运算符
可重载 =、+=、-=、*=、/=、%= 等。重载赋值运算符时应小心内存管理，避免浅拷贝问题。
示例（字符串类赋值）：
#include <cstring>class String {
public:char* data;// 构造函数String(const char* str = "") {data = new char[std::strlen(str) + 1];std::strcpy(data, str);}// 拷贝构造函数String(const String& other) {data = new char[std::strlen(other.data) + 1];std::strcpy(data, other.data);}// 赋值运算符String& operator=(const String& other) {if (this != &other) {delete[] data;data = new char[std::strlen(other.data) + 1];std::strcpy(data, other.data);}return *this;}// 析构函数~String() {delete[] data;}
};
3.4 自增自减运算符
包括前置和后置的 ++、-- 运算符。前置运算符（如 ++obj）在操作前修改对象，后置运算符（如 obj++）在操作后修改对象。
示例（计数器）：
class Counter {
public:int count;Counter(int c = 0) : count(c) {}// 前置自增Counter& operator++() {++count;return *this;}// 后置自增Counter operator++(int) {Counter temp = *this;++count;return temp;}// 前置自减Counter& operator--() {--count;return *this;}// 后置自减Counter operator--(int) {Counter temp = *this;--count;return temp;}
};
3.5 逻辑与位运算符
可重载 !、&&、|| 以及 &、|、^、~、<<、>> 等。请谨慎重载逻辑运算符，因为短路特性难以完全保留。
示例（位域操作）：
class BitField {
public:unsigned int bits;BitField(unsigned int b = 0) : bits(b) {}BitField operator&(const BitField& other) const {return BitField(bits & other.bits);}BitField operator|(const BitField& other) const {return BitField(bits | other.bits);}BitField operator^(const BitField& other) const {return BitField(bits ^ other.bits);}BitField operator~() const {return BitField(~bits);}BitField operator<<(int shift) const {return BitField(bits << shift);}BitField operator>>(int shift) const {return BitField(bits >> shift);}
};
3.6 流输入输出运算符
重载 << 和 >> 可以方便地输出和输入自定义类型的数据。通常实现为友元函数。
示例（复数的输入输出）：
#include <iostream>class Complex {
public:double real, imag;Complex(double r = 0, double i = 0) : real(r), imag(i) {}friend std::ostream& operator<<(std::ostream& os, const Complex& c) {os << c.real;if (c.imag >= 0)os << " + " << c.imag << "i";elseos << " - " << -c.imag << "i";return os;}friend std::istream& operator>>(std::istream& is, Complex& c) {is >> c.real >> c.imag;return is;}
};
3.7 下标与函数调用运算符
[] 可用于实现类似数组的访问，() 可用于实现函数对象（仿函数）。
示例（下标运算符）：
#include <vector>
#include <stdexcept>class MyArray {
private:std::vector<int> data;
public:MyArray(int size) : data(size) {}int& operator[](int index) {if (index < 0 || index >= (int)data.size())throw std::out_of_range("Index out of range");return data[index];}const int& operator[](int index) const {if (index < 0 || index >= (int)data.size())throw std::out_of_range("Index out of range");return data[index];}
};
示例（函数调用运算符）：
class Adder {
public:int operator()(int a, int b) const {return a + b;}
};
3.8 成员访问与其他运算符
-> 可被重载以返回指针或代理对象。逗号运算符、new、delete 也可被重载，但不常见且需谨慎使用。
示例（智能指针）：
#include <iostream>class Proxy {
public:void display() const {std::cout << "Proxy display" << std::endl;}
};class SmartPointer {
private:Proxy* ptr;
public:SmartPointer() : ptr(new Proxy()) {}// 拷贝构造函数SmartPointer(const SmartPointer& other) : ptr(new Proxy(*other.ptr)) {}// 赋值运算符SmartPointer& operator=(const SmartPointer& other) {if (this != &other) {delete ptr;ptr = new Proxy(*other.ptr);}return *this;}~SmartPointer() { delete ptr; }Proxy* operator->() const {return ptr;}
};
4. 实现细节与注意事项
4.1 参数传递与返回类型
为提高效率，二元运算符的参数应尽量使用常量引用传递。对于返回类型，除赋值类运算符外，多数运算符返回新对象的值。
4.2 友元函数的使用
当需要访问类的私有成员，或保持操作数对称性时，可将运算符函数声明为类的友元，这样无需通过类的公共接口访问成员数据。
4.3 链式调用
运算符常通过返回引用来支持链式调用。以 a += b += c; 为例，通过让 += 返回引用，可实现连续赋值操作。
4.4 不改变运算符含义与优先级
应保持重载运算符的语义与原有运算符的内在逻辑相一致，不要让 + 用于非加法语义的行为。同时，重载不会改变运算符的优先级和结合性。
5. 示例综合
以下以复数类为例，展示典型运算符重载的实现和使用。
5.1 Complex 类定义
#include <iostream>class Complex {
private:double real;double imag;
public:Complex(double r = 0, double i = 0) : real(r), imag(i) {}// 拷贝构造函数Complex(const Complex& other) : real(other.real), imag(other.imag) {}// 赋值运算符Complex& operator=(const Complex& other) {if (this != &other) {real = other.real;imag = other.imag;}return *this;}// 算术运算符重载Complex operator+(const Complex& other) const {return Complex(real + other.real, imag + other.imag);}Complex operator-(const Complex& other) const {return Complex(real - other.real, imag - other.imag);}// 非成员友元函数形式的运算符重载（如乘法、比较、输入输出）friend Complex operator*(const Complex& lhs, const Complex& rhs) {return Complex(lhs.real * rhs.real - lhs.imag * rhs.imag,lhs.real * rhs.imag + lhs.imag * rhs.real);}friend bool operator==(const Complex& lhs, const Complex& rhs) {return lhs.real == rhs.real && lhs.imag == rhs.imag;}friend bool operator!=(const Complex& lhs, const Complex& rhs) {return !(lhs == rhs);}friend std::ostream& operator<<(std::ostream& os, const Complex& c) {os << c.real;if (c.imag >= 0)os << " + " << c.imag << "i";elseos << " - " << -c.imag << "i";return os;}friend std::istream& operator>>(std::istream& is, Complex& c) {is >> c.real >> c.imag;return is;}
};
5.2 使用示例
#include <iostream>int main() {Complex c1(3.0, 4.0);Complex c2(1.5, -2.5);Complex c3 = c1 + c2; // 使用重载的 + 运算符Complex c4 = c1 - c2; // 使用重载的 - 运算符Complex c5 = c1 * c2; // 使用重载的 * 运算符std::cout << "c1: " << c1 << "\n";std::cout << "c2: " << c2 << "\n";std::cout << "c3: " << c3 << "\n";std::cout << "c4: " << c4 << "\n";std::cout << "c5: " << c5 << "\n";if (c1 == c2)std::cout << "c1 和 c2 相等。\n";elsestd::cout << "c1 和 c2 不相等。\n";if (c1 != c2)std::cout << "c1 和 c2 不相等。\n";elsestd::cout << "c1 和 c2 相等。\n";std::cout << "请输入复数 c6 的实部和虚部（空格分隔）: ";Complex c6;std::cin >> c6;std::cout << "您输入的 c6 为: " << c6 << "\n";return 0;
}
输出示例：
c1: 3 + 4i
c2: 1.5 - 2.5i
c3: 4.5 + 1.5i
c4: 1.5 + 6.5i
c5: 10.5 + -1.5i
c1 和 c2 不相等。
c1 和 c2 不相等。
请输入复数 c6 的实部和虚部（空格分隔）: 2.5 3.5
您输入的 c6 为: 2.5 + 3.5i
6. 高级话题
6.1 运算符的优先级和结合性
重载运算符不会改变其原有的优先级和结合性。例如，+ 的优先级高于 =，即使重载了 + 运算符，表达式 c1 = c2 + c3 依然会先执行 c2 + c3，然后将结果赋值给 c1。
6.2 运算符链式调用
通过适当的返回类型，可以实现运算符的链式调用。例如，赋值运算符通常返回 *this 的引用，以允许连续赋值操作。
示例：
#include <iostream>class Number {
public:int value;Number(int v = 0) : value(v) {}// 重载 += 运算符Number& operator+=(const Number& other) {value += other.value;return *this;}// 重载 << 运算符以便输出 Number 对象friend std::ostream& operator<<(std::ostream& os, const Number& n) {os << n.value;return os;}
};int main() {Number a(1), b(2), c(3);a += b += c; // a = a + (b += c)std::cout << "a: " << a << ", b: " << b << ", c: " << c << std::endl;return 0;
}
输出：
a: 4, b: 5, c: 3
6.3 运算符重载与继承
在继承体系中，运算符重载可以与多态性结合使用，但需要注意运算符函数的作用域和访问权限。需要避免尝试将运算符重载为虚函数，因为C++不支持运算符重载的虚拟化。
示例：
#include <iostream>class Base {
public:virtual void print() const {std::cout << "Base" << std::endl;}// 基类的 + 运算符Base operator+(const Base& other) const {std::cout << "Base + Base" << std::endl;return Base();}
};class Derived : public Base {
public:void print() const override {std::cout << "Derived" << std::endl;}// 派生类的 + 运算符Derived operator+(const Derived& other) const {std::cout << "Derived + Derived" << std::endl;return Derived();}
};int main() {Base b1, b2;Base b3 = b1 + b2;b3.print(); // 输出 "Base"Derived d1, d2;Derived d3 = d1 + d2;d3.print(); // 输出 "Derived"return 0;
}
输出示例：
Base + Base
Base
Derived + Derived
Derived
说明：
- 运算符重载不能作为虚函数：C++不允许将运算符重载声明为虚函数，因此在基类和派生类中分别实现各自的运算符。
- 不同类型的运算符：基类和派生类的
operator+是独立的，不存在多态性。
7. 常见问题与注意事项
7.1 避免不必要的重载
并非所有运算符都需要重载。在某些情况下，重载运算符可能会使代码变得复杂或难以理解。只有在运算符的重载能够增加代码的清晰度和可读性时，才应考虑进行重载。
7.2 保持运算符的一致性
重载运算符时，应尽量保持其与内置类型运算符的行为一致。例如，重载 + 运算符应表示“相加”的意思，避免引入与预期行为不符的逻辑。
7.3 实现对称性
对于二元运算符，如果选择使用非成员函数实现，应确保运算符在操作数顺序上的对称性。例如，a + b 和 b + a 应该都能正常工作。
示例：
#include <iostream>class Number {
public:int value;Number(int v = 0) : value(v) {}// 重载 + 运算符（成员函数）Number operator+(const Number& other) const {return Number(value + other.value);}// 重载 + 运算符（非成员函数）friend Number operator+(int lhs, const Number& rhs) {return Number(lhs + rhs.value);}// 重载 << 运算符以便输出 Number 对象friend std::ostream& operator<<(std::ostream& os, const Number& n) {os << n.value;return os;}
};int main() {Number a(5);Number b = a + 10; // 使用成员函数Number c = 10 + a; // 使用非成员函数std::cout << "a: " << a << ", b: " << b << ", c: " << c << std::endl;return 0;
}
输出：
a: 5, b: 15, c: 15
7.4 高效的参数传递
对于需要传递对象的运算符重载，应尽量使用常量引用传递，避免不必要的对象拷贝，提高性能。
示例：
class Complex {
public:double real, imag;Complex(double r = 0, double i = 0) : real(r), imag(i) {}// 重载 + 运算符（使用常量引用）Complex operator+(const Complex& other) const {return Complex(real + other.real, imag + other.imag);}
};
7.5 注意内存管理
在重载赋值运算符、拷贝构造函数等操作时，必须妥善管理内存，避免内存泄漏或浅拷贝问题。遵循三大法则（拷贝构造函数、拷贝赋值运算符、析构函数）以确保类的正确行为。
示例：
#include <cstring>class String {
public:char* data;// 构造函数String(const char* str = "") {data = new char[std::strlen(str) + 1];std::strcpy(data, str);}// 拷贝构造函数String(const String& other) {data = new char[std::strlen(other.data) + 1];std::strcpy(data, other.data);}// 赋值运算符String& operator=(const String& other) {if (this != &other) {delete[] data;data = new char[std::strlen(other.data) + 1];std::strcpy(data, other.data);}return *this;}// 析构函数~String() {delete[] data;}
};
7.6 不要改变运算符的优先级和结合性
运算符的优先级和结合性由C++语法定义，重载运算符不会改变这些规则。因此，应设计运算符重载的行为以符合其原有的优先级和结合性，避免引入混淆和错误。
7.7 避免过度重载
过度重载运算符可能会使代码难以理解和维护。应在必要时进行重载，并确保重载后的运算符具有清晰明确的语义。
8. 总结与建议
通过运算符重载，可以使用户自定义类型的使用方式更贴近内置类型，使代码更加直观。编写运算符重载时应注意以下几点：
- 不要滥用重载，保持逻辑清晰，避免误导。
- 遵循运算符原有的含义和使用习惯，例如，
+表示加法。 - 尽量使用常量引用参数传递，提高性能。
- 对需要内存管理的类（如动态分配内存）格外谨慎，确保深拷贝与正确的析构。
- 保持运算符的优先级和结合性，不改变其内在逻辑。
- 避免过度重载，确保重载后的运算符具有清晰明确的语义。
掌握运算符重载将有助于编写更加优雅、易读且扩展性良好的C++程序。