Ответ 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 использует для записи этих операторов для вас.