Ist es möglich boost :: foreach mit std :: map zu verwenden?

Finde ich boost::foreach sehr nützlich, da es spart mir eine Menge schreiben. Zum Beispiel, sagen wir, ich will zu drucken, die alle Elemente in einer 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 macht der code oben auch viel einfacher:

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

Viel besser! Allerdings habe ich nie herausgefunden, eine Möglichkeit (wenn es überhaupt möglich ist), um es für std::maps. Die Dokumentation hat nur Beispiele mit Typen wie vector oder string.

InformationsquelleAutor der Frage Andreas Bonini | 2010-01-20

boost c++foreach

88

Müssen Sie verwenden:
```
typedef std::map<int, int> map_type;
map_type map = /* ... */;

BOOST_FOREACH(const map_type::value_type& myPair, map)
{
    //...
}
```
Der Grund dafür ist, dass das makro erwartet zwei Parameter. Wenn Sie versuchen, inline-pair-definition, Einführung einer zweiten Komma, so dass das makro drei Parameter statt. Der Präprozessor nicht respektiert alle C++ - Konstrukte, es kennt nur text.

So, wenn Sie sagen BOOST_FOREACH(pair<int, int>, map) der Präprozessor sieht diese drei Argumente für das makro:

1.pair<int

2. int>

3. map

Falsch ist. Dies ist erwähnt in der for-each-Dokumentation.

InformationsquelleAutor der Antwort GManNickG

Benutze ich Boost-Bereich Ex-Bibliothekdie sich um einige ausgefallene Auswahl Adapter für die Iteration über Karte, Schlüssel oder Werte. Zum Beispiel:

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 der Antwort Manuel

Sicher, Sie können. Der trick ist jedoch, dass ein map-iterator zeigt auf ein paar von Schlüssel und Wert. Es würde in etwa so Aussehen:

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;
}

InformationsquelleAutor der Antwort Fred Larson

2

Es ist möglich, aber es ist nicht wirklich der beste Weg, Dinge zu tun (wie ich bereits erwähnt habe, ein paar mal vor, for_each fast nie ist, und BOOST_FOREACH ist nur marginal besser). Für Ihr erstes Beispiel, ich glaube, Sie wäre besser dran mit:
```
std::copy(numbers.begin(), numbers.end(), 
          std::ostream_iterator<int>(std::cout, " "));
```
Es funktioniert ziemlich ähnlich wie eine Landkarte, mit der Ausnahme, dass Sie zum definieren der operator<< für das es, da es nicht bereits definiert:
```
typedef map<std::string, int>::value_type vt;

std::ostream &operator<<(std::ostream &os, vt &v) { 
    return os << v.first << ": " << v.second;
}
```
...und wieder einmal std::copy ist der job ganz schön:
```
std::copy(mymap.begin(), mymap.end(), 
          std::ostream_iterator<vt>(std::cout, "\n"));
```
InformationsquelleAutor der Antwort Jerry Coffin
2

Typedefing eine Karte-pair-Mädchen ist verwirrend. Der einfachste Weg zum Durchlaufen einer Karte ist mit einem Tupel(wie in python):
```
std::map<int, int> mymap;
int key, value;
BOOST_FOREACH(boost::tie(key, value), mymap)
{
    ...
}
```
Und keine Sorge, solche Kommas nicht zu verwechseln den Präprozessor, weil ich Klammern gesetzt um Sie herum.

InformationsquelleAutor der Antwort Paul Fultz II

Ich mochte die Idee nicht gezwungen werden, zum hinzufügen von Typdefinitionen jedes mal wollte ich mit einer foreach auf eine Karte. So, hier ist meine Umsetzung basiert auf der boost foreach-code:

#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)

Dann können Sie es verwenden in Ihrem 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" );

Können Sie auch ändern Sie die Werte:
#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" );

InformationsquelleAutor der Antwort marko.ristin

Ja:

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

MyMap    myMap;

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

InformationsquelleAutor der Antwort Martin York

In C++0x " können Sie sich leichter tun:

map<int, string> entries;
/* Fill entries */

foreach(auto i, entries)
   cout << boost::format("%d = %s\n") % i.first % i.second;

InformationsquelleAutor der Antwort Andreas Bonini

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.