1.std::bind

标准库函数bind()和function()定义于头文件中（该头文件还包括许多其他函数对象），用于处理函数及函数参数。bind()接受一个函数（或者函数对象，或者任何你可以通过”(…)”符号调用的事物），生成一个其有某一个或多个函数参数被“绑定”或重新组织的函数对象。（译注：顾名思义，bind()函数的意义就像它的函数名一样，是用来绑定函数调用的某些参数的。）例如：

1 #include<iostream>
2 using namespace std;
3 int  main()
4 {
5         auto func = [] () {cout << "hello world"; };
6           
7         func();//now call the function
8 }

参数的绑定通常称为”Currying”（译注：Currying—“烹制咖喱烧菜”，此处意指对函数或函数对象进行加工修饰操作）, “_1″是一个占位符对象，用于表示当函数f通过函数ff进行调用时，函数ff的第一个参数在函数f的参数列表中的位置。第一个参数称为”_1″, 第二个参数为”_2″，依此类推。例如：

1 int f(int, char, double);
2 auto frev =bind(f, _3, _2, _1); //翻转参数顺序
3 int x = frev(1.2, 'c',7); //f(7, 'c'.1.2);

此处，auto关键字节约了我们去推断bind返回的结果类型的工作。

我们无法使用bind()绑定一个重载函数的参数，我们必须显式地指出需要绑定的重载函数的版本：

1 int g(int);
2 double g(double);
3 
4 auto g1= bind(g,_1); //错误，调用哪一个g（）？
5 //正确,但是相当丑陋
6 auto g2=bind( ( double(*) (double))g, _1);

bind()有两种版本：一个如上所述，另一个则是“历史遗留”的版本：你可以显式地描述返回类型。例如：

1         auto f2 = bind<int> (f, 7, ‘c’, _1);      // 显式返回类型
2 
3         int x = f2(1.2);                    // f(7, ‘c’, 1.2);

第二种形式的存在是必要的，并且因为第一个版本（(?) “and for a user simplest “，此处请参考原文)）无法在C++98中实现。所以第二个版本已经被广泛使用。

1.1 std::bind绑定普通函数

double my_divide (double x, double y) {return x/y;}
auto fn_half = std::bind (my_divide,_1,2);  
std::cout << fn_half(10) << '
';                        // 5

bind的第一个参数是函数名，普通函数做实参时，会隐式转换成函数指针。因此std::bind (my_divide,_1,2)等价于std::bind (&my_divide,_1,2)；
_1表示占位符，位于<functional>中，std::placeholders::_1；

1.2 std::bind绑定一个成员函数

struct Foo {
    void print_sum(int n1, int n2)
    {
        std::cout << n1+n2 << '
';
    }
    int data = 10;
};
int main() 
{
    Foo foo;
    auto f = std::bind(&Foo::print_sum, &foo, 95, std::placeholders::_1);
    f(5); // 100
}

bind绑定类成员函数时，第一个参数表示对象的成员函数的指针，第二个参数表示对象的地址。
必须显示的指定&Foo::print_sum，因为编译器不会将对象的成员函数隐式转换成函数指针，所以必须在Foo::print_sum前添加&；
使用对象成员函数的指针时，必须要知道该指针属于哪个对象，因此第二个参数为对象的地址 &foo；

1.3 绑定一个引用参数

默认情况下，bind的那些不是占位符的参数被拷贝到bind返回的可调用对象中。但是，与lambda类似，有时对有些绑定的参数希望以引用的方式传递，或是要绑定参数的类型无法拷贝。

#include <iostream>
#include <functional>
#include <vector>
#include <algorithm>
#include <sstream>
using namespace std::placeholders;
using namespace std;

ostream & print(ostream &os, const string& s, char c)
{
    os << s << c;
    return os;
}

int main()
{
    vector<string> words{"helo", "world", "this", "is", "C++11"};
    ostringstream os;
    char c = ' ';
    for_each(words.begin(), words.end(), 
                   [&os, c](const string & s){os << s << c;} );
    cout << os.str() << endl;

    ostringstream os1;
    // ostream不能拷贝，若希望传递给bind一个对象，
    // 而不拷贝它，就必须使用标准库提供的ref函数
    for_each(words.begin(), words.end(),
                   bind(print, ref(os1), _1, c));
    cout << os1.str() << endl;
}

1.4. 指向成员函数的指针

通过下面的例子，熟悉一下指向成员函数的指针的定义方法。

