operator==,!=,<,<=,>,>=,<=>(std::unique_ptr) - cppreference.com

template< class T1, class D1, class T2, class D2 >
bool operator==( const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y );

(1) (since C++11)
(constexpr since C++23)

template< class T1, class D1, class T2, class D2 >
bool operator!=( const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y );

(2) (since C++11)
(until C++20)

template< class T1, class D1, class T2, class D2 >
bool operator<( const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y );

(3) (since C++11)
(constexpr since C++26)

template< class T1, class D1, class T2, class D2 >
bool operator<=( const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y );

(4) (since C++11)
(constexpr since C++26)

template< class T1, class D1, class T2, class D2 >
bool operator>( const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y );

(5) (since C++11)
(constexpr since C++26)

template< class T1, class D1, class T2, class D2 >
bool operator>=( const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y );

(6) (since C++11)
(constexpr since C++26)

template< class T1, class D1, class T2, class D2 >
    requires std::three_way_comparable_with<
        typename unique_ptr<T1, D1>::pointer,
        typename unique_ptr<T2, D2>::pointer>
std::compare_three_way_result_t<typename unique_ptr<T1, D1>::pointer,
                                typename unique_ptr<T2, D2>::pointer>
    operator<=>( const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y );

(7) (since C++20)
(constexpr since C++26)

template< class T, class D >
bool operator==( const unique_ptr<T, D>& x, std::nullptr_t ) noexcept;

(8) (since C++11)
(constexpr since C++23)

template< class T, class D >
bool operator==( std::nullptr_t, const unique_ptr<T, D>& x ) noexcept;

(9) (since C++11)
(until C++20)

template< class T, class D >
bool operator!=( const unique_ptr<T, D>& x, std::nullptr_t ) noexcept;

(10) (since C++11)
(until C++20)

template< class T, class D >
bool operator!=( std::nullptr_t, const unique_ptr<T, D>& x ) noexcept;

(11) (since C++11)
(until C++20)

template< class T, class D >
bool operator<( const unique_ptr<T, D>& x, std::nullptr_t );

(12) (since C++11)
(constexpr since C++23)

template< class T, class D >
bool operator<( std::nullptr_t, const unique_ptr<T, D>& y );

(13) (since C++11)
(constexpr since C++23)

template< class T, class D >
bool operator<=( const unique_ptr<T, D>& x, std::nullptr_t );

(14) (since C++11)
(constexpr since C++23)

template< class T, class D >
bool operator<=( std::nullptr_t, const unique_ptr<T, D>& y );

(15) (since C++11)
(constexpr since C++23)

template< class T, class D >
bool operator>( const unique_ptr<T, D>& x, std::nullptr_t );

(16) (since C++11)
(constexpr since C++23)

template< class T, class D >
bool operator>( std::nullptr_t, const unique_ptr<T, D>& y );

(17) (since C++11)
(constexpr since C++23)

template< class T, class D >
bool operator>=( const unique_ptr<T, D>& x, std::nullptr_t );

(18) (since C++11)
(constexpr since C++23)

template< class T, class D >
bool operator>=( std::nullptr_t, const unique_ptr<T, D>& y );

(19) (since C++11)
(constexpr since C++23)

template< class T, class D >
    requires std::three_way_comparable<typename unique_ptr<T, D>::pointer>
std::compare_three_way_result_t<typename unique_ptr<T, D>::pointer>
    operator<=>( const unique_ptr<T, D>& x, std::nullptr_t );

(20) (since C++20)
(constexpr since C++23)

Compares the pointer values of two unique_ptrs, or a unique_ptr and nullptr.

1-7) Compares two unique_ptrs.

8-20) Compares a unique_ptr and nullptr.

3) std::less<CT>()(x.get(), y.get()), where CT is std::common_type<unique_ptr<T1, D1>::pointer, unique_ptr<T2, D2>::pointer>::type.

20) std::compare_three_way{}(x.get(), static_cast<typename unique_ptr<T, D>::pointer>(nullptr))

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.