operator==,!=,<,<=,>,>=,<=>(std::unique_ptr)

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.

1-7) Compares two unique_ptrs.

8-20) Compares a unique_ptr and nullptr.

The != operator is synthesized from operator==.

(since C++20)

Parameters

x, y - unique_ptrs to compare

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)

7) std::compare_three_way { } (x.get ( ), y.get ( ) )

8,9) !x

10,11) (bool)x

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

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

14) !(nullptr < x)

15) !(y < nullptr)

16) nullptr < x

17) y < nullptr

18) !(x < nullptr)

19) !(nullptr < y)

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

Example

Run this code

#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
}

Possible output:

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

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

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

Member functions
unique_ptr::unique_ptr
unique_ptr::~unique_ptr
unique_ptr::operator=
Modifiers
unique_ptr::release
unique_ptr::reset
unique_ptr::swap
Observers
unique_ptr::get
unique_ptr::get_deleter
unique_ptr::operator bool
unique_ptr::operator*unique_ptr::operator->
unique_ptr::operator[]
Non-member functions
make_uniquemake_unique_for_overwrite (C++14)(C++20)
operator==operator!=operator<operator>operator<=operator>=operator<=> (until C++20)(C++20)
operator<< (C++20)
swap(std::unique_ptr)
Helper classes
hash<std::unique_ptr>

operator==,!=,<,<=,>,>=,<=>(std::unique_ptr)

Parameters

Return value

Example

Defect reports

See also

Navigation