WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Node-Handles für assoziative Container

Ein Node-Handle übernimmt den Besitz eines Elements, das aus einem assoziativen Container entnommen wurde. Damit lässt sich sein Schlüssel ändern und der Knoten ohne Kopieren oder Verschieben des Elements selbst in einen kompatiblen Container übertragen. Prüfen Sie, ob das Handle leer ist, ob die Allocatoren kompatibel sind und wie das Einfügen ausgeht.

Version: 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 besitzen einzelne entnommene Knoten aus geordneten und ungeordneten assoziativen Containern. Der Typ heißt Container::node_type; node-handle ist im Standard eine nur zur Erläuterung verwendete Bezeichnung, keine Klasse namens std::node_handle. extract(key) entfernt ein Element und gibt sein Handle zurück; bei einem fehlenden Schlüssel ist das Handle leer. Beim Übertragen eines Knotens wird das Element selbst weder kopiert noch verschoben.

Ein Handle kann verschoben, aber nicht kopiert werden. empty() und operator bool() prüfen seinen Zustand. Bei Maps geben key() und mapped() den änderbaren Schlüssel und den zugeordneten Wert frei; bei Sets wird dafür value() verwendet. Diese Operationen und get_allocator() erfordern ein nicht leeres Handle. Wird ein nicht leeres Handle zerstört, wird das Element zerstört und der Speicher des Knotens freigegeben.

Kompatibel sind die Familien map/multimap und set/multiset sowie ihre unordered_-Varianten, sofern Schlüssel-, zugeordnete Wert- und Allocator-Typen jeweils übereinstimmen. Vergleichsfunktionen, Hash-Funktionen oder Gleichheitsprädikate dürfen unterschiedlich sein. Knoten lassen sich auf diese Weise nicht zwischen geordneten und ungeordneten Familien übertragen. Beim Einfügen eines nicht leeren Handles muss dessen Allocator dem Allocator des Zielcontainers entsprechen; andernfalls ist das Verhalten undefiniert.

Bei einem Container mit eindeutigen Schlüsseln liefert insert(std::move(nh)) ohne Hinweis die Felder position, inserted und node. Bei einer Schlüsselkollision befindet sich der zurückgewiesene Knoten in result.node, nicht in nh. Das Beispiel übernimmt ihn, ändert seinen Schlüssel und versucht es erneut. Die Quellen beschreiben den aktuellen Arbeitsentwurf; das Beispiel ist für die Kompilierung mit -std=c++23 gedacht, ohne Unterstützung zur Laufzeit in Produktionsumgebungen vorauszusetzen.

Beispiele

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

Ergebnis

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

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen