Est-il possible en C++ de faire l'itération std::map "for element: container" avec des variables nommées (par exemple, clé et valeur) au lieu de.premier et.deuxième?

vous pouvez écrire un modèle de classe:

template <class K, class T>
struct MapElem {
    K const& key;
    T& value;

    MapElem(std::pair<K const, T>& pair)
        : key(pair.first)
        , value(pair.second)
    { }
};

avec l'avantage d'être en mesure d'écrire key et value , mais avec l'inconvénient d'avoir à spécifier les types:

for ( MapElem<int, std::string> kv : my_map ){
    std::cout << kv.key << " --> " << kv.value;
}

et ça ne marchera pas si my_map était const non plus. Il faudrait faire quelque chose comme:

template <class K, class T>
struct MapElem {
    K const& key;
    T& value;

    MapElem(std::pair<K const, T>& pair)
        : key(pair.first)
        , value(pair.second)
    { }

    MapElem(const std::pair<K const, std::remove_const_t<T>>& pair)
        : key(pair.first)
        , value(pair.second)
    { }
};

for ( MapElem<int, const std::string> kv : my_map ){
    std::cout << kv.key << " --> " << kv.value;
}

c'est le bordel. La meilleure chose pour le moment est de s'habituer à écrire .first et .second et espérer que la proposition de reliures structurées passe, ce qui permettrait ce que vous voulez vraiment:

for (auto&& [key, value] : my_map) {
    std::cout << key << " --> " << value;
}

la chose la plus proche de l'utiliser std::tie :

std::map<int, std::string> my_map;
int key;
std::string value;
for(auto&& p: my_map)
{
    std::tie(key, value) = p;
    std::cout << key << ": " << value << std::endl;
}

bien sûr, les expressions ne peuvent pas être placées dans la boucle for, donc une macro pourrait être utilisée pour permettre l'expression:

#define FOREACH(var, cont) \
    for(auto && _p:cont) \
        if(bool _done = false) {} \
        else for(var = std::forward<decltype(_p)>(_p); !_done; _done = true)

alors std::tie peut être utilisé directement dans la boucle:

std::map<int, std::string> my_map;
int key;
std::string value;
FOREACH(std::tie(key, value), my_map)
{
    std::cout << key << ": " << value << std::endl;
}

Avec c++moderne 17 c'est désormais possible avec structuré liaisons .

#include <map>
#include <string>
#include <iostream>

using namespace std;

int main() {
    map<int, string> my_map;

    my_map[0] = "hello";
    my_map[1] = "world";

    for (auto&& [key, value] : my_map) {
        cout << key << "," << value << "\n";
    }

    return 0;
}

Construire:

$ clang++ -std=c++17 test.cpp -o program

sortie:

$ ./program
0,hello
1,world

juste pour fournir encore une autre façon de presque faites ce que vous voulez, j'ai écrit cela il y a quelque temps pour éviter d'avoir .first et .second sur tout mon code:

auto pair2params = [](auto&& f)
{
    return [f](auto&& p) {
        f(p.first, p.second);
    };
};

Maintenant vous pouvez écrire quelque chose comme (en supposant une gamme basée for_each ):

