Identificador de nodo (C++17)
| template</*sin especificar*/> class /*node-handle*/; |
(desde C++17) | |
Los contenedores asociativos std::set, std::map, std::multiset, std::multimap, std::unordered_set, std::unordered_map, std::unordered_multiset, y std::unordered_multimap son estructuras de datos basadas en nodos, y sus nodos pueden extraerse como un objeto de tipo no especificado conocido como identificador de nodo (node handle).
Un identificador de nodo es un tipo de solo-movimiento que posee y proporciona acceso al elemento (el tipo de valor o value_type) almacenado en el nodo, y proporciona acesso no-const a la parte clave del elemento (el tipo de clave o key_type) y la parte correspondida del elemento (el tipo correspondido o mapped_type). Si el identificador de nodo se destruye mientras mantiene el nodo, el nodo se destruye apropiadamente usando el asignador de memoria apropiado para el contenedor. El identificador de nodo contiene una copia del asignador de memoria del contenedor. Esto es necesario para que el identificador de nodo pueda sobrevivir al contenedor.
El tipo exacto del identificador de nodo (que se muestra aquí como /*node-handle*/) está sin especificar, pero cada contenedor expone su tipo de identificador de nodo como el miembro node_type.
Los identificadores de nodo se pueden utilizar para transferir la propiedad de un elemento entre dos contenedores asociativos con la misma clave, valor y tipo de asignador (ignorando la comparación o hash/igualdad), sin invocar ninguna operación de copia/movimiento en el elemento contenedor (este tipo de funcionamiento se conoce como "empalme" (splicing)). También se permite la transferencia entre contenedores únicos y no únicos: un identificador de nodo de un std::map se puede insertar en un std::multimap, pero no en std::unordered_map o std::set.
Un identificador de nodo puede estar vacío, en cuyo caso no contiene ningún elemento ni asignador. Un identificador de nodo construido por defecto o uno que ha sido movido está vacío. Además, se puede producir un identificador de nodo vacío mediante una llamada fallida a la función miembro del contenedor extract.
Los punteros y referencias a un elemento que se obtienen mientras es propiedad de un identificador de nodo se invalidan si el elemento se inserta correctamente en un contenedor.
Para todos los contenedores mapas (std::map, std::multimap, std::unordered_map, y std::unordered_multimap) cuyo tipo clave key_type es K y tipo correspondido mapped_type es T, el comportamiento de las operaciones que involucran identificadores de nodos está indefinido si existe una especialización definida por el usuario de std::pair para std::pair<K, T> o std::pair<const K, T>.
Contenido |
[editar] Tipos miembro
| Tipo miembro | Definición |
key_type
|
Key
|
mapped_type
|
T
|
allocator_type
|
El asignador de memoria a usar al destruir el elemento. |
[editar] Funciones miembro
constructores
| constexpr /*node-handle*/() noexcept; |
(1) | |
| /*node-handle*/(/*node-handle*/&& nh) noexcept; |
(2) | |
nh, construye el miembro asignador mediante movimiento, y deja a nh en el estado vacío.Parámetros
| nh | - | Un identificador de nodo con el mismo tipo (no necesariamente el mismo contenedor). |
Notas
Los identificadores de nodo son de solo-movimiento, el constructor de copia no está definido.
operator=
| /*node-handle*/& operator=(/*node-handle*/&& nh); |
||
- Si el identificador de nodo no está vacío,
- destruye el subobjeto
value_typeen el objeto elemento del contenedor gestionado por este identificador de nodo llamando astd::allocator_traits<allocator_type>::destroy; - desasigna el elemento del contenedor llamando a
allocator_traits<allocator_type>::rebind_traits<container-node-type>::deallocate;
- destruye el subobjeto
- Adquiere propiedad del elemento del contenedor de
nh. - Si el identificador de nodo estaba vacío (y así que no contenía un asignador) o si
allocator_traits<allocator_type>::propagate_on_container_move_assignmentestrue, mueve-asigna el asignador denh. - Establece
nhal estado vacío.
El comportamiento está indefinido si el nodo no está vacío y allocator_traits<allocator_type>::propagate_on_container_move_assignment es false y los asignadores no se comparan iguales.
Parámetros
| nh | - | Un identificador de nodo con el mismo tipo (no necesariamente el mismo contenedor). |
Valor de retorno
*this
Excepciones
(Ninguna)
Notas
Los identificadores de nodo son de solo-movimiento, la asignación de copia no está definida.
destructor
| ~/*node-handle*/(); |
||
- Si el identificador de nodo no está vacío,
- destruye el subobjeto
value_typeen el objeto elemento del contenedor gestionado por este identificador de nodo llamando astd::allocator_traits<allocator_type>::destroy; - desasigna el elemento del contenedor llamando a
allocator_traits<allocator_type>::rebind_traits<container-node-type>::deallocate.
- destruye el subobjeto
empty
| bool empty() const noexcept; |
(hasta C++20) | |
| [[nodiscard]] bool empty() const noexcept; |
(desde C++20) | |
Devuelve true si el identificador de nodo está vacío; de lo contrario, false.
operator bool
| explicit operator bool() const noexcept; |
||
Convierte a false si el identificador de nodo está vacío; de lo contrario, true.
get_allocator
| allocator_type get_allocator() const; |
||
Devuelve una copia del asignador almacenado (que es una copia del asignador del contenedor fuente). El comportamiento está indefinido si el identificador de nodo está vacío.
Excepciones
(Ninguna)
value
| value_type& value() const; |
(solo contenedores set) | |
Devuelve una referencia al subobjeto value_type en el objeto elemento del contenedor gestionado por este identificador de nodo. El comportamiento está indefinido si el identificador de nodo está vacío.
Excepciones
(Ninguna)
key
| key_type& key() const; |
(solo contenedores map) | |
Devuelve una referencia no const al miembro key_type del subobjeto value_type en el objeto elemento del contenedor gestionado por este identificador de nodo. El comportamiento está indefinido si el identificador de nodo está vacío.
Excepciones
(Ninguna)
Notas
Esta función hace posible modificar la clave de un nodo extraído de un mapa, y luego reinsertarlo en el mapa, sin siquiera copiar o mover el elemento.
mapped
| mapped_type& mapped() const; |
(map containers only) | |
Devuelve una referencia al miembro mapped_type del subobjeto value_type en el objeto elemento del contenedor gestionado por este identificador de nodo. El comportamiento no está definido si el identificador de nodo está vacío.
Excepciones
(Ninguna)
swap
| void swap(/*node-handle*/& nh) noexcept(/* véase más abajo */); |
||
- Intercambia la propiedad de nodos de contenedor.
- Si un nodo está vacío o si ambos nodos no están vacíos y
std::allocator_traits<allocator_type>::propagate_on_container_swapestrue, también intercambia los asignadores.
El comportamiento está indefinido si ambos nodos no están vacíos y allocator_traits<allocator_type>::propagate_on_container_swap es false y los asignadores no se comparan iguales.
Excepciones
| noexcept(std::allocator_traits<allocator_type>::propagate_on_container_swap::value || std::allocator_traits<allocator_type>::is_always_equal::value) |
||
[editar] Funciones no miembro
swap
| friend void swap(/*node-handle*/& x, /*node-handle*/& y) noexcept(noexcept(x.swap(y))); |
||
Efectivamente ejecuta x.swap(y).
Esta función no es visible a una búsqueda no calificada o calificada, y puede encontrarse solamente mediante la búsqueda dependiente de argumento cuando node-handle es una clase asociada de los argumentos.
