Est-il possible d'utiliser boost::foreach avec std::map?

Je trouve boost::foreach très utile car il me permet de gagner beaucoup de l'écriture. Par exemple, disons que je veux imprimer tous les éléments dans une liste:

std::list<int> numbers = { 1, 2, 3, 4 };
for (std::list<int>::iterator i = numbers.begin(); i != numbers.end(); ++i)
   cout << *i << " ";

boost::foreach rend le code ci-dessus beaucoup plus simple:

std::list<int> numbers = { 1, 2, 3, 4 };
BOOST_FOREACH (int i, numbers)
   cout << i << " ";

Beaucoup mieux! Cependant je n'ai jamais trouvé un moyen (si c'est possible) à utiliser pour std::maps. La documentation a des exemples avec des types comme vector ou string.

Ce n'est pas exactement un doublon, mais le voir ici: stackoverflow.com/questions/461507/...

InformationsquelleAutor Thomas Bonini | 2010-01-20

boost c++foreach

88

Vous devez utiliser:
```
typedef std::map<int, int> map_type;
map_type map = /* ... */;

BOOST_FOREACH(const map_type::value_type& myPair, map)
{
    //...
}
```
La raison en est que la macro s'attend deux paramètres. Lorsque vous essayez d'insérer le paire de définition, d'introduire un deuxième virgule, faire de la macro trois paramètres à la place. Le préprocesseur ne respecte pas toutes les constructions C++, il ne connaît que le texte.

Quand vous dites BOOST_FOREACH(pair<int, int>, map), le préprocesseur voit ces trois arguments de la macro:

1.pair<int

2. int>

3. map

Qui est faux. C'est mentionné pour chaque documentation.
- Faire que pair<const int, int>.
- La dernière modification introduit une certaine désinformation. Il n'y a pas de comportement indéfini, car les deux derniers exemples ne compile pas. std::map protège la clé elle-même: si vous avez map<Key, Value> puis le type de valeur est pair<const Key, Value>. Notez qu'il rend les clés de type const.
- Pouvez-vous modifier votre réponse encore une fois? Par accident, j'ai annulé mon upvote et maintenant il ne me faites pas de refonte, sauf si vous modifiez =p EDIT: ah, cool, je l'ai montée moi-même et cela a fonctionné 🙂 +1 regiven!
- Remarque en C++11, vous pouvez aussi simplement faire BOOST_FOREACH(const auto& myPair, map)
InformationsquelleAutor GManNickG
20

- Je utiliser Du coup de pouce de la Gamme Ex de bibliothèque qui implémente un peu de fantaisie gamme d'adaptateurs pour itérer sur la carte des clés ou des valeurs. Par exemple:
```
map<int, string> foo;
foo[3] = "three";
foo[7] = "seven";

BOOST_FOREACH(i, foo | map_keys)
   cout << i << "\n";


BOOST_FOREACH(str, foo | map_values)
   cout << str << "\n";
```
InformationsquelleAutor Manuel
3

