重载比较运算符

在关系运算符与浮点数比较中，我们讨论了六种比较运算符。重载这些比较运算符相对简单（注意到我的双关了吗？），因为它们遵循我们已见过的其他运算符重载模式。

由于所有比较运算符均为二元运算符且不修改其左操作数，我们将把重载后的比较运算符实现为友元函数。

下面给出带有重载 operator== 和 operator!= 的 Car 类示例：

#include <iostream>
#include <string>
#include <string_view>

class Car
{
private:
    std::string m_make;
    std::string m_model;

public:
    Car(std::string_view make, std::string_view model)
        : m_make{ make }, m_model{ model }
    {
    }

    friend bool operator== (const Car& c1, const Car& c2);
    friend bool operator!= (const Car& c1, const Car& c2);
};

bool operator== (const Car& c1, const Car& c2)
{
    return (c1.m_make == c2.m_make &&
            c1.m_model == c2.m_model);
}

bool operator!= (const Car& c1, const Car& c2)
{
    return (c1.m_make != c2.m_make ||
            c1.m_model != c2.m_model);
}

int main()
{
    Car corolla{ "Toyota", "Corolla" };
    Car camry{ "Toyota", "Camry" };

    if (corolla == camry)
        std::cout << "a Corolla and Camry are the same.\n";

    if (corolla != camry)
        std::cout << "a Corolla and Camry are not the same.\n";

    return 0;
}

上述代码应当一目了然。

那么 operator< 和 operator> 呢？对于 Car 来说，“大于”或“小于”另一辆汽车意味着什么？我们通常不会这样思考汽车。由于 operator< 和 operator> 的结果并不直观，最好将它们留作未定义。

最佳实践
仅当重载运算符对类而言具有直观语义时才进行定义。

然而，上述建议有一个常见例外：如果我们希望对汽车列表进行排序，此时可能需要重载比较运算符，使其返回最可能用于排序的成员。例如，Car 的重载 operator< 可按品牌和型号字母顺序排序。

标准库中的某些容器类（用于存储其他类的集合）要求重载 operator<，以便保持元素有序。

下面给出重载全部 6 个逻辑比较运算符的 Cents 示例：

#include <iostream>

class Cents
{
private:
    int m_cents;

public:
    Cents(int cents)
        : m_cents{ cents }
    {}

    friend bool operator== (const Cents& c1, const Cents& c2);
    friend bool operator!= (const Cents& c1, const Cents& c2);

    friend bool operator< (const Cents& c1, const Cents& c2);
    friend bool operator> (const Cents& c1, const Cents& c2);

    friend bool operator<= (const Cents& c1, const Cents& c2);
    friend bool operator>= (const Cents& c1, const Cents& c2);
};

bool operator== (const Cents& c1, const Cents& c2)
{
    return c1.m_cents == c2.m_cents;
}

bool operator!= (const Cents& c1, const Cents& c2)
{
    return c1.m_cents != c2.m_cents;
}

bool operator> (const Cents& c1, const Cents& c2)
{
    return c1.m_cents > c2.m_cents;
}

bool operator< (const Cents& c1, const Cents& c2)
{
    return c1.m_cents < c2.m_cents;
}

bool operator<= (const Cents& c1, const Cents& c2)
{
    return c1.m_cents <= c2.m_cents;
}

bool operator>= (const Cents& c1, const Cents& c2)
{
    return c1.m_cents >= c2.m_cents;
}

int main()
{
    Cents dime{ 10 };
    Cents nickel{ 5 };

    if (nickel > dime)
        std::cout << "a nickel is greater than a dime.\n";
    if (nickel >= dime)
        std::cout << "a nickel is greater than or equal to a dime.\n";
    if (nickel < dime)
        std::cout << "a dime is greater than a nickel.\n";
    if (nickel <= dime)
        std::cout << "a dime is greater than or equal to a nickel.\n";
    if (nickel == dime)
        std::cout << "a dime is equal to a nickel.\n";
    if (nickel != dime)
        std::cout << "a dime is not equal to a nickel.\n";

    return 0;
}

本例同样十分直观。

最小化比较冗余

在上述示例中，请注意各重载比较运算符的实现何其相似。重载的比较运算符往往冗余度极高；实现越复杂，冗余越多。

幸运的是，许多比较运算符可由其他运算符实现：

operator!= 可写为 !(operator==)
operator> 可通过交换 operator< 参数顺序实现
operator>= 可写为 !(operator<)
operator<= 可写为 !(operator>)

这意味着我们仅需实现 operator== 与 operator< 的逻辑，其余四个运算符均可由这两者派生！下面给出更新后的 Cents 示例：

