1.5.3.1 Basic

• Effective STL item 43, Prefer algorithm calls to hand-written loops.
  1. Handing writing is prone to bug
     for( size_t i = 0; i < max; ++i ) 
     d.insert( current++, data[i] + 41 ); // do you see the bug?
  2. You can fix it bu with careful design
     for( size_t i = 0; i < max; ++i ) { 
     current = d.insert( current, data[i] + 41 ); // be careful to 
     keep current validâĂę 
     ++current; // âĂę then increment 
     it when it’s␣safe 
     }
  3. but a better way is
     transform( data, data + max, // copy elements from data 
     inserter(d, d.begin()), // to the front of
  4. With a complex algorithem, just use STL alogrithem+lambda
  5. but a better way is
     for( vector<int>::iterator i = v.begin(); i != v.end(); ++i ) 
     if( *i > x && *i < y ) break; 
      
     // This is better version now. 
     vector<int>::iterator i = find_if( v.begin(), v.end(), [x, y](int &i){i>x && i<y} );

  But if you need a loop that dees something fairly simpler, but would require a confusing tangle of binders and adapters, just use loop.

  list<Widget> lw; 
  type list<Widget>::iterator WI; 
  for_each(lw.begin(),lw.end(), 
                  mem_fun_ref(&Widget::redraw) ); 
   
  transform(data, data+10, inserter(deque, deque.begin()), 
          bind2nd(plus<double>(), 41));
• There are four groups: non modifying sequence , mutating sequence, sorting, generalized numeric operations. Detail can be see c++ primer p1286.
• Note which algorithm expect sorted ranges:
  binary_search lower_bound upper_bound equal_range 
  set_union set_intersection set_difference 
  merge  inplace_merge  includes 
  unique  unique_copy
• Make sure destination ranges are big enough effective stl item 30
  vector<int> values, result; 
  int doSth(int x); // function 
  // make destination range big enough 
  result.reserve(result.size()+values.size() ); 
   
  transform(values.begin(), values,end(), result.end(),doSth ); 
  // It’s error. transform writes its result by making 
  //assignment. result.end() has no object at all 
   
  transform(values.begin(), values,end(), 
    back_inserter(result), doSth)  //insert end 
   
  transform(values.rbegin(), values,rend(), 
    front_insert(result), doSth) 
    //result must be a list 
    // use rbegin make insert in front right order
• Know you sorting options: It makes no sense to sort elements in standard associative containers, because such containers use their comparison functions to remain sorted all the time.
• For other sequence container, sorting options is below: (1-3) need random iterator. 4 only need bidirection iterator.(list)
  1. full sort on vector, string, deque, or array. use sort or stable_sort
  2. put only the top n elements in order, partial_sort
  3. Identify the elements at position n , you need nth_element
  4. spearate the elements of a standard sequence container, do satisfy some criterion, you use partition or stable_partition.
  5. for list, you should use list.sort() in place of common sort.
  vector<Foo> vf; 
  bool compare(const Foo& f1, constFoo& f2); 
  partial_sort(vf.begin(),vf.begin()+20, vf.end(),  compare); 
  sort(vf.begin(),vf.end(), compare); 
  nth_element(vf.begin(),vf.begin()+20,vf.end(), compare); 
   
  bool good(const Foo &f1) 
  partition(vf.begin(), vf.end(), good);
• Be wary of remove-like algorithm on container of pointers
  void delAndNULL(Foo*& pf){ // use pointer reference here. 
  if(!pf->isCertified(){ delete pf; pf = nullptr} 
  } 
  for_each(v.begin(),v.end(), delAndNULL); 
  v.erase(remove(v.begin(),v.end(), 
                   static_cast<Foo *>(0) ), v.end());
• For a algorithms, you need to know three points: 1) what’s function for 2) what iterator it accept, 3) what functor it will accept. So please see below summary.