C++ 11 range-based per e mappa: leggibilità

Question

I nuovi loop basati su range migliorano davvero la leggibilità e sono davvero facili da usare. Tuttavia, considerare quanto segue:

map<Foo,Bar> FooAndAssociatedBars; 

for (auto& FooAndAssociatedBar : FooAndAssociatedBars) { 
    FooAndAssociatedBar.first.doSth(); 
    FooAndAssociatedBar.second.doSomeOtherThing(); 
} 

Può essere un dettaglio, ma trovo che sarebbe stato più leggibile se avrei potuto fare qualcosa di simile:

for ((auto& foo, auto& bar) : FooAndAssociatedBars) { 
    foo.doSth(); 
    bar.doSomeOtherThing(); 
} 

Sai una sintassi equivalente?

EDIT: Buone notizie: C++ 17 ha una proposta che adresses questo problema, chiamato binding strutturati (vedi 1). In C++ 17, si dovrebbe essere in grado di scrivere:

tuple<T1,T2,T3> f(/*...*/) { 
    /*...*/ 
    return {a,b,c}; 
} 
auto [x,y,z] = f(); // x has type T1, y has type T2, z has type T3 

che risolve questo problema leggibilità

Answer 1

Non esiste una cosa come si desidera. Il più vicino è quello di dichiarare le variabili all'interno del ciclo:

for (auto& FooAndAssociatedBar : FooAndAssociatedBars) { 
    auto& foo = FooAndAssociatedBar.first; 
    auto& bar = FooAndAssociatedBar.second; 

    // ... 
} 

Answer 2

E, naturalmente, si ha sempre la possibilità di utilizzare lambda.

std::map<int, const char*> m { { 4, "hello" }, { 11, "c++" } }; 
convenient_for_each(m, [](int a, const char* b) { 
    std::cout << b << a << std::endl; 
    }); 
convenient_for_each(m, [](std::pair<int, const char> p) { 
    std::cout << p.first << p.second << std::endl; 
    }); 

O avvolto come macro (non raccomandato)

FOREACH((int a, const char* b), m, std::cout << a << b << std::endl); 
FOREACH((std::pair<int, const char*> p), m, std::cout << p.first << p.second << std::endl); 

(Hackish sample implementation at LWS)

Auto non funziona, però, sto ancora aspettando lambda polimorfico. Il mio approccio è teoricamente in grado di gestire anche le tuple.

Answer 3

Non è una buona idea. Prima o poi, si vorrebbe lo stesso per un std::tuple, e il compilatore dovrebbe essere in grado di utilizzare std::get<> su tuple automaticamente. A mio parere, il tuo approccio ti sta solo piacendo al momento, e troverai dei problemi con questo approccio (supponi che sia implementato in questo modo).

Il comitato standard ha progettato for-loop basato sulla gamma con profonda considerazione. È molto meglio del ciclo foreach in altre lingue, ed è molto più breve. Accoppialo con auto& e il gioco è fatto!