编辑“︁C++ 关系运算符重载”︁

{{DISPLAYTITLE:C++关系运算符重载}}

== 简介 ==
'''关系运算符重载'''是C++中一种强大的特性，允许程序员为自定义类重新定义关系运算符（如<code>==</code>, <code>!=</code>, <code><</code>, <code>></code>, <code><=</code>, <code>>=</code>）的行为。通过重载这些运算符，可以像内置类型一样比较自定义类的对象，使代码更直观和易读。

关系运算符通常返回布尔值（<code>true</code>或<code>false</code>），表示两个对象之间的比较结果。例如，比较两个<code>Date</code>类对象是否相等，或比较两个<code>Student</code>类对象的年龄大小。

== 语法 ==
关系运算符重载的一般语法如下：
<syntaxhighlight lang="cpp">
bool operator==(const ClassName& obj1, const ClassName& obj2) {
    // 比较逻辑
    return /* 比较结果 */;
}
</syntaxhighlight>

运算符可以重载为类的成员函数或全局函数。以下是两种方式的对比：

{| class="wikitable"
|-
! 成员函数重载 !! 全局函数重载
|-
| <syntaxhighlight lang="cpp">
class ClassName {
public:
    bool operator==(const ClassName& other) const {
        // 比较逻辑
    }
};
</syntaxhighlight> || <syntaxhighlight lang="cpp">
bool operator==(const ClassName& obj1, const ClassName& obj2) {
    // 比较逻辑
}
</syntaxhighlight>
|}
<br>

== 示例：重载<code>==</code>和<code>!=</code>运算符 ==
以下是一个完整的示例，展示如何为<code>Date</code>类重载<code>==</code>和<code>!=</code>运算符：
<syntaxhighlight lang="cpp">
#include <iostream>

class Date {
private:
    int day, month, year;

public:
    Date(int d, int m, int y) : day(d), month(m), year(y) {}

    // 成员函数重载 ==
    bool operator==(const Date& other) const {
        return day == other.day && month == other.month && year == other.year;
    }

    // 成员函数重载 !=
    bool operator!=(const Date& other) const {
        return !(*this == other); // 复用 == 的实现
    }
};

int main() {
    Date date1(15, 6, 2023);
    Date date2(15, 6, 2023);
    Date date3(20, 12, 2024);

    std::cout << "date1 == date2: " << (date1 == date2) << std::endl; // 输出 1 (true)
    std::cout << "date1 != date3: " << (date1 != date3) << std::endl; // 输出 1 (true)
    return 0;
}
</syntaxhighlight>

'''输出：'''
<pre>
date1 == date2: 1
date1 != date3: 1
</pre>

== 示例：重载<code><</code>和<code>></code>运算符 ==
以下示例为<code>Student</code>类重载<code><</code>和<code>></code>运算符，基于学生的分数比较：
<syntaxhighlight lang="cpp">
#include <iostream>
#include <string>

class Student {
private:
    std::string name;
    int score;

public:
    Student(std::string n, int s) : name(n), score(s) {}

    // 成员函数重载 <
    bool operator<(const Student& other) const {
        return score < other.score;
    }

    // 成员函数重载 >
    bool operator>(const Student& other) const {
        return score > other.score;
    }
};

int main() {
    Student alice("Alice", 85);
    Student bob("Bob", 90);

    std::cout << "Alice < Bob: " << (alice < bob) << std::endl; // 输出 1 (true)
    std::cout << "Alice > Bob: " << (alice > bob) << std::endl; // 输出 0 (false)
    return 0;
}
</syntaxhighlight>

'''输出：'''
<pre>
Alice < Bob: 1
Alice > Bob: 0
</pre>

== 实际应用场景 ==
关系运算符重载在以下场景中非常有用：
1. '''排序与比较'''：在STL容器（如<code>std::sort</code>或<code>std::set</code>）中，重载<code><</code>运算符可以直接对自定义类对象排序。
2. '''数据验证'''：例如，验证两个<code>BankAccount</code>对象的余额是否相等。
3. '''游戏开发'''：比较游戏角色的属性（如生命值、攻击力等）。

=== 案例：STL排序 ===
以下代码展示如何使用重载的<code><</code>运算符对<code>Student</code>对象排序：
<syntaxhighlight lang="cpp">
#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<Student> students = {
        Student("Alice", 85),
        Student("Bob", 90),
        Student("Charlie", 75)
    };

    std::sort(students.begin(), students.end()); // 使用重载的 < 运算符

    for (const auto& s : students) {
        std::cout << s.getName() << ": " << s.getScore() << std::endl;
    }
    return 0;
}
</syntaxhighlight>

'''输出：'''
<pre>
Charlie: 75
Alice: 85
Bob: 90
</pre>

== 注意事项 ==
1. '''一致性'''：如果重载了<code>==</code>，通常也应该重载<code>!=</code>，反之亦然。同理适用于<code><</code>和<code>></code>等。
2. '''返回值类型'''：关系运算符应返回<code>bool</code>类型。
3. '''参数类型'''：参数通常为<code>const</code>引用，以避免不必要的拷贝。

== 关系运算符重载的数学基础 ==
关系运算符的定义应符合数学上的等价关系：
* 自反性：<math>a == a</math> 必须为真。
* 对称性：如果 <math>a == b</math>，则 <math>b == a</math>。
* 传递性：如果 <math>a == b</math> 且 <math>b == c</math>，则 <math>a == c</math>。

== 总结 ==
关系运算符重载是C++中实现自定义类型比较的重要工具。通过合理重载这些运算符，可以使代码更简洁、直观，并与其他C++特性（如STL）无缝集成。

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 运算符重载]]