Avantages de std::for_each plus pour la boucle

Voici quelques raisons:

1. Il semble faire obstacle à la lisibilité juste parce que vous n'êtes pas habitué, et/ou n'utilisez pas les bons outils autour de lui pour le rendre vraiment facile. (voir boost::gamme et boost::bind/boost::lambda pour les aidants. Beaucoup de ces dans C++0x et faire for_each et d'autres fonctions plus utiles.)

2. Il vous permet d'écrire un algorithme sur le dessus de for_each qui fonctionne avec tous les itérateur.

3. Il réduit les chances d'stupide taper des bugs.

4. Il ouvre également votre esprit pour le reste de la STL-algorithmes, comme find_if, sort, replace, etc, et ceux-ci n'est pas si étrange plus. Cela peut être une grande victoire.

Mise à jour 1:

Plus important encore, il vous permet d'aller au-delà de for_each vs pour des boucles comme ça tout y est, et de regarder les autres, STL-alogs, comme trouver /tri /partition /copy_replace_if, parallèle de l'exécution .. ou quoi que ce soit.

Beaucoup de traitement peut être écrit de façon très concise en utilisant le "reste" de for_each frères et sœurs, mais si tout ce que vous faire est d'écrire une boucle for avec diverses logique interne, alors vous ne serez jamais apprendre à utiliser, et vous finirez par inventer la roue au-dessus et plus.

Et (le bientôt-à-être une gamme disponible de style for_each):

for_each(monsters, boost::mem_fn(&Monster::think));

Ou en C++x11 lambdas:

for_each(monsters, [](Monster& m) { m.think(); });

est de l'OMI, plus lisible que:

for(Monsters::iterator i = monsters.begin(); i != monsters.end(); ++i) {
    i->think();
} 

Aussi cette (ou avec des lambdas, voir les autres):

for_each(bananas, boost::bind(&Monkey::eat, my_monkey, _1));

Est plus concis que:

for(Bananas::iterator i = bananas.begin(); i != bananas.end(); ++i) {
    my_monkey->eat(*i);
} 

Surtout si vous avez plusieurs fonctions à appeler dans l'ordre... mais peut-être que c'est juste moi. 😉

Mise à jour 2: j'ai écrit mon propre one-liner wrappers de stl-algos qui travaillent avec des plages au lieu de la paire d'itérateurs. boost::range_ex, une fois libéré, comprendra et peut-être qu'il sera là dans C++0x trop?

Personnellement, à chaque fois que j'avais besoin de sortir de ma façon d'utiliser std::for_each (écrire à des fins spéciales de foncteurs /compliqué boost::lambdas), je trouve BOOST_FOREACH et C++0x de gamme à base de mieux:

BOOST_FOREACH(Monster* m, monsters) {
     if (m->has_plan()) 
         m->act();
}

vs

std::for_each(monsters.begin(), monsters.end(), 
  if_then(bind(&Monster::has_plan, _1), 
    bind(&Monster::act, _1)));

Vous êtes la plupart du temps correct: la plupart du temps, std::for_each est une perte nette. J'irais même jusqu'à comparer for_each à goto. goto fournit le plus polyvalent de contrôle de flux possible, vous pouvez l'utiliser pour mettre en œuvre pratiquement toute autre structure de contrôle que vous pouvez imaginer. Que très polyvalence, cependant, signifie que de voir un goto dans l'isolement, vous indique pratiquement rien sur ce qu'il est destiné à faire dans cette situation. En conséquence, presque personne dans leur bon esprit utilise goto, sauf en dernier recours.

Parmi les algorithmes standard, for_each est beaucoup de la même manière, il peut être utilisé pour mettre en œuvre pratiquement rien, ce qui signifie que le fait de voir for_each vous dit pratiquement rien de ce qu'il est utilisé dans cette situation. Malheureusement, l'attitude de la population envers for_each est au sujet de leur attitude à l'égard de goto était de (disons) de 1970, ou alors, un quelques les gens avaient attrapé sur le fait qu'il devrait être utilisé seulement comme un dernier recours, mais beaucoup considèrent encore la principale de l'algorithme, et rarement, sinon jamais utiliser n'importe quel autre. La grande majorité du temps, même un rapide coup d'œil a révélé que l'une des solutions de rechange a été considérablement supérieur.

Juste pour exemple, je suis sûr que j'ai perdu la trace de combien de fois j'ai vu des gens de l'écriture de code pour imprimer le contenu d'une collection à l'aide de for_each. Basé sur des postes que j'ai vu, c'est peut être le seul usage le plus courant de for_each. Ils se retrouvent avec quelque chose comme:

class XXX { 
//...
public:
     std::ostream &print(std::ostream &os) { return os << "my data\n"; }
};

Et leur post est de demander à propos de la combinaison de bind1st, mem_fun, etc. ils ont besoin de faire quelque chose comme:

std::vector<XXX> coll;

std::for_each(coll.begin(), coll.end(), XXX::print);

de travail, et d'imprimer les éléments de coll. Si il a vraiment fait un travail exactement comme je l'ai écrit il y a, il serait médiocre, mais il n'est pas -- et par le temps que vous avez eu à le faire fonctionner, il est difficile d'en trouver quelques bouts de code lié à ce qui se passe parmi les morceaux qui tiennent ensemble.

Heureusement, il ya une bien meilleure façon. Ajouter un flux normal insertion de surcharge pour XXX:

std::ostream &operator<<(std::ostream *os, XXX const &x) { 
   return x.print(os);
}

et l'utilisation std::copy:

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

Qui ne fonctionne pas -- et prend pratiquement pas de travail à tous de comprendre qu'il imprime le contenu de coll à std::cout.

L'avantage de l'écriture fonctionnelle pour être plus lisible, pourrait ne pas se montrer quand for(...) et for_each(...).

Si vous utilisez tous les algorithmes fonctionnels.h, au lieu de l'utiliser pour des boucles, le code est beaucoup plus lisible;

iterator longest_tree = std::max_element(forest.begin(), forest.end(), ...);
iterator first_leaf_tree = std::find_if(forest.begin(), forest.end(), ...);
std::transform(forest.begin(), forest.end(), firewood.begin(), ...);
std::for_each(forest.begin(), forest.end(), make_plywood);

est beaucoup plus lisible qu';

Forest::iterator longest_tree = it.begin();
for (Forest::const_iterator it = forest.begin(); it != forest.end(); ++it{
   if (*it > *longest_tree) {
     longest_tree = it;
   }
}

Forest::iterator leaf_tree = it.begin();
for (Forest::const_iterator it = forest.begin(); it != forest.end(); ++it{
   if (it->type() == LEAF_TREE) {
     leaf_tree  = it;
     break;
   }
}

for (Forest::const_iterator it = forest.begin(), jt = firewood.begin(); 
     it != forest.end(); 
     it++, jt++) {
          *jt = boost::transformtowood(*it);
    }

for (Forest::const_iterator it = forest.begin(); it != forest.end(); ++it{
    std::makeplywood(*it);
}

Et c'est ce que je pense, c'est tellement agréable, de généraliser les pour-boucles à l'une des fonctions de ligne =)

La for_each boucle est destinée à cacher les itérateurs (détail de la façon dont une boucle est mise en œuvre) à partir du code d'utilisateur et de définir clairement la sémantique de l'opération: chaque élément sera réitéré exactement une fois.

Le problème de la lisibilité dans le standard actuel est qu'il nécessite un foncteur comme le dernier argument au lieu d'un bloc de code, de sorte que dans de nombreux cas, vous devez écrire des foncteur type pour elle. Que devient moins lisible le code comme foncteur objets ne peuvent pas être définis en place (local classes définies à l'intérieur d'une fonction ne peuvent pas être utilisés comme arguments de modèle) et la mise en œuvre de la boucle doit être éloigné de la boucle.

struct myfunctor {
   void operator()( int arg1 ) { code }
};
void apply( std::vector<int> const & v ) {
   //code
   std::for_each( v.begin(), v.end(), myfunctor() );
   //more code
}

Noter que si vous souhaitez effectuer une opération spécifique sur chaque objet, vous pouvez utiliser std::mem_fn, ou boost::bind (std::bind dans le prochain standard), ou boost::lambda (lambdas dans le prochain standard) pour faire plus simple:

void function( int value );
void apply( std::vector<X> const & v ) {
   //code
   std::for_each( v.begin(), v.end(), boost::bind( function, _1 ) );
   //code
}

Qui n'est pas moins lisible et plus compact que le roulé à la main de version si vous avez de la fonction/méthode à appeler en place. La mise en œuvre pourrait fournir d'autres implémentations de la for_each boucle (pensez à traitement parallèle).

La norme à venir prend soin de certaines lacunes de différentes manières, il permettra localement les classes définies comme des arguments de modèles:

void apply( std::vector<int> const & v ) {
   //code
   struct myfunctor {
      void operator()( int ) { code }
   };
   std::for_each( v.begin(), v.end(), myfunctor() );
   //code
}

L'amélioration de la localité de code: lorsque vous naviguez, vous voyez ce qu'il fait là. Comme une question de fait, vous n'avez même pas besoin d'utiliser la classe syntaxe pour définir le foncteur, mais d'utiliser une lambda là:

void apply( std::vector<int> const & v ) {
   //code
   std::for_each( v.begin(), v.end(), 
      []( int ) { //code } );
   //code
}

Même si, pour le cas de for_each il y aura un spécifique de la construction qui va la rendre plus naturelle:

void apply( std::vector<int> const & v ) {
   //code
   for ( int i : v ) {
      //code
   }
   //code
}

J'ai tendance à mélanger les for_each à construire avec les roulés à la main boucles. Lorsque seulement un appel à une fonction ou une méthode est ce dont j'ai besoin (for_each( v.begin(), v.end(), boost::bind( &Type::update, _1 ) )) je vais pour le for_each construire qui n'est pas le code d'un lot de chaudière plaque itérateur choses. Quand j'ai besoin de quelque chose de plus complexe et je ne peut pas mettre en œuvre un foncteur juste un couple de lignes au-dessus de l'utilisation réelle, je roule ma propre boucle (qui garde l'opération en place). En non-critique des sections de code, je pourrais aller avec BOOST_FOREACH (un collègue m'a fait ça)

J'ai utilisé le dégoût std::for_each et de la pensée que, sans lambda, il a été fait absolument mauvais. Cependant, j'ai fait changer mon esprit il y a quelques temps, et maintenant je fait l'amour il. Et je pense que c'-même améliore la lisibilité et la rend plus facile à tester votre code dans un TDD façon.

La std::for_each algorithme peut être lu comme faire quelque chose avec tous les éléments de la gamme, qui peut d'améliorer la lisibilité. Dire que l'action que vous voulez effectuer est de 20 lignes de long, et la fonction où l'action est réalisée est également à environ 20 lignes de long. Que ferait une fonction 40 lignes de long, avec un classique de la boucle, et seulement environ 20 à std::for_each, donc probablement plus facile à comprendre.

Foncteurs pour std::for_each sont plus susceptibles d'être plus générique, et donc réutilisables, e.g:

struct DeleteElement
{
    template <typename T>
    void operator()(const T *ptr)
    {
        delete ptr;
    }
};

Et dans le code que tu avais seulement un one-liner comme std::for_each(v.begin(), v.end(), DeleteElement()) ce qui est légèrement mieux IMO qu'explicite d'une boucle.

Toutes ces foncteurs sont normalement plus facile à obtenir en vertu des tests unitaires qu'explicite pour la boucle dans le milieu d'une longue fonction, et que lui seul est déjà une grande victoire pour moi.

std::for_each est généralement plus fiable, que vous êtes moins susceptibles de faire une erreur avec la gamme.

Et enfin, le compilateur peut produire un code un peu meilleur pour std::for_each que pour certains types de main-conçu pour la boucle, comme il (for_each) toujours regarde la même chose pour le compilateur, et les rédacteurs de compilateur peut mettre l'ensemble de leurs connaissances, pour le rendre aussi bon que possible.

Même chose s'applique à d'autres mst algorithmes comme find_if, transform etc.

Si vous utilisez fréquemment d'autres algorithmes de la STL, il y a plusieurs avantages à for_each:

1. Il sera souvent plus simple et moins sujette aux erreurs que d'une boucle for, en partie parce que vous allez être utilisée pour les fonctions avec cette interface, et en partie parce que c'est en réalité un peu plus concis dans de nombreux cas.
2. Bien que toute une gamme à base de boucle for peut être encore plus simple, c'est de moins en moins flexibles (comme indiqué par Adrian McCarthy, il effectue une itération sur l'ensemble d'un récipient).

3. Contrairement aux entreprises traditionnelles pour la boucle, for_each vous oblige à écrire le code qui va travailler pour un itérateur d'entrée. La restriction de cette manière peut effectivement être une bonne chose parce que:

   1. Vous pourriez vraiment besoin d'adapter le code fonctionne pour un autre récipient plus tard.
   2. Au début, il peut vous apprendre quelque chose et/ou de changer vos habitudes pour le mieux.
   3. Même si vous écris toujours pour les boucles qui sont parfaitement équivalentes, d'autres personnes qui modifient le même code ne pourrait pas le faire sans être invité à utiliser for_each.

4. À l'aide de for_each rend parfois plus évident que vous pouvez utiliser un plus spécifiques à la fonction STL pour faire la même chose. (Comme dans Jerry Cercueil de l'exemple; il n'est pas nécessairement le cas que for_each est la meilleure option, mais une boucle for n'est pas la seule alternative.)

Plupart du temps, vous aurez à itérer sur l'ensemble de la collection. Par conséquent, je vous suggère d'écrire votre propre for_each() de la variante, en ne prenant que 2 paramètres. Cela va vous permettre de réécrire Terry Mahaffey l'exemple de comme:

for_each(container, [](int& i) {
    i += 10;
});

Je pense que c'est en effet plus lisible qu'une boucle for. Cependant, cela nécessite le C++0x compilateur extensions.

Vous pouvez avoir l'itérateur être un appel à une fonction qui est exécutée sur chaque itération de la boucle.

Voir ici:
http://www.cplusplus.com/reference/algorithm/for_each/

for_each nous permettre de mettre en œuvre Fork-Join modèle . Autre que cela, il prend en charge fluent interface.

fork-join modèle

Nous pouvons ajouter la mise en œuvre gpu::for_each d'utiliser cuda/gpu pour hétérogène-calcul parallèle en appelant le lambda tâche dans plusieurs travailleurs.

gpu::for_each(users.begin(),users.end(),update_summary);
//all summary is complete now
//go access the user-summary here.

Et gpu::for_each peut attendre pour les travailleurs de travailler sur toutes les lambda-tâches avant la fin de l'exécution de la prochaine consolidés.

fluent interface

Il permet d'écrire de l'homme-un code lisible de manière concise.

accounts::erase(std::remove_if(accounts.begin(),accounts.end(),used_this_year));
std::for_each(accounts.begin(),accounts.end(),mark_dormant);