В C++ для оператора, большего или равного ("> ="), достаточно ли иметь операторов, равных ("=") и большего (">"), перегруженных, чтобы иметь функциональность для большего или равного to ("> =")? Или мне нужно перегрузить оператор ("> ="), чтобы иметь для него функциональность?
С++ больше или равно оператору
Ответ 1
Используя очевидные обозначения, ">" || "==" на самом деле является избыточным требованием для "> =".
Хотя обратите внимание, что для всех реляционных операторов вам действительно нужно "<", поскольку эквивалентность устанавливается, если a <b и b <a являются ложными. На самом деле это одно из понятий, используемых в стандартных библиотечных контейнерах C++.
Ответ 2
достаточно, чтобы операторы были равны ("=")
Равным оператором в c++ является ==
ИЛИ мне нужно перегрузить оператор ("> ="), чтобы иметь функциональность для него?
Это зависит от функциональности. Если вы имеете в виду, что если вы определяете operator==
и operator>
то компилятор будет генерировать operator>=
автоматически для вас? Нет, это не так, вы должны реализовать его с помощью существующих операторов или нет.
Ответ 3
operator >=
не является комбинацией operator >
и operator =
. operator >=
- это собственный оператор, но вы можете реализовать его в терминах operator <
Обычно у вас есть что-то вроде
inline bool operator==(const X& lhs, const X& rhs){ /* do actual comparison */ } inline bool operator!=(const X& lhs, const X& rhs){return !operator==(lhs,rhs);} inline bool operator< (const X& lhs, const X& rhs){ /* do actual comparison */ } inline bool operator> (const X& lhs, const X& rhs){return operator< (rhs,lhs);} inline bool operator<=(const X& lhs, const X& rhs){return !operator> (lhs,rhs);} inline bool operator>=(const X& lhs, const X& rhs){return !operator< (lhs,rhs);}
От sbi answer on Какие основные правила и идиомы для перегрузки оператора?
Ответ 4
Нет, C++ не записывает эти операторы для вас.
Если вы считаете, что это отстой, вы правы. Было сделано несколько способов сделать это сосать. Я расскажу о 4 из них.
Подождите, пока c++20
В c++20, если вы правильно напишете operator<=>
(трехсторонний "космический корабль") или =default
, то все <
, <=
, >=
, >
!=
И ==
будут записаны для тебя.
struct bob {
int x,y;
auto operator<=>( bob const& )const = default;
};
В приведенном выше bob
есть каждый оператор <
==
etc, написанный для него C++.
Просто напишите им
До c++20 вы должны написать все, если хотите, все из них. Это утомительно и подвержено ошибкам.
Использование std::tie
и invoking <
и т.д. На них немного меньше подвержено ошибкам:
struct bob {
int x, y;
friend bool operator<( bob const& lhs, bob const& rhs ) {
return std::tie(lhs.x, lhs.y) < std::tie(rhs.x, rhs.y);
}
};
или даже
struct bob {
int x, y;
friend auto as_tie( bob const& b ) { // C++14
return std::tie(b.x, b.y);
}
friend bool operator<( bob const& lhs, bob const& rhs ) {
return as_tie(lhs) < as_tie(rhs);
}
};
потому что tuple
выполняет надлежащее лексическое сравнение; написание лессографических сравнений без ошибок раздражает.
Метапрограмму вокруг тебя
При сравнении строк вы обычно используете strcmp
. Это возвращает отрицательное число, если меньше, положительное число, если больше, и 0, если оно равно. Этот шаблон может быть более эффективным, чем повторение <
or ==
.
Создание одной подобной функции strcmp
создает <
==
а другие операции сравнения могут быть выполнены:
namespace utils {
template<class D>
struct use_cmp {
friend bool operator<( use_cmp<D> const& lhs, use_cmp<D> const& rhs ) {
return cmp( lhs.self(), rhs.self() ) < 0;
}
friend bool operator>( use_cmp<D> const& lhs, use_cmp<D> const& rhs ) {
return cmp( lhs.self(), rhs.self() ) > 0;
}
friend bool operator<=( use_cmp<D> const& lhs, use_cmp<D> const& rhs ) {
return cmp( lhs.self(), rhs.self() ) <= 0;
}
friend bool operator>=( use_cmp<D> const& lhs, use_cmp<D> const& rhs ) {
return cmp( lhs.self(), rhs.self() ) >= 0;
}
friend bool operator==( use_cmp<D> const& lhs, use_cmp<D> const& rhs ) {
return cmp( lhs.self(), rhs.self() ) == 0;
}
friend bool operator!=( use_cmp<D> const& lhs, use_cmp<D> const& rhs ) {
return cmp( lhs.self(), rhs.self() ) != 0;
}
private:
D const& self() const { return *static_cast<D const*>(this); }
};
}
Теперь предположим, что у нас есть тип:
struct bob {
int x, y;
};
и мы хотим иметь возможность использовать на нем операторы сравнения:
struct bob : utils::use_cmp<bob>
{
int x, y;
bob( int x_, int y_ ):x(x_), y(y_) {} // constructor
friend int cmp( bob const& lhs, bob const& rhs ) {
if (lhs.x < rhs.x) return -1;
if (lhs.x > rhs.x) return 1;
if (lhs.y < rhs.y) return -1;
if (lhs.y > rhs.y) return 1;
return 0;
}
};
и при использовании магии CRTP bob
теперь есть каждый оператор сравнения, написанный для него.
Этот раздражающий friend int cmp
(который становится более раздражающим, чем больше у вас есть в нем) может обрабатываться еще более вспомогательным кодом шаблона:
namespace utils {
template<class...Ts>
int cmp( std::tuple<Ts...> const& lhs, std::tuple<Ts...> const& rhs );
template<class T, class...LowPriority>
int cmp( T const& lhs, T const& rhs, LowPriority&&... );
template<class...Ts, std::size_t...Is>
int tuple_cmp( std::tuple<Ts...> const& lhs, std::tuple<Ts...> const& rhs, std::index_sequence<Is...> ) {
int result = 0;
( (result = cmp( std::get<Is>(lhs), std::get<Is>(rhs) )) && ... );
return result;
}
template<class...Ts>
int cmp( std::tuple<Ts...> const& lhs, std::tuple<Ts...> const& rhs ) {
return tuple_cmp( lhs, rhs, std::make_index_sequence<sizeof...(Ts)>{} );
}
template<class T, class...LowPriority>
int cmp( T const& lhs, T const& rhs, LowPriority&&... ) {
if (lhs < rhs) return -1;
if (rhs < lhs) return 1;
return 0;
}
}
который является еще более загадочным кодом, но вы получаете более простой bob
:
struct bob : utils::use_cmp<bob>
{
int x, y;
bob( int x_, int y_ ):x(x_), y(y_) {}
friend auto as_tie(bob const& b) {
return std::tie(b.x,b.y);
}
friend int cmp( bob const& lhs, bob const& rhs ) {
return utils::cmp( as_tie(lhs), as_tie(rhs) );
}
};
Обратите внимание, однако, что все это сделано и лучше с помощью operator<=>
в c++20.
Использовать другое решение
Это похоже на подход boost :: operator использует для записи этих операторов для вас.