Question

我试图在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。有没有人可以帮助我？

Answer 1

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

所以要么

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

作为会员，它看起来像

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

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

Answer 2

您的比较函数已被编写为接受两个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）。非成员运算符提供更对称的操作。

Answer 3

虽然你的问题措辞不合理，但我相信你在问为什么你所定义的运营商没有工作？

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

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 ...

Answer 4

重载可以在类定义的内部或外部完成。如果你想在里面做，那么函数只接收一个参数。您应该将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而不是制作字符串并比较它们会更快。

比较同一类的两个对象

4 个答案: