1.6.7 lambda

• lambda basic syntax and an example.
  [ captures ] (parameters) -> returnTypesDeclaration { ..; } 
   
  int sum = 0, divisor = 3; 
  vector<int> vc { 1, 2, 3, 4, 5, 10, 15, 20, 25, 35, 45 }; 
  for_each(vc.begin(), vc.end(), [divisor, &sum] (int y){ 
        if (y % divisor == 0){ 
           cout << y << endl; 
           sum += y; 
        } 
    }); 
   cout << sum << endl;
• Lambda is used on complex type container. You can use typedef.
  typedef std::vector< std::pair<int,std::string> > Record_t; 
  //______________________________________________________________________________ typedef is your good friend, reuse it below 
  Record_t k1; 
   
  int find_it(std::string value, __________________Record_t const& stuff){ 
    auto fit = std::find_if(stuff.begin(), stuff.end(), 
              [value](__________________________________________Record_t::value_type const& vt) -> bool 
                   { return vt.second == value; }); 
    if (fit != stuff.end()) 
             return fit->first; 
  }
• This auto-declaration defines a closure type named factorial that you can call later instead of typing the entire lambda expression (a closure type is in fact a compiler-generated function class):
  auto factorial = [](int i, int j) {return i * j;}; 
   
  int arr{1,2,3,4,5,6,7,8,9,10,11,12}; 
  long res = std::accumulate(arr, arr+12, 1, factorial); 
  cout<<"12!="<<res<<endl; // 479001600
• Under the final C++11 spec, if you have a lambda with an empty capture specification, then it can be treated like a regular function and assigned to a function pointer. Here’s an example of using a function pointer with a capture-less lambda:
  typedef int (*func)(); 
  func f = [] () -> int { return 2; }; 
  f();
• A delegate. When you call a normal function, all you need is the function itself. When you call a method on an object, you need two things: the function and the object itself. It’s the difference between func() and obj.method(). Starting with some code that again expects a function as an argument, into which we’ll pass a delegate. lambda is like a glue to combine for_each and class MessageSizeStor().
  class MessageSizeStore{ 
      public: 
      MessageSizeStore () : _max_size( 0 ) {} 
      void getMaxMessage (const std::string& message ) {...} 
      int getSize (){...} 
  private: 
      int _max_size; 
  }; 
   
  MessageSizeStore size_store; 
  for_each(s.begin(),s.end(), 
          [&] (const std::string& message) { 
                 size_store.checkMessage( message ); 
                 });
• Why lambda? 1) It can be inline, 2) It can access all the automatic varaible
  int count3 = 0; 
  std::count_if(v.begin(), v.end(), 
  [&count3](int x){count3 += (x%3 == 0)} ); 
  //how many number can be divided by 3.
• Always use auto as bind() return type. bind replaces bind1st and bind2nd.
  __________________________________________________________________using namespace std::placeholders; 
  void f(int n1, int n2, int n3, const int& n4, int n5){ 
      std::cout << n1 << n2  << n3 << n4  << n5 << ’\n’; 
  } 
  int g(int n1){ 
      return n1; 
  } 
   
  int n = 7; 
  auto f1 = std::bind(f, _2, _1, 42, std::cref(n), n); 
  ____________________________________________________________________________________\\follow f, you have to give 5 arguments. 
  __________________________________________________________________\\_2 and _1 represent position in f1. 
  n = 10; 
  f1(1, 2, 1001); // 1 is bound _2, 2 is bound _1, 1001 unused 
  //2,1,42,10,7 
   
  auto f2 = std::bind(f, _3, std::bind(g, _3), _3, 4, 5); 
  f2(10, 11, 12); 
  //12,12,12,4,5
  1. f1 and f2 are both variadic template function, so you can input any number of arguments
  2. but you need to know which argument is input to f
  3. you need to use inplace holder
• mem_fn(C++11) and mem_fun
  1. mem_fn is faster than bind. so prefer mem_fn first.
  2. std::mem_fun can only deal with member functions that take one or no argument. std::mem_fn is variadic and can deal with members that take any number of arguments.
  3. You also need to pick between std::mem_fun and std::mem_fun_ref depending on whether you want to deal with pointers or references for the class object (respectively). std::mem_fn alone can deal with either, and even provides support for smart pointers.
  struct Foo { 
      void display_number(int i) { 
          std::cout << "number:␣" << i << ’\n’; 
      } 
      int data = 7; 
  }; 
   
  Foo f; 
  auto print_num = std::mem_fn(&Foo::display_number); 
  print_num(f, 42); ___________________________________________________________________________// for mem_fn, you have to give a object:f