#include <iostream>

class Cents
{
private:
    int m_cents;

public:
    Cents(int cents)
        : m_cents{ cents }
    {}

    friend bool operator== (const Cents& c1, const Cents& c2) { return c1.m_cents == c2.m_cents; }
    friend bool operator!= (const Cents& c1, const Cents& c2) { return !(operator==(c1, c2)); }

    friend bool operator< (const Cents& c1, const Cents& c2) { return c1.m_cents < c2.m_cents; }
    friend bool operator> (const Cents& c1, const Cents& c2) { return operator<(c2, c1); }

    friend bool operator<= (const Cents& c1, const Cents& c2) { return !(operator>(c1, c2)); }
    friend bool operator>= (const Cents& c1, const Cents& c2) { return !(operator<(c1, c2)); }

};

int main()
{
    Cents dime{ 10 };
    Cents nickel{ 5 };

    if (nickel > dime)
        std::cout << "a nickel is greater than a dime.\n";
    if (nickel >= dime)
        std::cout << "a nickel is greater than or equal to a dime.\n";
    if (nickel < dime)
        std::cout << "a dime is greater than a nickel.\n";
    if (nickel <= dime)
        std::cout << "a dime is greater than or equal to a nickel.\n";
    if (nickel == dime)
        std::cout << "a dime is equal to a nickel.\n";
    if (nickel != dime)
        std::cout << "a dime is not equal to a nickel.\n";

    return 0;
}

如此，若需修改逻辑，仅更新 operator== 与 operator< 即可，无需改动全部六个运算符！

C++20 的三向比较运算符 <=>

C++20 引入三向比较运算符（operator<=>），可将需编写的比较函数数量减至最多 2 个，有时甚至仅需 1 个！

作者注
我们计划尽快新增一课专门讨论此主题。在此之前，请将此视为激发兴趣的预告——如需深入了解，请自行查阅其他资料。

测验

为 Fraction 类添加六个比较运算符，使以下程序得以编译：

#include <iostream>
#include <numeric> // for std::gcd

class Fraction
{
private:
    int m_numerator{};
    int m_denominator{};

public:
    Fraction(int numerator = 0, int denominator = 1) :
        m_numerator{ numerator }, m_denominator{ denominator }
    {
        // 在构造函数中调用 reduce() 以保证所有新分数均已约分！
        // 任何被覆盖的分数需重新约分
        reduce();
    }

    void reduce()
    {
        int gcd{ std::gcd(m_numerator, m_denominator) };
        if (gcd)
        {
            m_numerator /= gcd;
            m_denominator /= gcd;
        }
    }

    friend std::ostream& operator<<(std::ostream& out, const Fraction& f1);
};

std::ostream& operator<<(std::ostream& out, const Fraction& f1)
{
    out << f1.m_numerator << '/' << f1.m_denominator;
    return out;
}

int main()
{
    Fraction f1{ 3, 2 };
    Fraction f2{ 5, 8 };

    std::cout << f1 << ((f1 == f2) ? " == " : " not == ") << f2 << '\n';
    std::cout << f1 << ((f1 != f2) ? " != " : " not != ") << f2 << '\n';
    std::cout << f1 << ((f1 < f2) ? " < " : " not < ") << f2 << '\n';
    std::cout << f1 << ((f1 > f2) ? " > " : " not > ") << f2 << '\n';
    std::cout << f1 << ((f1 <= f2) ? " <= " : " not <= ") << f2 << '\n';
    std::cout << f1 << ((f1 >= f2) ? " >= " : " not >= ") << f2 << '\n';
    return 0;
}

若使用 C++17 之前的编译器，可用以下函数替换 std::gcd：

#include <cmath>

int gcd(int a, int b) {
    return (b == 0) ? std::abs(a) : gcd(b, a % b);
}

解答

为课程开头的 Car 类添加重载的 operator« 与 operator<，使以下程序得以编译：

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>

int main()
{
  std::vector<Car> cars{
    { "Toyota", "Corolla" },
    { "Honda", "Accord" },
    { "Toyota", "Camry" },
    { "Honda", "Civic" }
  };

  std::sort(cars.begin(), cars.end()); // 需要重载 operator<

  for (const auto& car : cars)
    std::cout << car << '\n'; // 需要重载 operator<<

  return 0;
}

该程序应输出：

(Honda, Accord)
(Honda, Civic)
(Toyota, Camry)
(Toyota, Corolla)

若需回顾 std::sort，请参阅。

测验

解答

关注公众号，回复"cpp-tutorial"