快捷導(dǎo)航

C++11 中的std::function和std::bind詳解

更新時(shí)間：2021年10月11日 10:33:11 作者：georgeguo

這篇文章主要介紹了C++ 11 std::function和std::bind,文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧

1. 可調(diào)用對(duì)象

可調(diào)用對(duì)象有一下幾種定義：

是一個(gè)函數(shù)指針，參考 C++ 函數(shù)指針和函數(shù)類(lèi)型；
是一個(gè)具有operator()成員函數(shù)的類(lèi)的對(duì)象；
可被轉(zhuǎn)換成函數(shù)指針的類(lèi)對(duì)象；
一個(gè)類(lèi)成員函數(shù)指針；

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

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

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

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

int(int ,int)

std::function就可以將上述類(lèi)型保存起來(lái)，如下：

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

3. std::bind

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

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

將可調(diào)用對(duì)象和其參數(shù)綁定成一個(gè)防函數(shù)；
只綁定部分參數(shù)，減少可調(diào)用對(duì)象傳入的參數(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的第一個(gè)參數(shù)是函數(shù)名，普通函數(shù)做實(shí)參時(shí)，會(huì)隱式轉(zhuǎn)換成函數(shù)指針。因此std::bind (my_divide,_1,2)等價(jià)于std::bind (&my_divide,_1,2)；
_1表示占位符，位于<functional>中，std::placeholders::_1；

3.2 std::bind綁定一個(gè)成員函數(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綁定類(lèi)成員函數(shù)時(shí)，第一個(gè)參數(shù)表示對(duì)象的成員函數(shù)的指針，第二個(gè)參數(shù)表示對(duì)象的地址。
必須顯示的指定&Foo::print_sum，因?yàn)榫幾g器不會(huì)將對(duì)象的成員函數(shù)隱式轉(zhuǎn)換成函數(shù)指針，所以必須在Foo::print_sum前添加&；
使用對(duì)象成員函數(shù)的指針時(shí)，必須要知道該指針屬于哪個(gè)對(duì)象，因此第二個(gè)參數(shù)為對(duì)象的地址 &foo；

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

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

#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一個(gè)對(duì)象，
    // 而不拷貝它，就必須使用標(biāo)準(zhǔn)庫(kù)提供的ref函數(shù)
    for_each(words.begin(), words.end(),
                   bind(print, ref(os1), _1, c));
    cout << os1.str() << endl;
}

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

通過(guò)下面的例子，熟悉一下指向成員函數(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);
}