C++运算符重载通过成员或非成员函数实现，如Vector类重载+和
C++ 运算符重载允许你为自定义类型赋予运算符新的含义，使其能够像内置类型一样使用。这增强了代码的可读性和表达力。
解决方案
C++ 中重载运算符是通过定义特殊的成员函数或非成员函数来实现的。这些函数的名字是
operator关键字后跟要重载的运算符。
1. 成员函数重载:
立即学习“C++免费学习笔记（深入）”；
当运算符左侧的操作数是该类的对象时，通常使用成员函数重载。例如，重载
+运算符，让两个自定义的
Vector对象相加：
class Vector {
public:
double x, y;
Vector(double x = 0, double y = 0) : x(x), y(y) {}
Vector operator+(const Vector& other) const {
return Vector(x + other.x, y + other.y);
}
};
int main() {
Vector v1(1, 2);
Vector v2(3, 4);
Vector v3 = v1 + v2; // 使用重载的 + 运算符
return 0;
}在这个例子中，
operator+是
Vector类的一个成员函数。它接受另一个
Vector对象作为参数，并返回一个新的
Vector对象，其 x 和 y 分别是两个原始
Vector对象的 x 和 y 的和。
const修饰符表示该函数不会修改调用它的对象。
2. 非成员函数重载:
当运算符左侧的操作数不是该类的对象，或者需要对称性时，使用非成员函数重载。例如，重载
<<运算符，以便可以将
Vector对象输出到
std::cout：
#includeclass Vector { public: double x, y; Vector(double x = 0, double y = 0) : x(x), y(y) {} friend std::ostream& operator<<(std::ostream& os, const Vector& v); // 声明友元函数 }; std::ostream& operator<<(std::ostream& os, const Vector& v) { os << "(" << v.x << ", " << v.y << ")"; return os; } int main() { Vector v(1, 2); std::cout << v; // 使用重载的 << 运算符 return 0; }
这里，
operator<<是一个非成员函数，它接受一个
std::ostream对象和一个
Vector对象作为参数。它将
Vector对象的 x 和 y 输出到
std::ostream对象，并返回
std::ostream对象。由于该函数需要访问
Vector对象的私有成员，所以声明为
Vector类的友元函数。
C++ 运算符重载有哪些限制？
并非所有的运算符都可以重载。以下运算符不能被重载：
.
(成员访问运算符).*
,->*
(成员指针访问运算符)::
(作用域解析运算符)?:
(三元条件运算符)sizeof
(sizeof 运算符)typeid
(typeid 运算符)static_cast
,dynamic_cast
,const_cast
,reinterpret_cast
(类型转换运算符)
此外，运算符的优先级和结合性不能被改变。重载运算符也不能改变运算符的操作数数量。例如，你不能将一个一元运算符重载为二元运算符。
重载运算符时应该遵循哪些最佳实践？
-
保持一致性： 重载运算符应该使其行为与内置类型的行为类似。例如，如果你重载了
+
运算符，它应该执行加法操作，而不是其他任何操作。 - 避免歧义： 重载运算符不应该导致代码难以理解。如果一个运算符有多种可能的含义，那么最好不要重载它。
-
考虑性能： 重载运算符可能会影响性能。如果一个运算符被频繁使用，那么应该确保它的实现是高效的。使用
const
引用传递参数可以避免不必要的复制。 -
使用友元函数： 对于某些运算符，例如
<<
和>>
，使用友元函数可以更方便地访问类的私有成员。 - 避免过度重载： 不是每个运算符都需要重载。只有在重载运算符可以显著提高代码的可读性和表达力时，才应该考虑重载它。
如何重载自增和自减运算符（++ 和 --）？
C++ 中自增和自减运算符有前缀和后缀两种形式。为了区分这两种形式，后缀形式的重载函数需要一个
int类型的哑元参数。
class Counter {
private:
int value;
public:
Counter(int v = 0) : value(v) {}
// 前缀自增
Counter& operator++() {
++value;
return *this;
}
// 后缀自增
Counter operator++(int) {
Counter temp = *this; // 保存原始值
++value;
return temp; // 返回原始值
}
int getValue() const { return value; }
};
int main() {
Counter c(5);
std::cout << "Prefix: " << (++c).getValue() << std::endl; // 输出 6
std::cout << "Postfix: " << (c++).getValue() << std::endl; // 输出 6，但 c 的值现在是 7
std::cout << "Current: " << c.getValue() << std::endl; // 输出 7
return 0;
}前缀形式的
operator++()首先递增
value，然后返回递增后的对象的引用。后缀形式的
operator++(int)首先保存对象的原始值，然后递增
value，最后返回原始值的副本。这个
int参数只是一个占位符，用于区分前缀和后缀形式。
重载赋值运算符 (=) 时需要注意什么？
重载赋值运算符需要特别小心，以避免浅拷贝和内存泄漏。必须确保正确地复制对象的所有成员，包括指针指向的动态分配的内存。通常，需要遵循“复制构造函数、赋值运算符和析构函数”的三/五法则。
class String {
private:
char* data;
size_t length;
public:
String(const char* str = nullptr) : data(nullptr), length(0) {
if (str) {
length = strlen(str);
data = new char[length + 1];
strcpy(data, str);
}
}
// 复制构造函数
String(const String& other) : data(nullptr), length(0) {
length = other.length;
data = new char[length + 1];
strcpy(data, other.data);
}
// 赋值运算符
String& operator=(const String& other) {
if (this == &other) {
return *this; // 防止自赋值
}
// 释放旧内存
delete[] data;
// 分配新内存并复制数据
length = other.length;
data = new char[length + 1];
strcpy(data, other.data);
return *this;
}
// 析构函数
~String() {
delete[] data;
}
};在这个例子中，赋值运算符首先检查是否是自赋值，如果是，则直接返回
*this。然后，它释放旧的
data指向的内存，分配新的内存，并将
other对象的
data复制到新的内存中。这可以防止内存泄漏和悬挂指针。 复制构造函数和析构函数也需要正确地管理动态分配的内存。
