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

Defined in header
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)
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)
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)
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)
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)
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.

The != operator is synthesized from operator==. (since C++20)

[edit] Parameters

x, y - unique_ptrs to compare

[edit] Return value

  1. x.get() == y.get()

  2. x.get() != y.get()

  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.

  4. !(y < x)

  5. y < x

  6. !(x < y)

8,9) !x

10,11) (bool)x

  1. std::less<unique_ptr<T,D>::pointer>()(x.get(), nullptr)

  2. std::less<unique_ptr<T,D>::pointer>()(nullptr, y.get())

  3. !(nullptr < x)

  4. !(y < nullptr)

  5. nullptr < x

  6. y < nullptr

  7. !(x < nullptr)

  8. !(nullptr < y)

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

[edit] Example

#include #include   int main() { std::unique_ptr p1(new int(42)); std::unique_ptr p2(new int(42));   std::cout << std::boolalpha << "(p1 == p1)  : " << (p1 == p1) << '\n' << "(p1 <=> p1) == 0 : " << ((p1 <=> p1) == 0) << '\n' // Since C++20   // p1 and p2 point to different memory locations, so p1 != p2 << "(p1 == p2)  : " << (p1 == p2) << '\n' << "(p1 < p2)  : " << (p1 < p2) << '\n' << "(p1 <=> p2) < 0  : " << ((p1 <=> p2) < 0) << '\n' // Since C++20 << "(p1 <=> p2) == 0 : " << ((p1 <=> p2) == 0) << '\n'; // Since C++20 }

Possible output:

(p1 == p1)  : true (p1 <=> p1) == 0 : true (p1 == p2)  : false (p1 < p2)  : true (p1 <=> p2) < 0  : true (p1 <=> p2) == 0 : false

[edit] Defect reports

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

DR Applied to Behavior as published Correct behavior
LWG 3426 C++20 operator<=>(unique_ptr, nullptr_t) was ill-formed constraints and definition fixed

[edit] See also

| | returns a pointer to the managed object (public member function) [edit] | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |