Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Binding strutturato del risultato di `std::map::insert` (da C++17)

Usa `auto [it, inserted]` per dare un nome all’iteratore e all’indicatore restituiti da `std::map::insert` quando inserisci un singolo valore senza suggerire una posizione.

Versione: ISO C++23; implementation support may vary

Sintassi

auto [it, inserted] = m.insert(value); // C++17 and later; m is a std::map and value is a single element

Da C++17, auto [it, inserted] = m.insert(value); assegna un nome a entrambi i componenti della coppia restituita. Tra parentesi quadre vanno identificatori, non tipi: scrivere alla lettera auto [iterator, bool] produce un errore di compilazione perché bool è una parola chiave. Per questa coppia servono esattamente due nomi, nell’ordine indicato.

auto si applica a un oggetto coppia nascosto, non a due dichiarazioni indipendenti. std::pair usa un’interfaccia simile a quella di una tupla: it designa il primo componente (first), inserted il secondo (second). Se esiste già una coppia result, auto [it, inserted] = result; la copia, mentre auto& [it, inserted] = result; lega i nomi ai suoi componenti. Non puoi usare auto& direttamente con il risultato di insert, che viene restituito per valore.

L’overload di std::map::insert che accetta un solo valore senza un suggerimento di posizione restituisce std::pair<iterator, bool>. Se la chiamata termina normalmente, inserted vale true se è stato aggiunto un elemento e false se esisteva già una chiave equivalente secondo il comparatore. In entrambi i casi, it punta all’elemento corrispondente e it->second ne legge il valore memorizzato. Un duplicato non sovrascrive quel valore. false non segnala un’eccezione.

Non tutti gli overload restituiscono una coppia: l’inserimento di un valore con un suggerimento di posizione restituisce solo un iteratore, quello di un intervallo restituisce void e quello di un handle di nodo senza suggerimento restituisce insert_return_type. L’iteratore non prolunga la vita della mappa o dell’elemento. Altri inserimenti in std::map non lo invalidano, ma non usarlo dopo aver rimosso l’elemento a cui punta o dopo la distruzione della mappa.

Esempi

#include <iostream>
#include <map>

int main() {
    std::map<int, int> m;
    const int values[] = {10, 20};

    for (int value : values) {
        auto [it, inserted] = m.insert(std::map<int, int>::value_type{7, value});
        std::cout << std::boolalpha << inserted << ' ' << it->second << '\n';
    }
}

Risultato

true 10
false 10

Il primo tentativo memorizza `10` con la chiave `7`. Il secondo usa la stessa chiave e segnala `false`; `it->second` vale ancora `10`, non `20`.

Lezioni correlate

  • C++ · Lezione 26 · Intermedio · Versione: 2

Fonti