int main()
{
    auto values = map<int, string>{
        {0, "hello"},
        {1, "world!"}
    };

    for_each(values, pair2params([](int key, const string& value) {
        cout << key << ": " << value << "\n";
    });
}

exemple D'exécution: http://ideone.com/Bs9Ctm

en général, je préfère un BAISER pour cette approche:

template<typename KeyValuePair>
typename KeyValuePair::first_type& key(KeyValuePair& kvp)
{
    return kvp.first;
}

template<typename KeyValuePair>
const typename KeyValuePair::first_type& key(const KeyValuePair& kvp)
{
    return kvp.first;
}

template<typename KeyValuePair>
void key(const KeyValuePair&& kvp) = delete;

template<typename KeyValuePair>
typename KeyValuePair::second_type& value(KeyValuePair& kvp)
{
    return kvp.second;
}

template<typename KeyValuePair>
const typename KeyValuePair::second_type& value(const KeyValuePair& kvp)
{
    return kvp.second;
}

template<typename KeyValuePair>
void value(const KeyValuePair&& kvp) = delete;

avec un exemple d'utilisation comme ceci:

for(auto& kvp : my_map) {
    std::cout << key(kvp) << " " << value(kvp) << "\n";
}

dans Apache Mesos , nous utilisons une macro appelée foreachpair qui peut être utilisé comme ceci:

foreachpair (const Key& key, const Value& value, elems) {
  /* ... */
}

vous pouvez bien sûr remplacer Key et Value par auto , avec tous les qualificatifs que vous souhaitez y utiliser. Il supporte également break et continue .

ma dernière implémentation ressemble à ceci:

#define FOREACH_PREFIX   BOOST_PP_CAT(foreach_, __LINE__)

#define FOREACH_BODY     BOOST_PP_CAT(FOREACH_PREFIX, _body__)
#define FOREACH_BREAK    BOOST_PP_CAT(FOREACH_PREFIX, _break__)
#define FOREACH_CONTINUE BOOST_PP_CAT(FOREACH_PREFIX, _continue__)
#define FOREACH_ELEM     BOOST_PP_CAT(FOREACH_PREFIX, _elem__)
#define FOREACH_ONCE     BOOST_PP_CAT(FOREACH_PREFIX, _once__)

les macros ci-dessus fournissent unique les noms de divers composants qui sont utilisés dans la macro foreachpair en incluant le nombre __LINE__ .

 1 #define foreachpair(KEY, VALUE, ELEMS)                                     \
 2   for (auto&& FOREACH_ELEM : ELEMS)                                        \
 3     if (false) FOREACH_BREAK: break; /* set up the break path */           \
 4     else if (bool FOREACH_CONTINUE = false) {} /* var decl */              \
 5     else if (true) goto FOREACH_BODY; /* skip the loop exit checks */      \
 6     else for (;;) /* determine whether we should break or continue. */     \
 7       if (!FOREACH_CONTINUE) goto FOREACH_BREAK; /* break */               \
 8       else if (true) break; /* continue */                                 \
 9       else                                                                 \
10         FOREACH_BODY:                                                      \
11         if (bool FOREACH_ONCE = false) {} /* var decl */                   \
12         else for (KEY = std::get<0>(                                       \
13                       std::forward<decltype(FOREACH_ELEM)>(FOREACH_ELEM)); \
14                   !FOREACH_ONCE; FOREACH_ONCE = true)                      \
15           for (VALUE = std::get<1>(                                        \
16                    std::forward<decltype(FOREACH_ELEM)>(FOREACH_ELEM));    \
17                !FOREACH_CONTINUE; FOREACH_CONTINUE = true)

je traverserai cette ligne par la ligne.

1. (début du mess).
2. de la Gamme, à base de boucle qui itère ELEMS .
3. nous avons mis en place le étiquette FOREACH_BREAK . Nous sautons à cette étiquette à break hors de cette boucle.
4. nous avons mis en place le indicateur de flux de contrôle FOREACH_CONTINUE . Il s'agit de true si l'itération courante est sortie normalement, ou via continue , et false si l'itération courante est sortie via break .
5. nous sautons toujours à l'étiquette FOREACH_BODY , ci-dessous.
6. c'est ici que nous interceptons le flux de contrôle et que nous inspectons le drapeau FOREACH_CONTINUE pour déterminer comment nous avons quitté l'itération en cours.
7. si FOREACH_CONTINUE est false , nous savons que nous sommes sortis par break donc nous sautons à FOREACH_BREAK .
8. autrement, FOREACH_CONTINUE est true , et nous break de la boucle for (;;) qui nous amène à la prochaine itération.
9. (mi-chemin à travers le mess).
10. Nous avons toujours sauter ici, à partir de (5).
11. configurer FOREACH_ONCE qui est juste utilisé pour exécuter le for boucle qui déclare KEY exactement une fois.
12. Déclarer KEY .
13. avancer l'élément correctement.
14. utilisez FOREACH_ONCE pour vous assurer que cette boucle est exécutée exactement une fois.
15. Déclarer VALUE .
16. avancer l'élément correctement.
17. Utiliser FOREACH_CONTINUE pour s'assurer que cette boucle est exécutée exactement une fois, et pour indiquer si la boucle sortie via break ou non.

NOTE : l'utilisation de std::get permet le support de std::tuple ou std::array sortant également de la séquence. par exemple, std::vector<std::tuple<int, int>>

Ideone Démo