21-7 重载比较运算符
在第6.7节——关系运算符与浮点数比较中，我们讨论了六种比较运算符。重载这些比较运算符相对简单（注意到我的双关了吗？），因为它们遵循与重载其他运算符相同的模式。
由于比较运算符均为二元运算符且不修改左操作数，我们将重载的比较运算符定义为友元函数。
以下是一个重载了 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>呢？一辆车比另一辆车大或小意味着什么？我们通常不会这样思考汽车。由于operator<和>operator>的结果难以直观理解，最好将这些运算符留空。
最佳实践:
仅为类定义符合直觉的重载运算符。
但上述建议存在一个常见例外：若需对汽车列表排序呢？此时可重载比较运算符，使其返回最常用于排序的成员（或成员组合）。例如，汽车的重载operator<可按品牌和型号字母顺序排序。
标准库中的某些容器类（用于存储其他类集合的类）需要重载operator<，以便保持元素排序。
以下示例重载了全部6个逻辑比较运算符：
#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;
}
这样一来，如果我们需要修改某些内容，只需更新运算符==和运算符<，而无需修改全部六个比较运算符！
太空船(spaceship)运算符 operator<=> (C++20)
C++20引入了太空船运算符（operator<=>），它能让我们最多只需编写2个比较函数，有时甚至只需1个！
作者注:
我们计划近期新增相关教程。在此之前，本文仅作为引子激发您的兴趣——若想深入了解，还需前往外部资源探索。
测验时间
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 }
{
// We put reduce() in the constructor to ensure any new fractions we make get reduced!
// Any fractions that are overwritten will need to be re-reduced
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);
}
显示解决方案
#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 }
{
// We put reduce() in the constructor to ensure any new fractions we make get reduced!
// Any fractions that are overwritten will need to be re-reduced
reduce();
}
void reduce()
{
int gcd{ std::gcd(m_numerator, m_denominator) };
if (gcd)
{
m_numerator /= gcd;
m_denominator /= gcd;
}
}
friend bool operator== (const Fraction& f1, const Fraction& f2);
friend bool operator!= (const Fraction& f1, const Fraction& f2);
friend bool operator< (const Fraction& f1, const Fraction& f2);
friend bool operator> (const Fraction& f1, const Fraction& f2);
friend bool operator<= (const Fraction& f1, const Fraction& f2);
friend bool operator>= (const Fraction& f1, const Fraction& f2);
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;
}
bool operator== (const Fraction& f1, const Fraction& f2)
{
return (f1.m_numerator == f2.m_numerator) && (f1.m_denominator == f2.m_denominator);
}
bool operator!= (const Fraction& f1, const Fraction& f2)
{
return !(operator==(f1, f2));
}
bool operator< (const Fraction& f1, const Fraction& f2)
{
return (f1.m_numerator * f2.m_denominator < f2.m_numerator * f1.m_denominator);
}
bool operator> (const Fraction& f1, const Fraction& f2)
{
return operator<(f2, f1);
}
bool operator<= (const Fraction& f1, const Fraction& f2)
{
return !(operator>(f1, f2));
}
bool operator>= (const Fraction& f1, const Fraction& f2)
{
return !(operator<(f1, f2));
}
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;
}
2.在课程开头的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()); // requires an overloaded operator<
for (const auto& car : cars)
std::cout << car << '\n'; // requires an overloaded operator<<
return 0;
}
该程序应输出以下结果：
若需复习 std::sort 的用法，请参阅第 18.1 课——使用选择排序对数组进行排序。
显示解决方案
#include <algorithm>
#include <iostream>
#include <string>
#include <string_view>
#include <vector>
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);
friend std::ostream& operator<<(std::ostream& out, const Car& c)
{
out << '(' << c.m_make << ", " << c.m_model << ')';
return out;
}
// h/t to reader Olivier for the initial version of the function
friend bool operator<(const Car& c1, const Car& c2)
{
if (c1.m_make != c2.m_make) // If the car is not the same make...
return c1.m_make < c2.m_make; // ...then compare the make
return c1.m_model < c2.m_model; // otherwise compare the model
}
};
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 !operator==(c1, c2);
}
int main()
{
std::vector<Car> cars{
{ "Toyota", "Corolla" },
{ "Honda", "Accord" },
{ "Toyota", "Camry" },
{ "Honda", "Civic" }
};
std::sort(cars.begin(), cars.end()); // requires an overloaded Car::operator<
for (const auto& car : cars)
std::cout << car << '\n'; // requires an overloaded Car::operator<<
return 0;
}
浙公网安备 33010602011771号