Comment utiliser BOOST_FOREACH avec deux cartes std :: maps?

Question

J'ai le code qui ressemble essentiellement comme ceci:

std::map<int, int> map1, map2; 
BOOST_FOREACH(int i, map1) 
{ 
    // do steps 1-5 here... 
} 
BOOST_FOREACH(int i, map2) 
{ 
    // do steps 1-5 (identical to above) here... 
} 

Est-il possible de concaténer les cartes pour éliminer le code en double dans la deuxième boucle? Ou un moyen d'étendre BOOST_FOREACH pour itérer sur deux cartes différentes en une fois? Évidemment, je ne veux pas augmenter la complexité temporelle du programme (sinon je pourrais juste créer une nouvelle carte et l'insérer dans map1 et map2). J'ai le sentiment qu'il me manque quelque chose de rudimentaire ici.

Answer 1

Vous pouvez définir une fonction:

typedef std::map<int, int> IntMap; 

void doStuffWithInt(IntMap::value_type &i) 
{ 
    // steps 1 to 5 
} 

BOOST_FOREACH(IntMap::value_type &i, map1) 
    doStuffWithInt(i); 
BOOST_FOREACH(IntMap::value_type &i, map2) 
    doStuffWithInt(i); 

Bien que dans ce cas, il pourrait être encore plus simple à utiliser std::for_each:

for_each(map1.begin(), map1.end(), doStuffWithInt); 
for_each(map2.begin(), map2.end(), doStuffWithInt); 

Answer 2

En plus de la solution de 1800, que je recommande, il y a aussi diverses solutions hacky:

for (int stage = 0; stage < 2; stage++) { 
    BOOST_FOREACH(int i, stage == 0 ? map1 : map2) { 
     ... 
    } 
} 

typedef std::map<int, int> intmap; 
std::vector<intmap *> v; 
v.push_back(&map1); 
v.push_back(&map2); 
BOOST_FOREACH(intmap *m, v) { 
    BOOST_FOREACH(int i, *m) { 
     ... 
    } 
} 

Remarque: lorsque je vois des collègues écrire comme ça, parfois je suis submergé par une envie irrésistible d'aller les étrangler. À utiliser à vos risques et périls.

Answer 3

L'idée ici est d'écrire un type spécial d'itérateurs pour fusionner virtuellement deux conteneurs, en ce qui concerne BOOST_FOREACH. Notez que je ne crée pas un nouveau conteneur parmi les deux existants. Je saute simplement de l'extrémité du premier conteneur() à l'itérateur begin() du second conteneur. Je n'ai pas essayé d'écrire la classe merged_iterator actuelle, mais même si cela peut prendre un peu de temps à écrire, ce n'est pas techniquement difficile. Je suis vraiment surpris de ne pas avoir trouvé quelque chose comme ça en utilisant google. Je n'ai pas cherché longtemps, cependant!

template<typename Container> 
boost::iterator_range< 
    merged_iterator<Container::iterator> 
    > 
concat_containers(Container& c1, Container& c2) 
{ 
    typedef merged_iterator<typename Container::iterator> MergedIterator; 
    typedef boost::iterator_range<MergedIterator> IteratorRange; 
    return IteratorRange(
    MergeIterator(c1.begin(), c1.end(), c2.begin(), c2.end()), 
    MergeIterator(c2.end(), c1.end(), c2.begin(), c2.end())); 
} 

// Now use a bit of magic to define merged_iterator<...> 
// And you'll be able to write 

BOOST_FOREACH(std::pair<int, int> i, concat_containers(map1, map2)) 
{ 
// Do whatever you want here 
} 

Answer 4

Du haut de ma tête, je vais essayer

std::map<int, int> map1, map2; 
std::map<int, int>& maps = { map1, map2 } 
BOOST_FOREACH(std::map<int, int> map, maps) 
    BOOST_FOREACH(int i, map) 
    { 
     // do steps 1-5 here... 
    } 

Answer 5

Il est expliqué here.

Vous pouvez le faire:

std::map<int,int> m; 
typedef std::pair<int,int> pair_t; 
BOOST_FOREACH(pair_t p, m) 

Answer 6

Le plus simple est comme ceci:

std::map<int, int> map1, map2; 
int key, value; 
BOOST_FOREACH(boost::tie(key, value), boost::join(map1, map2)) 
{ 
    // do steps 1-5 here... 
} 

Et ne vous inquiétez pas les virgules ne confondez pas le préprocesseur à cause de la parenthèse.