Come utilizzare il range-based per () loop con std :: map?

L'esempio comune per i loop () basati su intervallo C ++ 11 è sempre qualcosa di semplice come questo:

std::vector<int> numbers = { 1, 2, 3, 4, 5, 6, 7 };
for ( auto xyz : numbers )
{
     std::cout << xyz << std::endl;
}

Nel qual caso xyzè un int. Ma cosa succede quando abbiamo qualcosa come una mappa? Qual è il tipo di variabile in questo esempio:

std::map< foo, bar > testing = { /*...blah...*/ };
for ( auto abc : testing )
{
    std::cout << abc << std::endl;         // ? should this give a foo? a bar?
    std::cout << abc->first << std::endl;  // ? or is abc an iterator?
}

Quando il contenitore attraversato è qualcosa di semplice, sembra che i cicli () basati sulla portata ci forniscano ogni elemento, non un iteratore. Il che è bello ... se fosse iteratore, la prima cosa che dovremmo sempre fare è dereferenziarlo comunque.

Ma sono confuso su cosa aspettarsi quando si tratta di cose come mappe e multimappa.

(Sono ancora su g ++ 4.4, mentre i loop basati su range sono in g ++ 4.6+, quindi non ho ancora avuto la possibilità di provarlo.)

Ogni elemento del contenitore è un map<K, V>::value_type, che è un typedeffor std::pair<const K, V>. Di conseguenza, in C ++ 17 o versioni successive, è possibile scrivere

for (auto& [key, value]: myMap) {
    std::cout << key << " has value " << value << std::endl;
}

o come

for (const auto& [key, value]: myMap) {
    std::cout << key << " has value " << value << std::endl;
}

se non prevedi di modificare i valori.

In C ++ 11 e C ++ 14, è possibile utilizzare forloop avanzati per estrarre ciascuna coppia da sola, quindi estrarre manualmente le chiavi e i valori:

for (const auto& kv : myMap) {
    std::cout << kv.first << " has value " << kv.second << std::endl;
}

Puoi anche considerare di contrassegnare la kvvariabile constse desideri una vista di sola lettura dei valori.

In C ++ 17 questo è chiamato binding strutturato , che consente quanto segue:

std::map< foo, bar > testing = { /*...blah...*/ };
for ( const auto& [ k, v ] : testing )
{
  std::cout << k << "=" << v << "\n";
}

Da questo documento: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2049.pdf

for( type-specifier-seq simple-declarator : expression ) statement

è sintatticamente equivalente a

{
    typedef decltype(expression) C;
    auto&& rng(expression);
    for (auto begin(std::For<C>::begin(rng)), end(std::For<C>::end(rng)); begin != end; ++ begin) {
        type-specifier-seq simple-declarator(*begin);
        statement
    }
}

Quindi puoi vedere chiaramente che cosa sarà abcnel tuo caso std::pair<key_type, value_type >. Quindi per la stampa puoi accedere a ciascun elemento con abc.firsteabc.second

Se vuoi vedere solo le chiavi / i valori dalla tua mappa e ti piace usare boost, puoi usare gli adattatori boost con i loop basati sull'intervallo:

for (const auto& value : myMap | boost::adaptors::map_values)
{
    std::cout << value << std::endl;
}

esiste un boost equivalente :: adattatori :: key_values

http://www.boost.org/doc/libs/1_51_0/libs/range/doc/html/range/reference/adaptors/reference/map_values.html

Se l'operatore di assegnazione della copia di foo and bar è economico (ad es. Int, char, pointer ecc), è possibile effettuare le seguenti operazioni:

foo f; bar b;
BOOST_FOREACH(boost::tie(f,b),testing)
{
  cout << "Foo is " << f << " Bar is " << b;
}