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

CKTIS / C++

std::inserter — insertion avec un itérateur de sortie

std::inserter crée un itérateur de sortie qui appelle insert sur le conteneur à chaque affectation. Un algorithme comme std::copy peut ainsi ajouter des éléments à une position choisie au lieu d’écraser les éléments existants.

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

Syntaxe

#include <iterator>

template<class Container>
constexpr std::insert_iterator<Container>
inserter(Container& x, std::ranges::iterator_t<Container> i);

// Usage:
// auto out = std::inserter(container, position);

std::inserter(x, i), défini dans <iterator>, renvoie un std::insert_iterator<Container>. La création de l’adaptateur n’insère rien ; toute écriture par son intermédiaire appelle insert sur le conteneur. Celui-ci doit prendre en charge cette opération, et i doit être une position d’insertion valide dans x.

Une affectation effectue l’équivalent de iter = container->insert(iter, value); ++iter; ; pour un argument rvalue, elle utilise std::move(value). L’adaptateur mémorise l’itérateur renvoyé par insert, puis l’incrémente. Si insert ajoute un nouvel élément, la position mémorisée se trouve juste après cet élément. Dans un conteneur à clés uniques comme std::set, si une clé équivalente existe déjà, insert n’ajoute rien et renvoie un itérateur sur l’élément existant. La position mémorisée se trouve alors juste après cet élément existant. Dans un conteneur séquentiel, les écritures successives conservent l’ordre d’entrée. Le operator++ propre à l’adaptateur ne fait pas avancer la position : c’est l’affectation qui s’en charge.

L’adaptateur appelle une opération d’insertion au lieu d’écraser un élément existant. std::back_inserter utilise push_back et std::front_inserter utilise push_front ; std::inserter utilise insert avec une position. Le conteneur doit rester en vie tant que l’adaptateur est utilisé ; des modifications indépendantes ne doivent pas invalider la position mémorisée.

L’exemple insère 2 et 3 avant 4, ce qui produit 1 2 3 4. Le profil de vérification est C++23 ; le document cité est un projet de norme évolutif, et non une édition C++23 figée. Cela n’atteste ni la disponibilité d’un compilateur ni le comportement à l’exécution en production.

Exemples

#include <algorithm>
#include <array>
#include <cstddef>
#include <iostream>
#include <iterator>
#include <vector>

int main() {
    const std::array<int, 2> source{2, 3};
    std::vector<int> destination{1, 4};

    std::copy(source.begin(), source.end(),
              std::inserter(destination, destination.begin() + 1));

    for (std::size_t i = 0; i < destination.size(); ++i) {
        if (i != 0) std::cout << ' ';
        std::cout << destination[i];
    }
    std::cout << '\n';
}

Résultat

1 2 3 4

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