Сравнение двух объектов одного класса

0

Я пытаюсь перегрузить оператор == в 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. Есть ли кто-нибудь, кто может мне помочь?

Теги:
operators
operator-overloading

4 ответа

5
Лучший ответ

Бинарный оператор типа == может быть перегружен либо как функция-член с единственным параметром (this левый операнд, а параметр, являющийся правым), или как функция, не являющаяся членом, с двумя параметрами для два операнда.

Таким образом, либо

  • переместите объявление оператора за пределы объявления класса (перемещение определения в исходный файл или объявление его в inline если вы сохраните определение в заголовке); или
  • добавьте friend в определение, чтобы он объявлял не-член в окружающем пространстве имен; или
  • удалите первый аргумент из функции-члена, используя this вместо этого.

Как член, это будет выглядеть

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

Вы также можете сравнить два целочисленных значения напрямую, чтобы сэкономить затраты на создание строк. Вы также должны удалить изгоев ; после определения функций и пространств имен, хотя большинство современных компиляторов не должны возражать против их присутствия.

1

Перегрузка может выполняться внутри или вне определения класса. Если вы хотите сделать это внутри, функция получает только один аргумент. Вы должны сравнить 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 объектов, а не создавать строку и сравнивать их.

1

Ваша функция сравнения была записана для того, чтобы взять два 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). Оператор, не являющийся членом, дает более симметричную операцию.

1

Хотя ваш вопрос плохо сформулирован, я считаю, что вы спрашиваете, почему оператор, который вы определили, не работает?

Если вы определяете оператор как член класса, он принимает только один параметр. Например:

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

Ещё вопросы

Сообщество Overcoder
Наверх
Меню