Bien sûr vous pouvez. Le truc est, cependant, qu'une carte d'itérateur points à l'une des paires de clés et de valeurs. Il ressemblerait à quelque chose comme ceci:
```
typedef std::map<std::string, int> MapType;
MapType myMap;

//... fill the map...

BOOST_FOREACH(MapType::value_type val, myMap)
{
    std::cout << val.first << ": " << val.second << std::endl;
}
```
- Eh bien, j'ai essayé avec BOOST_FOREACH(int i, map), BOOST_FOREACH(pair<int, int>, map), etc. Pouvez-vous poster un exemple de travail?
- Quelqu'un pourrait mentionner qu' BOOST_FOREACH est un macro, et donc il ne peut pas traiter correctement la virgule dans la paire d'un modèle. C'est la raison pour laquelle tout le monde est ce qui suggère une définition de type.
- Je pense que le typedef permet simplement de regarder un ensemble beaucoup plus propre, même si la macro peut gérer la virgule (pas sûr si c'est possible).
- Virgule n'a qu'un seul sens pour le préprocesseur - argument séparateur. Il n'est pas conscient de modèles et qu'une virgule qui se trouve entre <> ne pas introduire un autre argument.
- Oui, il semble que vous avez raison. Mais ce n'était pas ma pensée à l'aide de la définition de type. Je pense que c'était le cas des OP problème tout au long, bien que je n'avais aucun moyen de savoir que lorsque je suis venu avec l'exemple de code.
InformationsquelleAutor Fred Larson
2

C'est possible, mais ce n'est pas vraiment la meilleure façon de faire les choses (comme je l'ai mentionné à quelques reprises avant, for_each presque jamais, et BOOST_FOREACH est à peine mieux). Pour votre premier exemple, je pense que vous seriez mieux avec:
```
std::copy(numbers.begin(), numbers.end(), 
          std::ostream_iterator<int>(std::cout, " "));
```
Ça marche pas de même avec une carte, sauf que vous devez définir l'opérateur<< pour elle, car il n'est pas déjà défini:
```
typedef map<std::string, int>::value_type vt;

std::ostream &operator<<(std::ostream &os, vt &v) { 
    return os << v.first << ": " << v.second;
}
```
...et encore une fois, std::copy fait le travail très bien:
```
std::copy(mymap.begin(), mymap.end(), 
          std::ostream_iterator<vt>(std::cout, "\n"));
```
- +1. Je suis d'accord avec vous, Jerry, bien que certains pourraient faire valoir que le fait d'avoir à définir l'opérateur (oups, vous avez une faute de frappe là!) est plus d'ennuis que de la BOOST_FOREACH.
- Ils peuvent toujours dire que, et une très minime mesure, c'est encore vrai. Puis à nouveau, de faire le travail à droite est souvent un peu plus de travail (au moins à l'avant) que juste le piratage sur quelque chose qui sorte de travaux.
InformationsquelleAutor Jerry Coffin
2

Typedefing une carte paire est source de confusion. Le plus simple moyen pour parcourir une carte avec un n-uplet(tout comme en python):
```
std::map<int, int> mymap;
int key, value;
BOOST_FOREACH(boost::tie(key, value), mymap)
{
    ...
}
```
Et ne vous inquiétez pas, ces virgules de ne pas confondre le préprocesseur parce que j'ai mis entre parenthèses autour d'eux.
- Cela a un inconvénient de la copie de la valeur de la carte. Il peut être coûteux si elle n'est pas primitive.
InformationsquelleAutor Paul Fultz II

Je n'aimais pas l'idée d'être obligé d'ajouter des typedefs chaque fois que je voulais utiliser un foreach sur une carte. Voici donc ma réalisation basée sur la relance de code foreach:

#ifndef MUNZEKONZA_FOREACH_IN_MAP 

#include <boost/preprocessor/cat.hpp>
#define MUNZEKONZA_FOREACH_IN_MAP_ID(x)  BOOST_PP_CAT(x, __LINE__)

namespace munzekonza {
namespace foreach_in_map_private {
inline bool set_false(bool& b) {
  b = false;
  return false;
}

}
}

#define MUNZEKONZA_FOREACH_IN_MAP(key, value, map)                            \
for(auto MUNZEKONZA_FOREACH_IN_MAP_ID(_foreach_in_map_it) = map.begin();      \
        MUNZEKONZA_FOREACH_IN_MAP_ID(_foreach_in_map_it) != map.end();)       \
for(bool MUNZEKONZA_FOREACH_IN_MAP_ID(_foreach_in_map_continue) = true;       \
      MUNZEKONZA_FOREACH_IN_MAP_ID(_foreach_in_map_continue) &&               \
      MUNZEKONZA_FOREACH_IN_MAP_ID(_foreach_in_map_it) != map.end();          \
      (MUNZEKONZA_FOREACH_IN_MAP_ID(_foreach_in_map_continue)) ?              \
        ((void)++MUNZEKONZA_FOREACH_IN_MAP_ID(_foreach_in_map_it)) :          \
        (void)0)                                                              \
  if( munzekonza::foreach_in_map_private::set_false(                          \
          MUNZEKONZA_FOREACH_IN_MAP_ID(_foreach_in_map_continue))) {} else    \
  for( key = MUNZEKONZA_FOREACH_IN_MAP_ID(_foreach_in_map_it)->first;         \
        !MUNZEKONZA_FOREACH_IN_MAP_ID(_foreach_in_map_continue);              \
        MUNZEKONZA_FOREACH_IN_MAP_ID(_foreach_in_map_continue) = true)        \
  if( munzekonza::foreach_in_map_private::set_false(                          \
          MUNZEKONZA_FOREACH_IN_MAP_ID(_foreach_in_map_continue))) {} else    \
  for( value = MUNZEKONZA_FOREACH_IN_MAP_ID(_foreach_in_map_it)->second;      \
        !MUNZEKONZA_FOREACH_IN_MAP_ID(_foreach_in_map_continue);              \
        MUNZEKONZA_FOREACH_IN_MAP_ID(_foreach_in_map_continue) = true)

Alors vous pouvez l'utiliser dans votre code:
#define foreach_in_map MUNZEKONZA_FOREACH_IN_MAP

std::map<int, std::string> mymap;
mymap[0] = "oi";
mymap[1] = "noi";

std::map<int, std::string> newmap;

foreach_in_map(int key, const std::string& value, mymap) {
  newmap[key] = value;
}

ASSERT_EQ( newmap.size(), 2 );
ASSERT_EQ( newmap.count(0), 1 );
ASSERT_EQ( newmap.count(1), 1 );
ASSERT_EQ( newmap.at(0), "oi" );
ASSERT_EQ( newmap.at(1), "noi" );

Vous pouvez également modifier les valeurs:
#define foreach_in_map MUNZEKONZA_FOREACH_IN_MAP

std::map<int, std::string> mymap;

mymap[0] = "oi";
mymap[1] = "noi";

std::map<int, std::string> newmap;

foreach_in_map(int key, std::string& value, mymap) {
  value = "voronoi" + boost::lexical_cast<std::string>(key);
}

ASSERT_EQ( mymap.size(), 2 );
ASSERT_EQ( mymap.count(0), 1 );
ASSERT_EQ( mymap.count(1), 1 );
ASSERT_EQ( mymap.at(0), "voronoi0" );
ASSERT_EQ( mymap.at(1), "voronoi1" );

si vous n'aimez pas les typedefs, il suffit d'utiliser #define !?

InformationsquelleAutor marko.ristin

Oui:

typedef std::map<std::string,int>    MyMap;

MyMap    myMap;

BOOST_FOREACH(MyMap::value_type loop, myMap)
{ 
       //Stuff
}

InformationsquelleAutor Martin York

0

Dans C++0x, vous pouvez plus facilement faire:
```
map<int, string> entries;
/* Fill entries */

foreach(auto i, entries)
   cout << boost::format("%d = %s\n") % i.first % i.second;
```
- Accoding à wikipédia, le foreach syntaxe ressemble plus à la java foreach for(int& x : my_array) { x *= 2; }
- Je crois que l'affiche a assumé la vieille pratique de #include<boost/foreach.hpp et #define foreach BOOST_FOREACH
InformationsquelleAutor Thomas Bonini

Vous devez vous connecter pour publier un commentaire.