Die for_eachSchleife soll die Iteratoren (Details zur Implementierung einer Schleife) vor dem Benutzercode verbergen und eine klare Semantik für die Operation definieren: Jedes Element wird genau einmal iteriert.
Das Problem mit der Lesbarkeit im aktuellen Standard besteht darin, dass anstelle eines Codeblocks ein Funktor als letztes Argument erforderlich ist. In vielen Fällen müssen Sie daher einen bestimmten Funktortyp dafür schreiben. Dies führt zu weniger lesbarem Code, da Funktorobjekte nicht direkt definiert werden können (lokale Klassen, die innerhalb einer Funktion definiert sind, können nicht als Vorlagenargumente verwendet werden) und die Implementierung der Schleife von der eigentlichen Schleife entfernt werden muss.
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
}
Beachten Sie, dass Sie, wenn Sie für jedes Objekt eine bestimmte Operation ausführen möchten std::mem_fn, oder boost::bind( std::bindim nächsten Standard) oder boost::lambda(Lambdas im nächsten Standard) verwenden können, um dies zu vereinfachen:
void function( int value );
void apply( std::vector<X> const & v ) {
// code
std::for_each( v.begin(), v.end(), boost::bind( function, _1 ) );
// code
}
Dies ist nicht weniger lesbar und kompakter als die handgerollte Version, wenn Sie über eine Funktion / Methode zum Aufrufen verfügen. Die Implementierung könnte andere Implementierungen der for_eachSchleife bereitstellen (denken Sie an Parallelverarbeitung).
Der kommende Standard behebt einige der Mängel auf unterschiedliche Weise und ermöglicht lokal definierte Klassen als Argumente für Vorlagen:
void apply( std::vector<int> const & v ) {
// code
struct myfunctor {
void operator()( int ) { code }
};
std::for_each( v.begin(), v.end(), myfunctor() );
// code
}
Verbessern der Lokalität von Code: Wenn Sie surfen, sehen Sie, was er genau dort tut. Tatsächlich müssen Sie nicht einmal die Klassensyntax verwenden, um den Funktor zu definieren, sondern verwenden genau dort ein Lambda:
void apply( std::vector<int> const & v ) {
// code
std::for_each( v.begin(), v.end(),
[]( int ) { // code } );
// code
}
Auch wenn es für den Fall von for_eachein spezifisches Konstrukt gibt, das es natürlicher macht:
void apply( std::vector<int> const & v ) {
// code
for ( int i : v ) {
// code
}
// code
}
Ich neige dazu, das for_eachKonstrukt mit handgerollten Schleifen zu mischen . Wenn ich nur einen Aufruf einer vorhandenen Funktion oder Methode benötige ( for_each( v.begin(), v.end(), boost::bind( &Type::update, _1 ) )), greife ich zu dem for_eachKonstrukt, das dem Code eine Menge Kesselplatten-Iterator-Material wegnimmt. Wenn ich etwas Komplexeres brauche und einen Funktor nicht nur ein paar Zeilen über dem tatsächlichen Gebrauch implementieren kann, rolle ich meine eigene Schleife (hält die Operation an Ort und Stelle). In unkritischen Codeabschnitten könnte ich mich für BOOST_FOREACH entscheiden (ein Mitarbeiter hat mich dazu gebracht).
std::for_eachbei Verwendung mitboost.lambdaoderboost.bindkann oft die Lesbarkeit verbessern