C++运算符重载通过成员或非成员函数实现，如Vector类重载+和<<运算符，前者用于对象相加，后者借助友元函数输出对象；不可重载的运算符包括.、::、?:等，且不能改变优先级与操作数数量；自增/减需区分前缀（返回引用）与后缀（带int哑元，返回副本）；赋值运算符需防自赋值并正确管理内存，遵循三/五法则避免泄漏。
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
：
#include <iostream> class 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
复制到新的内存中。这可以防止内存泄漏和悬挂指针。 复制构造函数和析构函数也需要正确地管理动态分配的内存。
c++ ai ios 作用域 运算符 赋值运算符 成员函数 构造函数 析构函数 const int 指针 重载运算符 重载函数 函数重载 运算符重载 operator 引用传递 类型转换 对象 作用域 一元运算符 this