Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Handle di nodo dei contenitori associativi

Un handle di nodo possiede un elemento estratto da un contenitore associativo. Permette di modificarne la chiave e trasferire il nodo in un contenitore compatibile senza copiare o spostare l’elemento stesso. Occorre controllare che l’handle non sia vuoto, la compatibilità degli allocator e l’esito dell’inserimento.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

auto nh = source.extract(key);
if (nh) {
    nh.key() = new_key; // map-like containers
    auto result = destination.insert(std::move(nh));
    // Unique-key, non-hinted insertion: inspect result.inserted and result.node.
}

Gli Associative-container node handles possiedono singoli nodi estratti da contenitori associativi ordinati e non ordinati. Il tipo si scrive Container::node_type; nello standard, node-handle è un nome esplicativo, non una classe chiamata std::node_handle. extract(key) rimuove un elemento e ne restituisce l’handle; se la chiave non esiste, l’handle è vuoto. Il trasferimento di un nodo non copia né sposta l’elemento stesso.

Un handle può essere spostato, ma non copiato. empty() e operator bool() ne verificano lo stato. Per le mappe, key() e mapped() espongono la chiave modificabile e il valore associato; per gli insiemi si usa value(). Queste operazioni e get_allocator() richiedono un handle non vuoto. La distruzione di un handle non vuoto distrugge l’elemento e dealloca lo spazio del nodo.

La compatibilità riguarda le famiglie map/multimap e set/multiset e le rispettive varianti unordered_, con tipi di chiave, valore associato e allocator corrispondenti, se applicabile. Comparatori, funzioni hash o predicati di uguaglianza possono essere diversi. Non è possibile trasferire nodi in questo modo tra famiglie ordinate e non ordinate. Quando si inserisce un handle non vuoto, il suo allocator deve essere uguale a quello del contenitore di destinazione; in caso contrario il comportamento è indefinito.

Per un contenitore con chiavi univoche, insert(std::move(nh)) senza suggerimento restituisce i campi position, inserted e node. In caso di collisione tra chiavi, il nodo rifiutato si trova in result.node, non in nh. L’esempio lo recupera, ne modifica la chiave e riprova. Le fonti descrivono la bozza di lavoro corrente; l’esempio è pensato per la compilazione con -std=c++23, senza presupporre il supporto in fase di esecuzione in produzione.

Esempi

#include <iostream>
#include <map>
#include <string>
#include <utility>

int main() {
    std::map<int, std::string> source{{1, "Ada"}};
    std::map<int, std::string> destination{{2, "Grace"}};

    auto nh = source.extract(1);
    if (!nh) return 1;
    nh.key() = 2;

    auto result = destination.insert(std::move(nh));
    std::cout << std::boolalpha << "inserted: " << result.inserted << '\n';

    if (!result.inserted) {
        result.node.key() = 3;
        auto retry = destination.insert(std::move(result.node));
        if (!retry.inserted) return 2;
    }

    std::cout << "source size: " << source.size() << '\n';
    for (const auto& [key, name] : destination) {
        std::cout << key << ": " << name << '\n';
    }
}

Risultato

inserted: false
source size: 0
2: Grace
3: Ada

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti