C++中可調(diào)用對象的雖然都有一個比較統(tǒng)一的操作形式，但是定義方法五花八門，這樣就導(dǎo)致使用統(tǒng)一的方式保存可調(diào)用對象或者傳遞可調(diào)用對象時，會十分繁瑣。C++11中提供了std::function和std::bind統(tǒng)一了可調(diào)用對象的各種操作。

不同類型可能具有相同的調(diào)用形式，如：

// 普通函數(shù)
int add(int a, int b){return a+b;} 
// lambda表達式
auto mod = [](int a, int b){ return a % b;}
// 函數(shù)對象類
struct divide{
    int operator()(int denominator, int divisor){
        return denominator/divisor;
    }
};

上述三種可調(diào)用對象雖然類型不同，但是共享了一種調(diào)用形式：

int(int ,int)

std::function就可以將上述類型保存起來，如下：

std::function<int(int ,int)>  a = add; 
std::function<int(int ,int)>  b = mod ; 
std::function<int(int ,int)>  c = divide();

2. std::function

std::function 是一個可調(diào)用對象包裝器，是一個類模板，可以容納除了類成員函數(shù)指針之外的所有可調(diào)用對象，它可以用統(tǒng)一的方式處理函數(shù)、函數(shù)對象、函數(shù)指針，并允許保存和延遲它們的執(zhí)行。
定義格式：std::function<函數(shù)類型>。
std::function可以取代函數(shù)指針的作用，因為它可以延遲函數(shù)的執(zhí)行，特別適合作為回調(diào)函數(shù)使用。它比普通函數(shù)指針更加的靈活和便利。

3. std::bind

可將std::bind函數(shù)看作一個通用的函數(shù)適配器，它接受一個可調(diào)用對象，生成一個新的可調(diào)用對象來“適應(yīng)”原對象的參數(shù)列表。

std::bind將可調(diào)用對象與其參數(shù)一起進行綁定，綁定后的結(jié)果可以使用std::function保存。std::bind主要有以下兩個作用：

將可調(diào)用對象和其參數(shù)綁定成一個防函數(shù)；
只綁定部分參數(shù)，減少可調(diào)用對象傳入的參數(shù)。

3.1 std::bind綁定普通函數(shù)

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

bind的第一個參數(shù)是函數(shù)名，普通函數(shù)做實參時，會隱式轉(zhuǎn)換成函數(shù)指針。因此std::bind (my_divide,_1,2)等價于std::bind (&my_divide,_1,2)；
_1表示占位符，位于<functional>中，std::placeholders::_1；

3.2 std::bind綁定一個成員函數(shù)

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

bind綁定類成員函數(shù)時，第一個參數(shù)表示對象的成員函數(shù)的指針，第二個參數(shù)表示對象的地址。
必須顯示的指定&Foo::print_sum，因為編譯器不會將對象的成員函數(shù)隱式轉(zhuǎn)換成函數(shù)指針，所以必須在Foo::print_sum前添加&；
使用對象成員函數(shù)的指針時，必須要知道該指針屬于哪個對象，因此第二個參數(shù)為對象的地址 &foo；

3.3 綁定一個引用參數(shù)

默認情況下，bind的那些不是占位符的參數(shù)被拷貝到bind返回的可調(diào)用對象中。但是，與lambda類似，有時對有些綁定的參數(shù)希望以引用的方式傳遞，或是要綁定參數(shù)的類型無法拷貝。

#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函數(shù)
    for_each(words.begin(), words.end(),
                   bind(print, ref(os1), _1, c));
    cout << os1.str() << endl;
}

4. 指向成員函數(shù)的指針

通過下面的例子，熟悉一下指向成員函數(shù)的指針的定義方法。

#include <iostream>
struct Foo {
    int value;
    void f() { std::cout << "f(" << this->value << ")\n"; }
    void g() { std::cout << "g(" << this->value << ")\n"; }
};
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);
}