KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Node handles van associatieve containers

Een node handle bezit een element dat uit een associatieve container is gehaald. Hiermee kun je de sleutel wijzigen en de node naar een compatibele container overbrengen zonder het element zelf te kopiëren of te verplaatsen. Controleer of de handle leeg is, of de allocators compatibel zijn en wat het invoegresultaat is.

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

Syntax

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

Associative-container node handles bezitten afzonderlijke nodes die uit geordende en ongeordende associatieve containers zijn gehaald. Het type schrijf je als Container::node_type; node-handle is in de standaard een naam die alleen ter uitleg wordt gebruikt, geen klasse met de naam std::node_handle. extract(key) verwijdert een element en retourneert de handle; bij een ontbrekende sleutel is de handle leeg. Bij het overbrengen van een node wordt het element zelf niet gekopieerd of verplaatst.

Een handle kan worden verplaatst, maar niet gekopieerd. empty() en operator bool() controleren de toestand. Bij maps geven key() en mapped() toegang tot de wijzigbare sleutel en de gekoppelde waarde; bij sets gebruik je value(). Deze bewerkingen en get_allocator() vereisen een niet-lege handle. Als een niet-lege handle wordt vernietigd, wordt het element vernietigd en de opslag van de node vrijgegeven.

Compatibel zijn de families map/multimap en set/multiset, plus hun unordered_-varianten, met waar van toepassing overeenkomende typen voor sleutel, gekoppelde waarde en allocator. Vergelijkers, hashfuncties of gelijkheidspredicaten mogen verschillen. Nodes kunnen niet op deze manier tussen geordende en ongeordende families worden overgebracht. Bij het invoegen van een niet-lege handle moet de allocator ervan gelijk zijn aan die van de doelcontainer; anders is het gedrag ongedefinieerd.

Bij een container met unieke sleutels retourneert insert(std::move(nh)) zonder hint de velden position, inserted en node. Bij een sleutelconflict staat de afgewezen node in result.node, niet in nh. Het voorbeeld haalt deze node terug, wijzigt de sleutel en probeert het opnieuw. De bronnen beschrijven het huidige werkdocument; het voorbeeld is bedoeld om te compileren met -std=c++23, zonder ondersteuning tijdens productiegebruik te veronderstellen.

Voorbeelden

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

Resultaat

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

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen