《C++探幽：运算符重载》

《C++探幽:运算符重载》

一、引言

在C++中，运算符重载是一项非常强大的特性，它允许程序员重新定义运算符在自定义类型上的行为。通过运算符重载，我们可以让自定义类型（如类和结构体）的对象像内置类型一样使用运算符，从而使代码更加直观、易读且易于维护。

二、运算符重载的语法

运算符重载通过函数来实现，这些函数被称为运算符重载函数。运算符重载函数有两种形式：成员函数形式和非成员函数形式。

（一）成员函数形式

当运算符重载函数是类的成员函数时，其语法如下：

return_type operator运算符(参数列表);

例如，重载加号运算符：

class MyClass {
public:MyClass operator+(const MyClass& other) {// 实现加法运算符的逻辑}
};

在这种情况下，运算符的第一个操作数是该类的对象，而第二个操作数是参数列表中的参数。

（二）非成员函数形式

当运算符重载函数是类的友元函数或普通函数时，其语法如下：

return_type operator运算符(参数列表);

例如，重载加号运算符：

class MyClass {
public:friend MyClass operator+(const MyClass& a, const MyClass& b) {// 实现加法运算符的逻辑}
};

在这种情况下，运算符的两个操作数都是参数列表中的参数。

三、可重载的运算符

C++中并不是所有的运算符都可以被重载，以下是一些常见的可重载运算符：

算术运算符：+、-、、/、%、+=、-=、=、/=、%=
关系运算符：==、!=、<、>、<=、>=
逻辑运算符：!、||、&&
位运算符：~、&、|、^{、<<、>>、&=、|=、}=、<<=、>>=
自增自减运算符：++、–
赋值运算符：=
下标运算符：[]
函数调用运算符：()
箭头运算符：->

四、运算符重载示例

（一）重载双目运算符

以下是一个重载加号运算符的示例：

#include <iostream>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) {return Complex(real + other.real, imag + other.imag);}// 重载加号运算符（非成员函数形式）friend Complex operator+(const Complex& a, const Complex& b) {return Complex(a.real + b.real, a.imag + b.imag);}void display() const {std::cout << "(" << real << " + " << imag << "i)" << std::endl;}
};int main() {Complex c1(3.0, 4.0);Complex c2(1.0, 2.0);Complex c3 = c1 + c2; // 使用重载后的加号运算符c3.display(); // 输出：(4 + 6i)return 0;
}

（二）重载单目运算符

以下是一个重载自增运算符的示例：

#include <iostream>class Counter {
private:int count;public:Counter(int c = 0) : count(c) {}// 重载前置自增运算符Counter& operator++() {count++;return *this;}// 重载后置自增运算符Counter operator++(int) {Counter temp = *this;count++;return temp;}void display() const {std::cout << "Count: " << count << std::endl;}
};int main() {Counter c1(5);++c1; // 使用前置自增运算符c1.display(); // 输出：Count: 6Counter c2(5);c2++; // 使用后置自增运算符c2.display(); // 输出：Count: 6return 0;
}

（三）重载比较运算符

以下是一个重载等于运算符的示例：

#include <iostream>
#include <string>class Person {
private:std::string name;int age;public:Person(const std::string& n, int a) : name(n), age(a) {}// 重载等于运算符bool operator==(const Person& other) const {return (name == other.name) && (age == other.age);}void display() const {std::cout << "Name: " << name << ", Age: " << age << std::endl;}
};int main() {Person p1("Alice", 25);Person p2("Alice", 25);Person p3("Bob", 30);if (p1 == p2) {std::cout << "p1 and p2 are the same person." << std::endl;} else {std::cout << "p1 and p2 are different persons." << std::endl;}if (p1 == p3) {std::cout << "p1 and p3 are the same person." << std::endl;} else {std::cout << "p1 and p3 are different persons." << std::endl;}return 0;
}

（四）重载自定义类型与内置类型的运算符

以下是一个重载自定义类型与内置类型的加法运算符的示例：

#include <iostream>
#include <string>class String {
private:std::string str;public:String(const std::string& s) : str(s) {}// 重载加法运算符，允许将String对象与std::string对象相加String operator+(const std::string& other) {return String(str + other);}// 重载加法运算符，允许将std::string对象与String对象相加friend String operator+(const std::string& a, const String& b) {return String(a + b.str);}void display() const {std::cout << str << std::endl;}
};int main() {String s1("Hello, ");std::string s2 = "World!";String s3 = s1 + s2; // 使用String对象与std::string对象相加s3.display(); // 输出：Hello, World!String s4 = s2 + s1; // 使用std::string对象与String对象相加s4.display(); // 输出：World!Hello, return 0;
}