La for_eachboucle a pour but de masquer les itérateurs (détail de l'implémentation d'une boucle) du code utilisateur et de définir une sémantique claire sur l'opération: chaque élément sera itéré exactement une fois.
Le problème de lisibilité dans la norme actuelle est qu'il nécessite un foncteur comme dernier argument au lieu d'un bloc de code, donc dans de nombreux cas, vous devez écrire un type de foncteur spécifique pour celui-ci. Cela se transforme en code moins lisible car les objets foncteurs ne peuvent pas être définis sur place (les classes locales définies dans une fonction ne peuvent pas être utilisées comme arguments de modèle) et l'implémentation de la boucle doit être éloignée de la boucle réelle.
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
}
Notez que si vous souhaitez effectuer une opération spécifique sur chaque objet, vous pouvez utiliser std::mem_fn, ou boost::bind( std::binddans la norme suivante), ou boost::lambda(lambdas dans la norme suivante) pour le rendre 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
}
Ce qui n'est pas moins lisible et plus compact que la version roulée à la main si vous avez une fonction / méthode à appeler en place. L'implémentation pourrait fournir d'autres implémentations de la for_eachboucle (pensez au traitement parallèle).
La norme à venir s'occupe de certaines des lacunes de différentes manières, elle autorisera des classes définies localement comme arguments dans les 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
}
Amélioration de la localité du code: lorsque vous naviguez, vous voyez ce qu'il fait ici. En fait, vous n'avez même pas besoin d'utiliser la syntaxe de classe pour définir le foncteur, mais utilisez un lambda juste 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 for_eachil y aura une construction spécifique qui la rendra plus naturelle:
void apply( std::vector<int> const & v ) {
// code
for ( int i : v ) {
// code
}
// code
}
J'ai tendance à mélanger la for_eachconstruction avec des boucles roulées à la main. Quand seul un appel à une fonction ou une méthode existante est ce dont j'ai besoin ( for_each( v.begin(), v.end(), boost::bind( &Type::update, _1 ) )), je choisis la for_eachconstruction qui enlève au code beaucoup de trucs d'itérateur de plaque chauffante. Quand j'ai besoin de quelque chose de plus complexe et que je ne peux pas implémenter un foncteur juste quelques lignes au-dessus de l'utilisation réelle, je roule ma propre boucle (maintient l'opération en place). Dans les sections non critiques du code, je pourrais utiliser BOOST_FOREACH (un collègue m'a mis dedans)
std::for_eachlorsqu'il est utilisé avecboost.lambdaouboost.bindpeut souvent améliorer la lisibilité