1. C++运算符重载基础概念
运算符重载是C++面向对象编程中一项强大的特性，它允许我们为自定义的类和结构体重新定义运算符的行为。简单来说，就是让运算符能够作用于我们自定义的数据类型，就像作用于内置类型一样自然。
在C++中，运算符重载本质上是一种特殊的函数，使用operator关键字后接要重载的运算符符号来定义。这种机制使得我们可以为自定义类型赋予与内置类型相似的操作体验，大大提高了代码的可读性和易用性。
注意：运算符重载不能改变运算符的优先级和结合性，也不能创造新的运算符符号。
2. 仿函数：重载函数调用运算符()
2.1 仿函数的概念与实现
仿函数（Functor）是指重载了函数调用运算符()的类或结构体对象。这种对象可以像普通函数一样被调用，因此得名"仿函数"。
cpp复制class Adder {
public:
int operator()(int a, int b) {
return a + b;
}
};
在这个例子中，我们定义了一个Adder类，重载了()运算符使其能够执行加法操作。使用时可以这样调用：
cpp复制Adder add;
int result = add(3, 5); // 输出8
2.2 仿函数的实际应用场景
仿函数在STL算法中被广泛使用，特别是在需要自定义比较或操作逻辑时。例如：
cpp复制#include <algorithm>
#include <vector>
struct Compare {
bool operator()(int a, int b) {
return a > b; // 降序排列
}
};
int main() {
std::vector<int> nums = {3, 1, 4, 1, 5, 9};
std::sort(nums.begin(), nums.end(), Compare());
// nums现在是{9, 5, 4, 3, 1, 1}
return 0;
}
提示：相比普通函数，仿函数可以保存状态，这是它的一个重要优势。例如，可以创建一个计数器仿函数，每次调用时递增内部计数器。
3. 重载输出运算符<<
3.1 基本实现方式
输出运算符<<通常用于将对象内容输出到流中。在类或结构体内部重载时，通常需要返回引用以支持链式调用。
cpp复制struct Point {
int x, y;
std::ostream& operator<<(std::ostream& os) {
os << "(" << x << ", " << y << ")";
return os;
}
};
然而，这种实现方式使用起来不太直观：
cpp复制Point p{1, 2};
p << std::cout; // 输出(1, 2)
3.2 更常见的全局重载方式
更常见的做法是将<<重载为全局函数：
cpp复制struct Point {
int x, y;
};
std::ostream& operator<<(std::ostream& os, const Point& p) {
os << "(" << p.x << ", " << p.y << ")";
return os;
}
int main() {
Point p{1, 2};
std::cout << p; // 输出(1, 2)
return 0;
}
注意：如果类成员是private的，需要在类中声明这个全局函数为友元(friend)。
4. 重载比较运算符==
4.1 基本实现
比较运算符==用于判断两个对象是否相等。重载时应考虑所有相关成员变量。
cpp复制struct Person {
std::string name;
int age;
bool operator==(const Person& other) const {
return name == other.name && age == other.age;
}
};
4.2 完整关系运算符的实现
在实际开发中，如果实现了==，通常也应该实现!=。C++20引入了"三路比较运算符"(<=>)，可以简化关系运算符的实现：
cpp复制#include <compare>
struct Person {
std::string name;
int age;
auto operator<=>(const Person&) const = default;
};
这样编译器会自动生成==, !=, <, <=, >, >=等所有比较运算符。
5. 运算符重载的综合应用实例
让我们通过一个更完整的例子来展示多种运算符重载的实际应用：
cpp复制#include <iostream>
#include <string>
class Complex {
private:
double real;
double imag;
public:
Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
// 加法运算符重载
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);
}
// 乘法运算符重载
Complex operator*(const Complex& other) const {
return Complex(
real * other.real - imag * other.imag,
real * other.imag + imag * other.real
);
}
// 相等比较运算符
bool operator==(const Complex& other) const {
return real == other.real && imag == other.imag;
}
// 输出运算符重载(友元函数)
friend std::ostream& operator<<(std::ostream& os, const Complex& c);
};
std::ostream& operator<<(std::ostream& os, const Complex& c) {
os << c.real;
if (c.imag >= 0) os << "+";
os << c.imag << "i";
return os;
}
int main() {
Complex a(1.0, 2.0);
Complex b(3.0, -4.0);
std::cout << "a = " << a << std::endl;
std::cout << "b = " << b << std::endl;
std::cout << "a + b = " << a + b << std::endl;
std::cout << "a - b = " << a - b << std::endl;
std::cout << "a * b = " << a * b << std::endl;
if (a == b) {
std::cout << "a equals b" << std::endl;
} else {
std::cout << "a does not equal b" << std::endl;
}
return 0;
}
6. 运算符重载的注意事项与最佳实践
6.1 可重载的运算符列表
C++中大部分运算符都可以重载，但有几个例外：
- 成员访问运算符.
- 成员指针访问运算符.*
- 作用域解析运算符::
- 条件运算符?:
- sizeof运算符
6.2 运算符重载的黄金法则
-
保持一致性：运算符的行为应该符合直觉。例如，+应该执行某种"加法"操作，而不是完全无关的操作。
-
对称性原则：对于二元运算符，考虑是否需要处理不同类型的操作数。例如，实现复数与double的加法时，应该同时实现Complex + double和double + Complex。
-
返回值优化：对于创建新对象的运算符(如+、-)，通常应该返回值而不是引用。
-
复合赋值优先：如果实现了+，也应该实现+=，通常后者效率更高。
6.3 常见陷阱与解决方案
- 自赋值问题：在重载赋值运算符=时，需要处理对象给自己赋值的情况。
cpp复制class MyArray {
int* data;
size_t size;
public:
MyArray& operator=(const MyArray& other) {
if (this != &other) { // 检查自赋值
delete[] data;
size = other.size;
data = new int[size];
std::copy(other.data, other.data + size, data);
}
return *this;
}
};
-
异常安全：运算符重载应该保证基本的异常安全。在上面的例子中，如果new抛出异常，对象将处于无效状态。
-
重载&&和||：这些运算符有短路特性，但重载后会失去这一特性，因为重载的运算符是函数调用。
7. 高级运算符重载技巧
7.1 类型转换运算符
可以定义类型转换运算符，让对象能够隐式或显式转换为其他类型。
cpp复制class Rational {
int numerator;
int denominator;
public:
operator double() const {
return static_cast<double>(numerator) / denominator;
}
explicit operator bool() const {
return numerator != 0;
}
};
7.2 下标运算符重载
下标运算符[]常用于容器类，提供类似数组的访问方式。
cpp复制class IntArray {
int* data;
size_t size;
public:
int& operator[](size_t index) {
if (index >= size) throw std::out_of_range("Index out of range");
return data[index];
}
const int& operator[](size_t index) const {
if (index >= size) throw std::out_of_range("Index out of range");
return data[index];
}
};
7.3 函数对象与Lambda表达式
现代C++中，Lambda表达式可以替代简单的仿函数：
cpp复制std::vector<int> nums = {3, 1, 4, 1, 5, 9};
std::sort(nums.begin(), nums.end(), [](int a, int b) {
return a > b; // 降序排列
});
但对于需要保存状态的复杂操作，仿函数仍然是更好的选择。
8. 性能考量与优化
运算符重载虽然方便，但也需要注意性能影响：
-
避免不必要的临时对象：对于连续运算，如a + b + c，可能会产生临时对象。使用+=或复合赋值运算符通常更高效。
-
移动语义的应用：C++11引入的移动语义可以优化运算符重载中的对象传递：
cpp复制Matrix operator+(Matrix&& lhs, const Matrix& rhs) {
lhs += rhs; // 重用lhs的存储空间
return std::move(lhs);
}
- 表达式模板：高级技术如表达式模板可以延迟计算，优化复杂表达式的性能。
在实际项目中，应该根据性能分析结果来决定是否需要进行这类优化，避免过早优化带来的代码复杂性。