Kann boost :: foreach mit std :: map verwendet werden?

Question

Ich finde boost::foreach sehr nützlich, da es mir eine Menge Schreiben erspart. Zum Beispiel, sagen wir, ich alle Elemente in einer Liste drucken möchten:

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

boost :: foreach den Code oben viel simplier macht:

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

Viel besser! Jedoch habe ich nie einen Weg gefunden (wenn es überhaupt möglich ist), es für std::map s zu benutzen. Die Dokumentation enthält nur Beispiele mit Typen wie vector oder string.

Answer 1

Sie müssen 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 zwei Parameter erwartet. Wenn Sie versuchen, die Paardefinition zu verknüpfen, führen Sie ein zweites Komma ein, indem Sie dem Makro stattdessen drei Parameter zuweisen. Der Präprozessor berücksichtigt keine C++ - Konstrukte, er kennt nur Text. So

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

1. pair<int
2. int>
3. map

was falsch ist. Dies ist mentioned in der for-each-Dokumentation.

Answer 2

Sicher können Sie. Der Trick besteht jedoch darin, dass ein Map-Iterator auf ein Paar aus Schlüssel und Wert zeigt. Es würde wie folgt 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; 
} 

Answer 3

Ja:

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

MyMap myMap; 

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

Answer 4

Es ist möglich, aber es ist nicht wirklich der beste Weg, Dinge zu tun (wie ich ein paar Mal schon erwähnt habe, for_each so gut wie nie ist, und BOOST_FOREACH ist nur geringfügig besser). Für Ihr erstes Beispiel, ich glaube, Sie besser dran sein würden:

std::copy(numbers.begin(), numbers.end(), 
      std::ostream_iterator<int>(std::cout, " ")); 

Es ziemlich ähnlich mit einer Karte arbeitet, mit der Ausnahme, dass Sie Betreiber < < für sie definieren müssen, da es nicht einen 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 noch einmal, tut std::copy das ganz schön Job:

std::copy(mymap.begin(), mymap.end(), 
      std::ostream_iterator<vt>(std::cout, "\n")); 

Answer 5

ich benutze Boost's Range Ex library die imp lenkt einige phantastische Bereichsadapter für das Iterieren über Kartenschlü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"; 

Answer 6

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

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

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

Answer 7

Typedefing eine Karte Paar verwirrend ist.Die einfachste Art, eine Karte iterieren 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, werden diese Kommata den Präprozessor nicht verwirren, weil ich Klammer um sie herum platziert.

Answer 8

Ich mochte nicht die Idee, gezwungen zu werden, jedesmal typedefs hinzuzufügen, wenn ich eine foreach auf einer Karte benutzen wollte. So, hier ist meine Implementierung basiert auf dem 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 in Ihrem Code verwenden: #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"); 

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