运算符重载允许为自定义类型赋予运算符新含义，提升
代码可读性
和维护性。1. 成员函数方式适用于需访问类私有成员或左操作数为该类对象的情况，如vector的加法运算符；2. 全局函数方式适用于左操作数非该类对象或需保持对称性，如complex类的加法运算符；3. 选择依据是运算符特性和设计需求，如输出运算符通常用全局函数；4. 应避免改变运算符原始语义、造成复杂性及重载逗号、&&、||运算符；5. 异常处理可通过try-catch实现，如除法运算中的除零检查；6. 运算符重载可与模板结合，实现通用代码，如mynumber类支持多种类型的加法操作。
运算符重载允许你用更自然的方式操作自定义类型，本质上就是赋予运算符新的含义。它可以通过成员函数或全局函数来实现，选择哪种方式取决于运算符的特性和你的设计需求。
解决方案
运算符重载，简单来说，就是让C++的运算符（如+、-、*、/等）能够作用于自定义的类或结构体。这能极大地提高代码的可读性和可维护性，让你的代码更贴近问题的本质。
成员函数方式
立即学习
“
C++免费学习笔记（深入）
”；
当运算符需要访问类的私有成员时，或者运算符的左操作数必须是该类的对象时，通常选择成员函数方式。
在这个例子中，
是
类的一个成员函数。它接受另一个
对象作为参数，并返回一个新的
对象，表示两个向量的和。注意
的使用，保证了操作不会修改原对象。
全局函数方式
C函数速查手册（CHM版）
C函数速查手册（CHM版）
下载
当运算符的左操作数不是该类的对象，或者为了对称性，通常选择全局函数方式。 全局函数需要声明为类的友元函数，才能访问类的私有成员。
这里，
是一个全局函数，它接受两个
对象作为参数，并返回一个新的
对象。由于
需要访问
类的私有成员
和
，因此它被声明为
类的友元函数。
选择哪种方式？
如果运算符的左操作数是该类的对象，且需要访问类的私有成员，则选择成员函数方式。
如果运算符的左操作数不是该类的对象，或者为了保持对称性，则选择全局函数方式。 例如，重载输出运算符
时，通常使用全局函数方式，因为
对象位于运算符的左侧。
何时应该避免运算符重载？
过度使用或不当使用运算符重载会降低代码的可读性和可维护性。应该避免在以下情况下使用运算符重载：
改变运算符的原始语义：
运算符重载应该保持其原始语义，避免引起混淆。 例如，不应该用
运算符来实现减法操作。
创建不必要的复杂性：
如果使用普通函数能够更清晰地表达操作，则不应该使用运算符重载。
重载逗号运算符、和：
重载这些运算符可能会导致短路求值行为失效，从而产生难以调试的错误。
如何处理运算符重载中的异常？
运算符重载也可能抛出异常。应该在适当的地方使用
块来捕获和处理这些异常。 例如，如果重载除法运算符
，应该检查除数是否为零，并抛出异常。
运算符重载与模板结合使用
运算符重载可以与模板结合使用，以实现更通用的代码。 例如，可以创建一个模板类，并重载运算符，使其能够处理不同类型的操作数。
这个例子展示了如何使用模板类
和运算符重载来实现对不同数值类型的加法操作。
class Vector {
private:
double x, y;
public:
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);
}
// 重载输出运算符 << (友元函数方式，后面会讲)
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 v1(1, 2);
Vector v2(3, 4);
Vector v3 = v1 + v2; // 使用重载的 + 运算符
std::cout << v3 << std::endl; // 输出 (4, 6)
return 0;
}operator+VectorVectorVectorconstclass Complex {
private:
double real, imag;
public:
Complex(double real = 0, double imag = 0) : real(real), imag(imag) {}
// 声明友元函数，允许全局函数访问私有成员
friend Complex operator+(const Complex& c1, const Complex& c2);
friend std::ostream& operator<<(std::ostream& os, const Complex& c);
};
// 重载加法运算符 +，全局函数方式
Complex operator+(const Complex& c1, const Complex& c2) {
return Complex(c1.real + c2.real, c1.imag + c2.imag);
}
std::ostream& operator<<(std::ostream& os, const Complex& c) {
os << c.real << "+" << c.imag << "i";
return os;
}
int main() {
Complex c1(1, 2);
Complex c2(3, 4);
Complex c3 = c1 + c2; // 使用重载的 + 运算符
std::cout << c3 << std::endl; // 输出 4+6i
return 0;
}operator+ComplexComplexoperator+ComplexrealimagComplex<<std::ostream+&&||try-catch/class Fraction {
private:
int numerator, denominator;
public:
Fraction(int numerator, int denominator) : numerator(numerator), denominator(denominator) {
if (denominator == 0) {
throw std::invalid_argument("Denominator cannot be zero.");
}
}
Fraction operator/(const Fraction& other) const {
if (other.numerator == 0) {
throw std::runtime_error("Cannot divide by zero.");
}
return Fraction(numerator * other.denominator, denominator * other.numerator);
}
};
int main() {
try {
Fraction f1(1, 2);
Fraction f2(0, 1);
Fraction f3 = f1 / f2; // 可能抛出异常
} catch (const std::exception& e) {
std::cerr << "Exception: " << e.what() << std::endl; // 输出错误信息
}
return 0;
}template
class MyNumber {
private:
T value;
public:
MyNumber(T value) : value(value) {}
MyNumber operator+(const MyNumber& other) const {
return MyNumber(value + other.value);
}
friend std::ostream& operator<<(std::ostream& os, const MyNumber& num) {
os << num.value;
return os;
}
};
int main() {
MyNumber num1(10);
MyNumber num2(20);
MyNumber num3 = num1 + num2;
std::cout << num3 << std::endl; // 输出 30
MyNumber d1(3.14);
MyNumber d2(2.71);
MyNumber d3 = d1 + d2;
std::cout << d3 << std::endl; // 输出 5.85
return 0;
} MyNumber