1.6.6 function

• A basic example of std::function variadic template
  //list of callable objects 
  void print_num(int i){  //1) common function 
      std::cout << i << ’\n’; 
  } 
  struct PrintNum {  //2) functor 
      void operator()(int i) const{ std::cout << i ;} 
      }; 
   
  std::function<void(int)> f_display; 
  f_display = print_num; 
  f_display = PrintNum(); 
  f_display = [](int) { print_num(42); }; 
  // you can call fun inside of lambda 
   
  f_display(-9); // call function. 
   
  std::function<void()> f_display_3 = std::bind(print_num, 3);
• Use for member function.
  struct Foo { 
      Foo(int num) : num_(num) {} 
      void print_add(int i) const { std::cout << num_+i << ’\n’; } 
      int num_; 
  }; 
   
  std::function<void(const Foo&, int)> f_add_display = &Foo::print_add; 
  const Foo foo(3); 
  f_add_display(foo, 1); // store a call to a member function 
   
  std::function<void(int)> f_add_display2= 
                         std::bind( &Foo::print_add,  foo,  _1 ); 
  f_add_display2(2); // a call to a member function and object 
   
  std::function<void(int)> f_add_display3= 
                        std::bind( &Foo::print_add, &foo, _1 ); 
  f_add_display3(3); // a call to a member function and object ptr
• function can be used CALL BACK as a function argument.
  void run_within_for_each(std::function<void (int)> func){ 
      vector<int> numbers{ 1, 2, 3, 4, 5, 10, 15, 20, 25 }; 
      for_each(numbers.begin(), numbers.end(), func); 
  } 
   
  void fun(int x){ }  //1) function pointer 
    cout<<x<<endl; 
  }; 
  auto lambda1 = [](int y){  //4) lamba 
     cout << y <<endl; 
  }; 
   
  run_within_for_each(fun); 
  run_within_for_each(lambda1);
• One big advantage of std::function over templates is that if you write a template, you need to put the whole function in the header file, whereas std::function does not. This can really help if you’re working on code that will change a lot and is included by many source files.
• If you want to check if a variable of type std::function is currently holding a valid function, you can always treat it like a boolean:
  std::function<int ()> func; 
  ....... 
  if ( func ) { // if we did have a function, call it 
      func(); 
  }