function, bind and mem

A basic example

void print_num(int i){
    std::cout << i << ’\n’;
}

struct PrintNum {
    void operator()(int i) const{
        std::cout << i << ’\n’;
    }};

std::function<void(int)> f_display = print_num;
f_display(-9); // store a free function

std::function<void()> f_display_42 = []() { print_num(42); };
f_display_42();  // store a lambda

std::function<void()> f_display_31337 = std::bind(print_num, 31337);
f_display_31337(); // store the result of a call to std::bind

std::function<void(int)> f_display_obj = PrintNum();
f_display_obj(18);  // store a call to a function object

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(314159);
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.

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();
}

auto is bind() return type. bind replaces bind1st and bind2nd.

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);
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

mem_fn is faster than bind. so prefer mem_fn first. 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. 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);

1.3.3.2 function, bind and mem_fn