Namespaces
Variants

    operator==(std::expected)

    С сайта ru.cppreference.net
     
    C++
    Поддержка компиляторов
    Автономные и под управлением среды
    Язык
    Стандартная библиотека
    Заголовки стандартной библиотеки
    Именованные требования
    Макросы проверки возможностей (C++20)
    Библиотека поддержки языка
    Библиотека концепций (C++20)
    Библиотека диагностики
    Библиотека управления памятью
    Библиотека метапрограммирования (C++11)
    Библиотека общих утилит
    Библиотека контейнеров
    Библиотека итераторов
    Библиотека диапазонов (C++20)
    Библиотека алгоритмов
    Библиотека строк
    Библиотека обработки текста
    Библиотека численных расчетов
    Библиотека даты и времени
    Библиотека ввода/вывода
    Библиотека файловой системы (C++17)
    Библиотека поддержки параллелизма (C++11)
    Библиотека управления выполнением (C++26)
    Технические спецификации
    Указатель символов
    Внешние библиотеки
     
    Библиотека утилит
    Поддержка языка
    Поддержка типов (базовые типы, RTTI)
    Макросы проверки возможностей библиотеки (C++20)
    Утилиты программ
    Функции с переменным числом аргументов
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Поддержка корутин (C++20)
    Поддержка контрактов (C++26)
    Трёхстороннее сравнение
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Общие утилиты
    Операторы отношений (устарело в C++20)
     
    std::expected
     
    Основной шаблон
    		 
    template< class T2, class E2 >
    requires (!std::is_void_v<T2>)
friend constexpr bool operator==( const expected& lhs,
                                  const std::expected<T2, E2>& rhs );
    		(1) (начиная с C++23) 
    template< class E2 >
friend constexpr bool operator==( const expected& lhs,
                                  const std::unexpected<E2>& unex );
    		(2) (начиная с C++23) 
    template< class T2 >
friend constexpr bool operator==( const expected& lhs, const T2& val );
    		(3) (начиная с C++23)
    void частичная специализация
    		 
    template< class T2, class E2 >
  requires std::is_void_v<T2>
friend constexpr bool operator==( const expected& lhs,
                                  const std::expected<T2, E2>& rhs );
    		(4) (начиная с C++23) 
    template< class E2 >
