Здравствуйте, LaptevVV, Вы писали:

LVV>Вот смотри, интерфейс класса
LVV>

class Fraction final{
LVV>    [/b]
LVV>    // преобразование в int - целая часть дроби
LVV>    operator int() const noexcept;
LVV>    // дружественные функции
LVV>};
LVV>

Естественно, в коде реализация отсутствует.
LVV>Нет никаких определений операций сравнения.
LVV>Но!Вот такой код работает абсолютно правильно:
LVV>

LVV>    Fraction A {3};                    // целое = <3/1>
LVV>    Fraction B {6,4};                  // дробь = <3/2>
LVV>    cout << A << B << endl;
LVV>// это работает - почему ?
LVV>    cout << std::boolalpha
LVV>         << (A == B) << '\n'  // false
LVV>         << (A != B) << '\n'  // true
LVV>         << (A <  B) << '\n'  // false
LVV>         << (A <= B) << '\n'  // false
LVV>         << (A >  B) << '\n'  // true
LVV>         << (A >= B) << '\n'; // true
LVV>

LVV>Трехстроннее сравнение автоматом синтезируется ?
LVV>Или обычные сравнения автоматом синтезируется ?

А ты неявный оператор приведения к инту не пробовал объявить явным, или вообще убрать?

LVV>В результате код со сравнениями выдает именно то, что и ожидалось

а если сравнить 2/5 и 1/2, какая будет меньше?
или 2/4 и 1/2 -- будут ли равны?

LVV>>А если трехстороннее сравнение не определено в классе, чего тогда делается ?
LVV>>Понятно, что равенство и неравенство можно сгенерить (но и тут есть нюансы).
LVV>>А операция МЕНЬШЕ — генерится ?
LVV>>И какой из трех вариантов порядка соблюдается ?
B>А если попробовать?
А то я не пробовал
Вот смотри, интерфейс класса

class Fraction final{
  public:
    struct divide_by_zero {};               // типы исключения
    struct denumerator_is_zero {};
    // конструкторы
    Fraction() = default;
    Fraction(int numerator) noexcept;       // конструктор преобразования
    Fraction(int num, int denum);           // 2 аргумента
    // методы
    std::string toString() const;
    // операции
    Fraction& operator+=(const Fraction &R) noexcept;
    Fraction& operator-=(const Fraction &R) noexcept;
    Fraction& operator*=(const Fraction &R) noexcept;
    Fraction& operator/=(const Fraction &R);
    Fraction& operator++() noexcept;
    Fraction& operator--() noexcept;
    // трехстороннее сравнение
   //int operator<=>(const Fraction&) const noexcept;
    
    // преобразование в int - целая часть дроби
    operator int() const noexcept;
    // дружественные функции
    friend std::istream& operator>>(std::istream& t, Fraction &r);
  private:
    int num {0}, denum{1};              // поля закрыты
    void reduce();                      // сокращение дроби
};

Естественно, в коде реализация отсутствует.
Нет никаких определений операций сравнения.
Но!Вот такой код работает абсолютно правильно:

    Fraction A {3};                    // целое = <3/1>
    Fraction B {6,4};                  // дробь = <3/2>
    cout << A << B << endl;
// это работает - почему ?
    cout << std::boolalpha
         << (A == B) << '\n'  // false
         << (A != B) << '\n'  // true
         << (A <  B) << '\n'  // false
         << (A <= B) << '\n'  // false
         << (A >  B) << '\n'  // true
         << (A >= B) << '\n'; // true

Трехстроннее сравнение автоматом синтезируется ?
Или обычные сравнения автоматом синтезируется ?

R>А ты неявный оператор приведения к инту не пробовал объявить явным, или вообще убрать?
Да, блин!
Неявные преобразования — зло абсолютное!
Спасибо.
Свежий взгляд мгновенно видит...

Здравствуйте, K13, Вы писали:

LVV>>В результате код со сравнениями выдает именно то, что и ожидалось

K13>а если сравнить 2/5 и 1/2, какая будет меньше?

Так прямо в примере же есть ответ на этот вопрос:

    Fraction A {3};                 // целое = <3/1>
    Fraction B {6,4};           // дробь = <3/2>
    // . . .
         << (A <  B) << '\n'  // true

Вот завели в С++20 операцию трехстороннего сравнения.
Компилятор при ее реализации в классе генерит на ее основе правильные логические выражения с обычными операция сравнения.

А если трехстороннее сравнение не определено в классе, чего тогда делается ?
Понятно, что равенство и неравенство можно сгенерить (но и тут есть нюансы).
А операция МЕНЬШЕ — генерится ?
И какой из трех вариантов порядка соблюдается ?

Здравствуйте, LaptevVV, Вы писали:

LVV>Вот завели в С++20 операцию трехстороннего сравнения.
LVV>Компилятор при ее реализации в классе генерит на ее основе правильные логические выражения с обычными операция сравнения.

LVV>А если трехстороннее сравнение не определено в классе, чего тогда делается ?
LVV>Понятно, что равенство и неравенство можно сгенерить (но и тут есть нюансы).
LVV>А операция МЕНЬШЕ — генерится ?
LVV>И какой из трех вариантов порядка соблюдается ?

А если попробовать?

https://godbolt.org/z/3vEaxr9Yr

Такой код просто не скомпилируется.

Ну, вот.
Наконец-то получилось именно то, что я с самого начала и ожидал.
1. Объявил операцию трехстороннего сравнения в классе по дефолту

auto operator<=>(const Fraction& r) const noexcept = default;

В результате код со сравнениями выдает именно то, что и ожидалось

    Fraction A {3};                 // целое = <3/1>
    Fraction B {6,4};           // дробь = <3/2>
    cout << A << B << endl;
    cout << std::boolalpha
         << (A == B) << '\n'  // false
         << (A != B) << '\n'  // true
         << (A <  B) << '\n'  // true
         << (A <= B) << '\n'  // true
         << (A >  B) << '\n'  // false
         << (A >= B) << '\n'; // false

LVV>>В результате код со сравнениями выдает именно то, что и ожидалось

K13>а если сравнить 2/5 и 1/2, какая будет меньше?
Лексикографически 2/5 > 1/2, та как 2 > 1
Но я реализовал правильное сравнение.
K13>или 2/4 и 1/2 -- будут ли равны?
Будут — у меня автоматом сокращение идет.