C++运算符重载（Operator Overloading）

在 C++ 中，运算符重载（Operator Overloading）是一种特殊的函数重载机制，允许我们重新定义已有的运算符的行为。通过运算符重载，我们可以定义自定义类型的对象在使用运算符时的行为，使其能够执行类似于内置类型的操作。

运算符重载的语法形式为：

返回类型 operator 运算符 (参数列表) {
    // 运算符重载的实现
    // 返回结果
}

其中，operator 是关键字，用于指定要重载的运算符，例如 +、-、* 等。运算符重载函数可以是类的成员函数，也可以是全局函数。

以下是运算符重载的一些常见示例：

1. 算术运算符重载：

   class Vector {
   public:
       int x, y;
   
       Vector operator+(const Vector& other) {
           Vector result;
           result.x = this->x + other.x;
           result.y = this->y + other.y;
           return result;
       }
   };
   
   int main() {
       Vector v1{1, 2};
       Vector v2{3, 4};
       Vector sum = v1 + v2;  // 使用重载的加法运算符
       // sum.x 等于 4，sum.y 等于 6
       return 0;
   }
   

   在上述示例中，我们定义了一个名为 Vector 的类，并重载了加法运算符 +。通过重载的加法运算符，我们可以实现两个 Vector 对象的相加，并返回结果。

2. 关系运算符重载：

   class Person {
   private:
       int age;
   
   public:
       Person(int age) : age(age) {}
   
       bool operator>(const Person& other) {
           return this->age > other.age;
       }
   };
   
   int main() {
       Person p1(30);
       Person p2(25);
       if (p1 > p2) {
           // 执行某些操作
       }
       return 0;
   }
   

   在上述示例中，我们定义了一个名为 Person 的类，并重载了大于运算符 >。通过重载的大于运算符，我们可以比较两个 Person 对象的年龄。

3. 输入/输出运算符重载：

   class Point {
   public:
       int x, y;
   
       friend ostream& operator<<(ostream& os, const Point& p) {
           os << "(" << p.x << ", " << p.y << ")";
           return os;
       }
   };
   
   int main() {
       Point p{3, 4};
       cout << p;  // 使用重载的输出运算符
       // 输出：(3, 4)
       return 0;
   }
   

   在上述示例中，我们定义了一个名为 Point 的类，并重载了输出运算符 <<。通过重载的输出运算符，我们可以以自定义的方式输出 Point 对象。

4. 递增运算符（Increment Operator）包括前置递增运算符 ++ 和后置递增运算符 ++。可以通过运算符重载来定义自定义类型对象的递增操作。

• 前置递增运算符重载：
  前置递增运算符 ++ 返回递增后的对象的引用。在重载前置递增运算符时，需要将其定义为类的成员函数，并不需要传入任何参数。

示例：

class Counter {
private:
    int count;

public:
    Counter(int value = 0) : count(value) {}

    Counter& operator++() {
        count++;
        return *this;
    }

    int getCount() const {
        return count;
    }
};

int main() {
    Counter c(5);
    ++c;  // 使用前置递增运算符
    cout << c.getCount();  // 输出：6
    return 0;
}

在上述示例中，定义了一个名为 Counter 的类，并重载了前置递增运算符 ++。重载函数的返回类型是引用 Counter&，递增操作在函数中实现。通过前置递增运算符，我们可以递增 Counter 对象的值。

• 后置递增运算符重载：
  后置递增运算符 ++ 返回递增前的对象的副本。在重载后置递增运算符时，需要在函数参数列表中增加一个（并不会被使用的）整数参数，以便区分前置和后置递增运算符。

示例：

class Counter {
private:
    int count;

public:
    Counter(int value = 0) : count(value) {}

    Counter operator++(int) {
        Counter temp = *this;
        count++;
        return temp;
    }

    int getCount() const {
        return count;
    }
};

int main() {
    Counter c(5);
    Counter result = c++;  // 使用后置递增运算符
    cout << c.getCount();  // 输出：6
    cout << result.getCount();  // 输出：5
    return 0;
}

