比较同一类的两个对象

Comparing two objects of the same class

本文关键字：两个 对象 一类 比较      更新时间：2023-10-16

我正在尝试重载C++中的==运算符。 

#include <string>
using namespace std;
namespace date_independent
{
    class clock
    {
        public:
            int clockPair[2] = {0,0};
            operator string() const
            {
                string hourString;
                string minString;
                if(clockPair[0]<10)
                {
                    hourString = "0"+to_string(clockPair[0]);
                }
                else
                {
                    hourString = to_string(clockPair[0]);
                }
                if(clockPair[1]<10)
                {
                    minString  = "0"+to_string(clockPair[1]);
                }
                else
                {
                    minString = to_string(clockPair[1]);
                }
                return hourString+":"+minString;
            };
            bool operator ==(const clock&clockOne, const clock&clockTwo) const
            {
                return string(clockOne)==string(clockTwo);
            };
    };
};

代码比我包含的代码要多得多，但这是重要的部分。我希望它使==运算符可以比较类clock的两个对象。例如，object1==object2 .有人可以帮助我吗？

像==这样的二元运算符可以重载为具有单个参数的成员函数（this是左侧操作数，参数是右侧操作数），也可以作为具有两个操作数的两个参数的非成员函数。

所以要么

  • 将运算符声明移到类声明之外（将定义移动到源文件，或者如果将定义保留在标头中，则inline声明它）;或
  • 将friend添加到定义中，以便它在周围的命名空间中声明非成员;或
  • 从成员函数中删除第一个参数，改用this。

作为成员，它看起来像

bool operator==(const const & clockTwo) const {
    return string(*this) == string(clockTwo);
}

您可能还希望直接比较两个整数值，以节省创建字符串的费用。您还应该删除函数和命名空间定义之后的恶意;，尽管大多数现代编译器不应反对它们的存在。

您的比较函数已被编写为获取两个clock对象并进行比较，因此它应该是一个非成员函数（在类定义之后），没有const限定符。

bool operator==(const clock& clockOne, const clock& clockTwo)
{
    return string(clockOne) == string(clockTwo);
}

当你在类定义中有一个运算符时，左手参数会隐式为你提供（它是*this），所以如果你想在那里实现它，你需要这样的东西：

bool operator==(const clock& clockTwo) const
{
    return string(*this) == string(clockTwo);
}
尽管如此，不

建议==这样做，因为如果您已经说了另一种类型的隐式构造函数T，您将无法使用成员版本编写代码 ala my_t == my_clock，除非T提供了合适的比较运算符（用于clock或string）。 非成员运算符提供更对称的操作。

重载可以在类定义内部或外部完成。如果要在内部执行此操作，则该函数仅接收一个参数。您应该将this与该论点进行比较。

bool operator ==(const clock&clockTwo) const
{
    return string(*this)==string(clockTwo);
}

请注意参数后面的const，这意味着您不会更改函数内部的this。另一方面，如果你想在类定义之外执行此操作，它需要两个参数，你应该比较它们。

bool operator ==(const clock&clockOne, const clock&clockTwo)
{
    return string(clockOne)==string(clockTwo);
}

另请注意，比较对象的 clockPair 会比制作字符串并比较它们更快。

虽然你的问题措辞不好，但我相信你在问为什么你定义的运算符不起作用？

如果将运算符定义为类的成员，则它只需要一个参数。例如：

class clock {
    bool operator ==(const clock& rhsClock) const
    {
        // Note: this is the lhsClock
        return string(*this) == string(otherClock);
    }
};

当您将运算符定义为自由函数（而不是类的一部分）时，您需要定义两个参数：

class clock {
    // ... class declaration ...
};
bool operator ==(const clock& lhsClock, const clock& rhsClock)
{
    return string(lhsClock) == string(rhsClock)
}

其中比较如下所示：

if (lhsClock == rhsClock) // ... do something ...
相关文章：