L'ordine di iterazione tramite std :: map è noto (e garantito dallo standard)?

Quello che voglio dire è che sappiamo che gli std::mapelementi sono ordinati in base alle chiavi. Quindi, supponiamo che le chiavi siano numeri interi. Se mi iterare da std::map::begin()a std::map::end()utilizzare un for, fa la garanzia standard che io iterare di conseguenza attraverso gli elementi con chiavi, in ordine crescente?

Esempio:

std::map<int, int> map_;
map_[1] = 2;
map_[2] = 3;
map_[3] = 4;
for( std::map<int, int>::iterator iter = map_.begin();
     iter != map_.end();
     ++iter )
{
    std::cout << iter->second;
}

La stampa 234è garantita o l'implementazione è definita?

Motivo della vita reale: ho un std::mapcon le intchiavi. In situazioni molto rare, vorrei scorrere tutti gli elementi, con la chiave, più di un intvalore concreto . Sì, sembra che std::vectorsarebbe la scelta migliore, ma nota le mie "situazioni molto rare".

EDIT : So che gli elementi di std::mapsono ordinati .. non c'è bisogno di segnalarlo (per la maggior parte delle risposte qui). L'ho anche scritto nella mia domanda.
Stavo chiedendo degli iteratori e dell'ordine quando sto iterando attraverso un contenitore. Grazie @Kerrek SB per la risposta.

Sì, è garantito. Inoltre, *begin()ti dà l' *rbegin()elemento più piccolo e più grande, come determinato dall'operatore di confronto, e due valori chiave ae bper i quali l'espressione !compare(a,b) && !compare(b,a)è vera sono considerati uguali. La funzione di confronto predefinita è std::less<K>.

L'ordinamento non è una caratteristica bonus fortunato, ma piuttosto è un aspetto fondamentale della struttura dei dati, poiché l'ordinamento viene utilizzato per determinare quando due chiavi sono uguali (secondo la regola sopra) e per eseguire una ricerca efficiente (essenzialmente un binario ricerca, che ha complessità logaritmica nel numero di elementi).

Ciò è garantito dai requisiti del contenitore associativo nello standard C ++. Ad esempio, vedere 23.2.4 / 10 in C ++ 11:

La proprietà fondamentale degli iteratori di contenitori associativi è che essi
scorrere i contenitori nell'ordine non discendente delle chiavi dove
non discendente è definito dal confronto che è stato usato per costruirli.
Per due iteratori dichiarabili i e j tale che la distanza da i a j sia
positivo,
  value_comp (* j, * i) == false

e 23.2.4 / 11

Per i contenitori associativi con chiavi univoche vale la condizione più forte,
  value_comp (* i, * j)! = false.

Penso che ci sia confusione nelle strutture di dati.

Nella maggior parte delle lingue, a mapè semplicemente un AssociativeContainer: associa una chiave a un valore. Nelle lingue "più recenti", ciò viene generalmente ottenuto utilizzando una mappa hash, quindi non viene garantito alcun ordine.

In C ++, tuttavia, non è così:

• std::mapè un contenitore associativo ordinato
• std::unordered_map è un contenitore associativo basato su tabella hash introdotto in C ++ 11

Quindi, al fine di chiarire le garanzie sugli ordini.

In C ++ 03:

• std::set, std::multiset, std::mapE std::multimapsono garantiti da ordinare in base ai tasti (e il criterio fornito)
• in std::multisete std::multimap, lo standard non impone alcuna garanzia di ordine su elementi equivalenti (cioè quelli che si equivalgono)

In C ++ 11:

• std::set, std::multiset, std::mapE std::multimapsono garantiti da ordinare in base ai tasti (e il criterio fornito)
• in std::multisete std::multimap, lo Standard impone che gli elementi equivalenti (quelli che si equivalgono) siano ordinati secondo il loro ordine di inserimento (prima inseriti per primi)
• std::unordered_*i contenitori sono, come suggerisce il nome, non ordinati. In particolare, l'ordine degli elementi può cambiare quando il contenitore viene modificato (all'inserimento / eliminazione).

Quando lo standard dice che gli elementi sono ordinati in un certo senso, significa che:

• durante l'iterazione, vedi gli elementi nell'ordine definito
• quando si scorre in senso inverso, si vedono gli elementi nell'ordine opposto

Spero che questo chiarisca ogni confusione.

Questo è garantito per la stampa 234 o la sua implementazione è definita?

Sì, std::mapè un contenitore ordinato, ordinato da Keycon il fornito Comparator. Quindi è garantito.

Vorrei scorrere tutti gli elementi, con la chiave, più di un valore int concreto.

Questo è sicuramente possibile.

Sì ... gli elementi in a std::map hanno un rigoroso ordinamento debole, nel senso che gli elementi saranno composti da un set (cioè, non ci saranno ripetizioni di chiavi che sono "uguali"), e l'uguaglianza è determinata testando su qualsiasi due chiavi A e B, che se la chiave A non è inferiore alla chiave B e B non è inferiore a A, allora la chiave A è uguale alla chiave B.

Detto questo, non puoi ordinare correttamente gli elementi di a std::mapse l'ordinamento debole per quel tipo è ambiguo (nel tuo caso, dove stai usando numeri interi come tipo di chiave, non è un problema). Devi essere in grado di definire un'operazione che definisce un ordine totale sul tipo che stai usando per le chiavi nel tuo std::map, altrimenti avrai solo un ordine parziale per i tuoi elementi, o poset, che ha proprietà dove A potrebbe non essere paragonabile a B. Ciò che accadrà in genere in questo scenario è che sarai in grado di inserire le coppie chiave / valore, ma potresti finire con coppie duplicate chiave / valore se esegui l'iterazione dell'intera mappa e / o rilevi "mancante" coppie chiave / valore quando si tenta di eseguire una std::map::find()coppia chiave / valore specifica nella mappa.

begin () può fornire l'elemento più piccolo. Ma dipende l'implementazione. È specificato nello standard C ++? Altrimenti, è pericoloso fare questo presupposto.