在上述示例中，同样是定义了一个名为 Counter 的类，并重载了后置递增运算符 ++。重载函数的参数列表中增加了一个整数参数，并在函数中返回递增前的对象的副本。通过后置递增运算符，我们可以递增 Counter 对象的值，并返回递增前的对象的副本。

前置递增和后置递增运算符的行为略有不同。前置递增运算符直接修改对象本身，并返回递增后的对象的引用。后置递增运算符先返回递增前的对象的副本，再对对象进行递增操作。因此，在使用时需要根据需求选择合适的递增运算符。

5. 函数调用运算符 () 可以通过运算符重载来定义自定义类型对象的函数调用操作。通过重载函数调用运算符，我们可以使对象看起来像函数一样被调用，实现类似函数的行为。

函数调用运算符重载的语法形式为：

返回类型 operator() (参数列表) {
    // 函数调用运算符重载的实现
    // 返回结果
}

以下是函数调用运算符重载的示例：

class Adder {
public:
    int operator()(int a, int b) {
        return a + b;
    }
};

int main() {
    Adder add;
    int result = add(3, 4);  // 使用函数调用运算符
    // result 等于 7
    return 0;
}

在上述示例中，定义了一个名为 Adder 的类，并重载了函数调用运算符 (). 重载函数的参数列表中包含要传递给函数调用运算符的参数。通过函数调用运算符重载，我们可以将 Adder 对象 add 当作函数来使用，接收两个参数并返回它们的和。

函数调用运算符重载可以具有任意数量和类型的参数，可以根据需要进行自定义。这使得我们可以在自定义类型中实现类似函数的行为，为对象提供更灵活的使用方式。

6. 赋值运算符 = 可以通过运算符重载来定义自定义类型对象的赋值操作。通过重载赋值运算符，我们可以自定义对象之间的赋值行为，使其能够进行深拷贝或其他特定的操作。

赋值运算符重载的语法形式为：

返回类型 operator= (const 类型& 右操作数) {
    // 赋值运算符重载的实现
    // 返回当前对象的引用
}

以下是赋值运算符重载的示例：

class MyString {
private:
    char* data;

public:
    MyString(const char* str = nullptr) {
        if (str == nullptr) {
            data = nullptr;
        } else {
            int length = strlen(str);
            data = new char[length + 1];
            strcpy(data, str);
        }
    }

    // 赋值运算符重载
    MyString& operator=(const MyString& other) {
        if (this == &other) {
            return *this;
        }

        delete[] data;

        if (other.data == nullptr) {
            data = nullptr;
        } else {
            int length = strlen(other.data);
            data = new char[length + 1];
            strcpy(data, other.data);
        }

        return *this;
    }

    // 其他成员函数和析构函数...

};

在上述示例中，定义了一个名为 MyString 的类，并重载了赋值运算符 =。重载函数的参数是常量引用 const MyString& other，表示右操作数为另一个 MyString 对象。在重载函数中，我们首先检查自我赋值情况，如果是自我赋值，直接返回当前对象的引用。然后，释放当前对象的内存，根据右操作数的情况进行深拷贝或指针置空操作。最后，返回当前对象的引用。

通过赋值运算符重载，我们可以使自定义类型对象能够像内置类型一样使用赋值运算符进行赋值操作。需要注意的是，在进行赋值运算符重载时，需要注意资源的管理和释放，避免内存泄漏和悬挂指针的问题。另外，还可以根据具体需求，实现其他特定的赋值行为。

在上述示调用例中，我们创建了两个 MyString 对象 str1 和 str2。然后，通过赋值运算符重载将 str1 的值赋给 str2，即 str2 = str1;。赋值运算符重载函数被调用，执行自定义的赋值操作，将 str1 的值复制给 str2。
赋值运算符重载的实现可以根据具体需求进行自定义，可以实现深拷贝、浅拷贝或其他特定的赋值操作。在实现赋值运算符重载时，需要注意资源的管理和释放，确保避免内存泄漏和悬挂指针的问题。

---

通过运算符重载，我们可以使用自定义类型的对象像使用内置类型一样进行各种运算和操作，使代码更加直观和易读。需要注意的是，在使用运算符重载时，应确保重载的行为符合直觉和常规用法，避免引起歧义和混淆。