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) (C++11 起)
(C++23 起为 constexpr)

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

(2) (C++11 起)
(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) (C++11 起)
(C++26 起为 constexpr)

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

(4) (C++11 起)
(C++26 起为 constexpr)

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

(5) (C++11 起)
(C++26 起为 constexpr)

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

(6) (C++11 起)
(C++26 起为 constexpr)

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) (C++20 起)
(C++26 起为 constexpr)

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

(8) (C++11 起)
(C++23 起为 constexpr)

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

(9) (C++11 起)
(C++20 前)

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

(10) (C++11 起)
(C++20 前)

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

(11) (C++11 起)
(C++20 前)

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

(12) (C++11 起)
(C++23 起为 constexpr)

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

(13) (C++11 起)
(C++23 起为 constexpr)

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

(14) (C++11 起)
(C++23 起为 constexpr)

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

(15) (C++11 起)
(C++23 起为 constexpr)

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

(16) (C++11 起)
(C++23 起为 constexpr)

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

(17) (C++11 起)
(C++23 起为 constexpr)

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

(18) (C++11 起)
(C++23 起为 constexpr)

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

(19) (C++11 起)
(C++23 起为 constexpr)

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) (C++20 起)
(C++23 起为 constexpr)

3) std::less<CT>()(x.get(), y.get())，其中 CT 是 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))