Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Handles de nœud des conteneurs associatifs

Un handle de nœud possède un élément extrait d’un conteneur associatif. Il permet de modifier sa clé et de transférer le nœud vers un conteneur compatible sans copier ni déplacer l’élément lui-même. Il faut vérifier que le handle n’est pas vide, que les allocateurs sont compatibles et quel est le résultat de l’insertion.

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

Syntaxe

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

Les Associative-container node handles possèdent des nœuds individuels extraits de conteneurs associatifs ordonnés ou non ordonnés. Le type s’écrit Container::node_type ; dans la norme, node-handle est un nom utilisé à des fins explicatives, et non une classe appelée std::node_handle. extract(key) retire un élément et renvoie son handle ; si la clé est absente, le handle est vide. Le transfert d’un nœud ne copie ni ne déplace l’élément lui-même.

Un handle peut être déplacé, mais pas copié. empty() et operator bool() permettent d’en vérifier l’état. Pour les maps, key() et mapped() donnent accès à la clé modifiable et à la valeur associée ; pour les sets, on utilise value(). Ces opérations et get_allocator() nécessitent un handle non vide. La destruction d’un handle non vide détruit l’élément et libère le stockage du nœud.

La compatibilité concerne les familles map/multimap et set/multiset, ainsi que leurs variantes unordered_, avec des types de clé, de valeur associée et d’allocateur correspondants, selon le cas. Les comparateurs, fonctions de hachage ou prédicats d’égalité peuvent différer. Le transfert de nœuds de cette manière n’est pas possible entre familles ordonnées et non ordonnées. Lorsqu’on insère un handle non vide, son allocateur doit être égal à celui du conteneur de destination ; sinon, le comportement est indéfini.

Dans un conteneur à clés uniques, insert(std::move(nh)) sans indice renvoie les champs position, inserted et node. En cas de collision de clé, le nœud rejeté se trouve dans result.node, et non dans nh. L’exemple le récupère, modifie sa clé et réessaie. Les sources décrivent le projet de norme actuel ; l’exemple vise une compilation avec -std=c++23, sans présumer de la prise en charge à l’exécution en production.

Exemples

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

Résultat

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

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources