for loop vs std :: for_each mit Lambda

Ich denke, es gibt einige andere Unterschiede, die in den Antworten bisher noch nicht behandelt wurden.

1. ein for_each kann any - geeignetes aufrufbares Objekt akzeptieren, wodurch der Schleifenrumpf für verschiedene for - Schleifen "recycelt" werden kann. Zum Beispiel (Pseudo-Code)

   for( range_1 ) { lengthy_loop_body }    // many lines of code
   for( range_2 ) { lengthy_loop_body }    // the same many lines of code again
   

   wird

   auto loop_body = some_lambda;           // many lines of code here only
   std::for_each( range_1 , loop_body );   // a single line of code
   std::for_each( range_2 , loop_body );   // another single line of code
   

   dadurch werden Doppelarbeit vermieden und die Codewartung vereinfacht. (Natürlich kann man in einem witzigen Stilmix auch einen ähnlichen Ansatz mit der for-Schleife verwenden.)

2. ein weiterer Unterschied betrifft das Ausbrechen der Schleife (mit break oder return in der for-Schleife). Soweit ich weiß, kann dies in einer for_each-Schleife nur durch Auslösen einer Ausnahme erfolgen. Zum Beispiel

   for( range )
   {
     some code;
     if(condition_1) return x; // or break
     more code;
     if(condition_2) continue;
     yet more code;
   }
   

   wird

   try {
     std::for_each( range , [] (const_reference x)
                   {
                     some code;
                     if(condition_1) throw x;
                     more code;
                     if(condition_2) return;
                     yet more code;
                   } );
   } catch(const_reference r) { return r; }
   

   mit den gleichen Auswirkungen hinsichtlich des Aufrufs von Destruktoren für Objekte mit Umfang des Schleifenkörpers und des Funktionskörpers (um die Schleife).

3. der Hauptvorteil von for_each ist IMHO, dass es für bestimmte Containertypen überlastet werden kann, wenn die einfache Iteration nicht so effizient ist. Stellen Sie sich beispielsweise einen Container vor, der eine verknüpfte Liste von Datenblöcken enthält, wobei jeder Block ein zusammenhängendes Array von Elementen enthält, ähnlich wie (Fehlen von irrelevantem Code).

   namespace my {
     template<typename data_type, unsigned block_size>
     struct Container
     {
       struct block
       {
         const block*NEXT;
         data_type DATA[block_size];
         block() : NEXT(0) {}
       } *HEAD;
     };
   }
   

   ein geeigneter Forward-Iterator für diesen Typ müsste dann bei jedem Inkrement nach dem Blockende suchen, und der Vergleichsoperator muss sowohl den Blockzeiger als auch den Index in jedem Block vergleichen (wobei irrelevanter Code weggelassen wird):

   namespace my {
     template<typename data_type, unsigned block_size>
     struct Container
     {
       struct iterator
       {
         const block*B;
         unsigned I;
         iterator() = default;
         iterator&operator=(iterator const&) = default;
         iterator(const block*b, unsigned i) : B(b), I(i) {}
         iterator& operator++()
         {
           if(++I==block_size) { B=B->NEXT; I=0; }    // one comparison and branch
           return*this;
         }
         bool operator==(const iterator&i) const
         { return B==i.B && I==i.I; }                 // one or two comparisons
         bool operator!=(const iterator&i) const
         { return B!=i.B || I!=i.I; }                 // one or two comparisons
         const data_type& operator*() const
         { return B->DATA[I]; }
       };
       iterator begin() const
       { return iterator(HEAD,0); }
       iterator end() const
       { return iterator(0,0); }
     };
   }
   

   diese Art von Iterator funktioniert beispielsweise korrekt mit for und for_each

   my::Container<int,5> C;
   for(auto i=C.begin();
       i!=C.end();              // one or two comparisons here
       ++i)                     // one comparison here and a branch
     f(*i);
   

   erfordert aber zwei bis drei Vergleiche pro Iteration sowie eine Verzweigung. Eine effizientere Methode besteht darin, die Funktion for_each() zu überladen, um den Blockzeiger und den Index separat zu durchlaufen:

   namespace my {
     template<typename data_type, int block_size, typename FuncOfDataType>
     FuncOfDataType&&
     for_each(typename my::Container<data_type,block_size>::iterator i,
              typename my::Container<data_type,block_size>::iterator const&e,
              FuncOfDataType f)
     {
       for(; i.B != e.B; i.B++,i.I=0)
         for(; i.I != block_size; i.I++)
           f(*i);
       for(; i.I != e.I; i.I++)
         f(*i);
       return std::move(f);
     }
   }
   using my::for_each;     // ensures that the appropriate
   using std::for_each;    // version of for_each() is used
   

   dies erfordert nur einen Vergleich für die meisten Iterationen und hat keine Verzweigungen (Beachten Sie, dass Verzweigungen die Performance beeinträchtigen können). Beachten Sie, dass wir dies nicht im Namespace std definieren müssen (was möglicherweise illegal ist), aber Sie können sicherstellen, dass die richtige Version von den entsprechenden using-Anweisungen verwendet wird. Dies ist äquivalent zu using std::swap;, wenn swap() auf bestimmte benutzerdefinierte Typen spezialisiert wird.