| Defined in header <memory>
|
||
| 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.
unique_ptrs.unique_ptr and nullptr.|
The |
(since C++20) |
Parameters
| x, y | - | unique_ptrs to compare
|
Return value
x.get() == y.get()x.get() != y.get()std::less<CT>()(x.get(), y.get()), where CT is std::common_type<unique_ptr<T1, D1>::pointer, unique_ptr<T2, D2>::pointer>::type.!(y < x)y < x!(x < y)std::compare_three_way{}(x.get(), y.get())!x(bool)xstd::less<unique_ptr<T,D>::pointer>()(x.get(), nullptr) std::less<unique_ptr<T,D>::pointer>()(nullptr, y.get()) !(nullptr < x)!(y < nullptr)nullptr < xy < nullptr!(x < nullptr)!(nullptr < y)std::compare_three_way{}(x.get(), static_cast<typename unique_ptr<T, D>::pointer>(nullptr))Example
#include <iostream>
#include <memory>
int main()
{
std::unique_ptr<int> p1(new int(42));
std::unique_ptr<int> 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
}(p1 == p1) : true
(p1 <=> p1) == 0 : true
(p1 == p2) : false
(p1 < p2) : true
(p1 <=> p2) < 0 : true
(p1 <=> p2) == 0 : falseDefect 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 |
See also
| returns a pointer to the managed object (public member function) |
Content from this page on cppreference.com, licensed under CC-BY-SA 3.0 and GFDL. Modified: restyled, site navigation removed, code windows added. Offline snapshot of 9 February 2025.