#include <iostream>
struct Foo {
    int value;
    void f() { std::cout << "f(" << this->value << ")
"; }
    void g() { std::cout << "g(" << this->value << ")
"; }
};
void apply(Foo* foo1, Foo* foo2, void (Foo::*fun)()) {
    (foo1->*fun)();  // call fun on the object foo1
    (foo2->*fun)();  // call fun on the object foo2
}
int main() {
    Foo foo1{1};
    Foo foo2{2};
    apply(&foo1, &foo2, &Foo::f);
    apply(&foo1, &foo2, &Foo::g);
}

成员函数指针的定义：void (Foo::*fun)()，调用是传递的实参: &Foo::f；
fun为类成员函数指针，所以调用是要通过解引用的方式获取成员函数*fun,即(foo1->*fun)();

2. std::function

function是一个拥有任何可以以”(…)”符号进行调用的值的类型。特别地，bind的返回结果可以赋值给function类型。function十分易于使用。（译注：更直观地，可以把function看成是一种表示函数的数据类型，就像函数对象一样。只不过普通的数据类型表示的是数据，function表示的是函数这个抽象概念。）例如：

 1         // 构造一个函数对象，
 2 
 3         // 它能表示的是一个返回值为float，
 4 
 5         // 两个参数为int，int的函数
 6 
 7         function<float (int x, int y)> f;   
 8 
 9         // 构造一个可以使用"()"进行调用的函数对象类型
10 
11         struct int_div {
12 
13                 float operator() (int x, int y) const
14 
15                      { return ((float)x)/y; };
16         };
17         f = int_div();                    // 赋值
18         cout<< f(5,3) <<endl;  // 通过函数对象进行调用
19         std::accumulate(b, e, 1, f);        // 完美传递

成员函数可被看做是带有额外参数的自由函数：

 1         struct X {
 3                 int foo(int); 
 5         };
 9         // 所谓的额外参数，
11         // 就是成员函数默认的第一个参数，
13         // 也就是指向调用成员函数的对象的this指针 
15         function<int (X*, int)> f; 
17         f = &X::foo;            // 指向成员函数
21         X x;
23         int v = f(&x, 5);  // 在对象x上用参数5调用X::foo()
25         function<int (int)> ff = std::bind(f, &x, _1);    // f的第一个参数是&x
27         v = ff(5);                // 调用x.foo(5)

function对于回调函数、将操作作为参数传递等十分有用。它可以看做是C++98标准库中函数对象mem_fun_t, pointer_to_unary_function等的替代品。同样的，bind()也可以被看做是bind1st()和bind2nd()的替代品，当然比他们更强大更灵活。

function是一组函数对象包装类的模板，实现了一个泛型的回调机制。

引入头文件

#include <functional>
using namespace std;
using namespace std::placeholders; //bind的时候会用`

参考：http://www.cnblogs.com/hujian/archive/2012/12/07/2807605.html

fuction bind:http://blog.csdn.net/fjb2080/article/details/7527715

我们可以调用的对象有很多，比如普通函数、函数指针、lambda表达式、函数对象和类的成员函数等。

不管采用哪种方式，主要调用形式一样（返回值类型、传递给调用的实参类型），我们就可以使用同一种形式来调用。

这个时候就可以用到function模板，它给予我们在调用的方式上更大的弹性。

请看一下三种不同的函数定义：

1 int add(int a, int b){//普通函数
2     return a+b;
3 }
4 auto mod=[](int a, int b){return a%b;}; //lambda 函数

5 struct divide{  //函数对象
6     int operator()(int m, int n){
7         return m/n;
8     }
9 };

这三种都可以使用同一种调用形式，int(int, int)，调用方式如下：

1  function<int(int,int)> func1= add;
2  function<int(int,int)> func2= divide();
3  function<int(int,int)> func3= mod;
4  cout<<func1(5, 6)<<endl;
5  cout<<func2(5, 6)<<endl;
6  cout<<func3(5, 6)<<endl;

学会了使用function，可以继续如下进行抽象定义，不同类型采用相同的调用方法：

1  map<string,function<int(int, int)>> funs =
2     {
3         {"+", add},
4         {"-", std::minus<int>()},//标准库的函数，参数为两个整数，可以参考前一篇博客
5         {"/", divide()},//类成员函数
6         {"*", [](int i,int j){return i*j;}},//lambda表达式
7         {"%", mod},
8     };
9     funs["+"](4,6);

以上就是function的简单使用。下面是从另一篇博客转载的，使用function的引用来保存函数对象。考虑下面代码：

 1 class CAdd
 2 
 3 {
 4 public:
 5     CAdd():m_nSum(0){NULL;}
 6     int operator()(int i)
 7     {
 8         m_nSum += i;
 9         return m_nSum;
10     }
11     int Sum() const
12     {
13         return m_nSum;
14     }
15 private:
16     int m_nSum;
17 };
18 int main(int argc, const char * argv[])
19 {
20     CAdd cAdd;
21     function<int(int)> funcAdd1 = cAdd;
22     function<int(int)> funcAdd2 = cAdd;
23     cout<<funcAdd1(10)<<endl;
24     cout<<funcAdd2(10)<<endl;
25     cout<<cAdd.Sum()<<endl;
26      return 0;
27 }

上面的输出结果是 10 10 0。我们将同一个函数对象赋值给了两个function，然后分别调用这两个function，但函数中的成员变量的值没有保存，问题在哪里？因为function的缺省行为是拷贝一份传递给它的函数对象，于是f1,f2中保存的都是cAdd对象的拷贝。
C++11提供了ref和cref函数来提供对象的引用和常引用的包装。要是function能够正确保存函数对象的状态，可以如下修改代码：

1     function<int(int)> funcAdd3 = ref(cAdd);
2     function<int(int)> funcAdd4 = ref(cAdd);
3     cout<<funcAdd3(10)<<endl;
4     cout<<funcAdd4(10)<<endl;
5     cout<<cAdd.Sum()<<endl;

另外，两个function之间赋值时，如果源function保存的是函数对象的拷贝，则目标function保存的也是函数对象的拷贝。如果源function保存的是对函数对象的引用，则目标function保存的也是函数对象的引用。