Espacios de nombres
Variantes
Acciones

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

De cppreference.com
< cpp‎ | memory‎ | unique ptr
 
C++
Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas
 
Biblioteca de servicios
 
Gestión de memoria dinámica
Punteros inteligentes
(C++11)
(C++11)
(C++11)
(hasta C++17)
(C++11)
(C++11)
(C++11)
(C++11)
(C++23)
(C++23)
Asignadores de memoria
(C++11)
(C++23)
(C++23)
(C++11)
(C++11)
(C++11)
(C++20)
(C++20)
(C++20)
(C++11)
(C++17)
Recursos de memoria
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
Almacenamiento no inicializado
(hasta C++20)
(hasta C++20)
(hasta C++20)
Algoritmos de memoria no inicializada
Algoritmos restringidos de memoria no inicializada
Apoyo para recolección de basura
(C++11)(hasta C++23)
(C++11)(hasta C++23)
(C++11)(hasta C++23)
(C++11)(hasta C++23)
(C++11)(hasta C++23)
(C++11)(hasta C++23)
Misceláneos
(C++11)
(C++20)
(C++11)
(C++11)
(C++20)
 
std::unique_ptr
 
Definido en el archivo de encabezado <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) (desde 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) (desde C++11)
(hasta 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) (desde 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) (desde 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) (desde 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) (desde 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) (desde C++20)
template< class T, class D >
bool operator==( const unique_ptr<T, D>& x, std::nullptr_t) noexcept;
 (8) (desde C++11)
(constexpr since C++23)
template< class T, class D >
bool operator==(std::nullptr_t, const unique_ptr<T, D>& x) noexcept;
 (9) (desde C++11)
(hasta C++20)
template< class T, class D >
bool operator!=( const unique_ptr<T, D>& x, std::nullptr_t) noexcept;
 (10) (desde C++11)
(hasta C++20)
template< class T, class D >
bool operator!=(std::nullptr_t, const unique_ptr<T, D>& x) noexcept;
 (11) (desde C++11)
(hasta C++20)
template< class T, class D >
bool operator<( const unique_ptr<T, D>& x, std::nullptr_t );
 (12) (desde C++11)
(constexpr since C++23)
template< class T, class D >
bool operator<(std::nullptr_t, const unique_ptr<T, D>& y );
 (13) (desde C++11)
(constexpr since C++23)
template< class T, class D >
bool operator<=( const unique_ptr<T, D>& x, std::nullptr_t );
 (14) (desde C++11)
(constexpr since C++23)
template< class T, class D >
bool operator<=(std::nullptr_t, const unique_ptr<T, D>& y );
 (15) (desde C++11)
(constexpr since C++23)
template< class T, class D >
bool operator>( const unique_ptr<T, D>& x, std::nullptr_t );
 (16) (desde C++11)
(constexpr since C++23)
template< class T, class D >
bool operator>(std::nullptr_t, const unique_ptr<T, D>& y );
 (17) (desde C++11)
(constexpr since C++23)
template< class T, class D >
bool operator>=( const unique_ptr<T, D>& x, std::nullptr_t );
 (18) (desde C++11)
(constexpr since C++23)
template< class T, class D >
bool operator>=(std::nullptr_t, const unique_ptr<T, D>& y );
 (19) (desde 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) (desde C++20)
(constexpr since C++23)

Compara los valores de puntero de dos objetos unique_ptr, o un objeto unique_ptr y nullptr.

1-7) Compara dos objetos unique_ptr.
8-20) Compara un objeto unique_ptr y nullptr.

El operador != se sintetiza a partir de operator==.

(desde C++20)

Contenido

[editar] Parámetros

x, y - Objetos unique_ptr a comparar.

[editar] Valor de retorno

1) x.get() == y.get().
2) x.get() != y.get().
3) std::less<CT>()(x.get(), y.get()), donde CT es 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)).

[editar] Ejemplo

Ejecuta este código
#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' // desde 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'   // desde C++20
        << "(p1 <=> p2) == 0 : " << ((p1 <=> p2) == 0) << '\n'; // desde C++20
}

Posible salida: 

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

[editar] Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID Aplicado a Comportamiento según lo publicado Comportamiento correcto
LWG 3426 C++20 operator<=>(unique_ptr, nullptr_t) estaba mal formado. Se corrigieron las restricciones y la definición.

[editar] Véase también

 Devuelve un puntero al objeto gestionado.
(función miembro pública) [editar]
Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/memory/unique_ptr/operator_cmp&oldid=41645»