friend constexpr bool operator==( const expected& lhs,
                                  const std::unexpected<E2>& unex );
    		(5) (начиная с C++23)

    Выполняет операции сравнения для объектов типа std::expected.

    1) Сравнивает два объекта std::expected. Объекты равны тогда и только тогда, когда оба lhs и rhs содержат ожидаемые значения, которые равны, или оба содержат неожиданные значения, которые равны.

    Если любое из следующих выражений некорректно, или его результат не преобразуется в bool, программа считается некорректной:

    		(до C++26)

    Эта перегрузка участвует в разрешении перегрузки только если все следующие выражения корректны, и их результаты преобразуются в bool:

    		(начиная с C++26)
    • *lhs == *rhs
    • lhs.error() == rhs.error()
    2) Сравнивает объект std::expected с объектом std::unexpected. Объекты равны тогда и только тогда, когда lhs содержит неожиданное значение, которое равно unex.error().

    Если выражение lhs.error() == unex.error() некорректно, или его результат не преобразуется в bool, программа считается некорректной.

    		(до C++26)

    Эта перегрузка участвует в разрешении перегрузки только если выражение lhs.error() == unex.error() корректно, и его результат преобразуется в bool.

    		(начиная с C++26)
    3) Сравнивает объект std::expected с ожидаемым значением. Объекты равны тогда и только тогда, когда lhs содержит ожидаемое значение, которое равно val.

    Если выражение *lhs == val некорректно, или его результат не преобразуется в bool, программа считается некорректной.

    		(до C++26)

    Эта перегрузка участвует в разрешении перегрузки только если выполняются все следующие условия:

    • T2 не является специализацией std::expected.
    • Выражение *lhs == val корректно, и его результат преобразуется в bool.
    		 (начиная с C++26)
    4) Сравнивает два объекта std::expected. Объекты равны тогда и только тогда, когда lhs и rhs оба представляют ожидаемые значения, или оба содержат неожиданные значения, которые равны.

    Если выражение lhs.error() == rhs.error() некорректно, или его результат не преобразуется в bool, программа считается некорректной.

    		(до C++26)

    Эта перегрузка участвует в разрешении перегрузки только если выражение lhs.error() == rhs.error() корректно, и его результат преобразуется в bool.

    		(начиная с C++26)
    5) Сравнивает объект std::expected с объектом std::unexpected. Объекты равны тогда и только тогда, когда lhs содержит неожиданное значение, которое равно unex.error().

    Если выражение lhs.error() == unex.error() некорректно, или его результат не преобразуется в bool, программа считается некорректной.

    		(до C++26)

    Эта перегрузка участвует в разрешении перегрузки только если выражение lhs.error() == unex.error() корректно, и его результат преобразуется в bool.

    		(начиная с C++26)

    Эти функции не видны при обычном неквалифицированном или квалифицированном поиске, и могут быть найдены только поиском, зависящим от аргументов, когда std::expected<T, E> является ассоциированным классом для аргументов.

    Оператор != синтезируется из operator==.

    Параметры

    lhs, rhs - std::expected объект(ы) для сравнения
    unex - std::unexpected значение для сравнения с lhs
    val - значение для сравнения с ожидаемым значением, содержащимся в lhs

    Возвращаемое значение

    1)
    lhs. has_value ( ) ! = rhs. has_value ( ) ? false :
    ( lhs. has_value ( ) ? * lhs == * rhs : lhs. error ( ) == rhs. error ( ) )
    2) ! lhs. has_value ( ) && static_cast < bool > ( lhs. error ( ) == unex. error ( ) )
    3) lhs. has_value ( ) && static_cast < bool > ( * lhs == val )

    4)
    lhs. has_value ( ) ! = rhs. has_value ( ) ? false :
    lhs. has_value ( ) || static_cast < bool > ( lhs. error ( ) == rhs. error ( ) )
    5) ! lhs. has_value ( ) && static_cast < bool > ( lhs. error ( ) == unex. error ( ) )

    Исключения

    Выбрасывает, когда и что выбрасывает сравнение.

    Примечания

    Макрос тестирования возможностей Значение Стандарт Функция
    __cpp_lib_constrained_equality 202411L (C++26) ограниченные операторы сравнения для std::expected

    Пример

    Запустить этот код 
    #include <expected>
#include <iostream>
#include <string_view>
using namespace std::string_view_literals;
int main()
{
    auto x1{"\N{GREEN HEART}"sv};
    auto x2{"\N{CROSS MARK}"sv};
    std::expected<std::string_view, int> e1{x1}, e2{x1}, e3{x2};
    std::unexpected u1{13};
    std::cout << "Overload (1):\n"
              << e1.value() << (e1 == e2 ? " == " : " != ") << *e2 << '\n'
              << e1.value() << (e1 != e3 ? " != " : " == ") << *e3 << "\n\n";
    std::cout << "Overload (2):\n"
              << e1.value() << (e1 == u1 ? " == " : " != ") << u1.error() << '\n';
    e1 = std::unexpected{13};
    std::cout << e1.error() << (e1 == u1 ? " == " : " != ") << u1.error() << '\n';
    e1 = std::unexpected{31};
    std::cout << e1.error() << (e1 != u1 ? " != " : " == ") << u1.error() << '\n';
    std::cout << "Overload (3):\n"
              << *e1 << (e1 == x1 ? " == " : " != ") << x1 << '\n'
              << *e1 << (e1 != x2 ? " != " : " == ") << x2 << "\n\n";
}

    Вывод: 

    Overload (1):
💚 == 💚
💚 != ❌
Overload (2):
💚 != 13
13 == 13
31 != 13
Overload (3):
💚 == 💚
💚 != ❌

    Смотрите также

    (C++23)
    		сравнивает std::unexpected объекты
    (шаблон функции)