Espacios de nombres
Variantes

    Identificador de nodo (C++17)

    De cppreference.com
     
    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 contenedores
     
    <tbody> </tbody>
    template</*sin especificar*/> class /*node-handle*/;
    		 (desde C++17)
    See More

    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>.

    Tipos miembro

    Tipo miembro Definición
    key_type Key [editar]
    mapped_type T [editar]
    allocator_type El asignador de memoria a usar al destruir el elemento. [editar]

    Funciones miembro

    constructores

    <tbody> </tbody>
    constexpr /*node-handle*/() noexcept;
    		 (1)
    /*node-handle*/(/*node-handle*/&& nh) noexcept;
    		 (2)
    1) El constructor por defecto inicializa el identificador de nodo al estado vacío.
    2) El constructor de movimiento toma propiedad del elemento del contenedor de 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=

    <tbody> </tbody>
    /*node-handle*/& operator=(/*node-handle*/&& nh);
    • Si el identificador de nodo no está vacío,
    • destruye el subobjeto value_type en el objeto elemento del contenedor gestionado por este identificador de nodo llamando a std::allocator_traits<allocator_type>::destroy;
    • desasigna el elemento del contenedor llamando a allocator_traits<allocator_type>::rebind_traits<container-node-type>::deallocate;
    • 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_assignment es true, mueve-asigna el asignador de nh.
    • Establece nh al 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

    <tbody> </tbody>
    ~/*node-handle*/();
    • Si el identificador de nodo no está vacío,
    • destruye el subobjeto value_type en el objeto elemento del contenedor gestionado por este identificador de nodo llamando a std::allocator_traits<allocator_type>::destroy;
    • desasigna el elemento del contenedor llamando a allocator_traits<allocator_type>::rebind_traits<container-node-type>::deallocate.

    empty

    <tbody> </tbody> <tbody class="t-dcl-rev "> </tbody><tbody> </tbody>
    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

    <tbody> </tbody>
    explicit operator bool() const noexcept;

    Convierte a false si el identificador de nodo está vacío; de lo contrario, true.

    get_allocator

    <tbody> </tbody>
    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

    <tbody> </tbody>
    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

    <tbody> </tbody>
    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

    <tbody> </tbody>
    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

    <tbody> </tbody>
    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_swap es true, 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

    Especificación noexcept:   (desde C++11)
    <tbody> </tbody>
    noexcept(std::allocator_traits<allocator_type>::propagate_on_container_swap::value || std::allocator_traits<allocator_type>::is_always_equal::value)

    Funciones no miembro

    swap

    <tbody> </tbody>
    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.