bind這個東西爭議很多，用起來很迷，而且不利於編譯優化，很多人都推薦用lambda而非bind。簡單說，bind就是通過庫抽象實現了lambda裏需要寫進語言標準的東西，變量捕獲，參數綁定，延遲求值等。但是以此帶來的缺陷就是，雖然bind生成的可調用對象的結構是編譯期確定的，但是它的值，尤其是被調用的函數，全部是在運行期指定的，並且可調用對象也只是一個普通的類，因此很難進行優化。除此之外，標準庫的bind實現，只提供了20個placeholder進行參數綁定，無法擴展，這也是實現的一個坑。因此，在有條件的情況下，應該使用lambda而非bind，lambda是寫入語言標準的特性，編譯器面對一個你寫的lambda，和bind生成的普通的對象相比，可以更加清楚你想要做什麽，並進行針對性的優化。

雖說如此，bind怎麽實現的還是很trick的，這篇文章就講一講bind的實現。

bind的使用

bind的使用分兩步，第一步是生成可調用對象，使用你想要bind的東西和需要捕獲和延遲綁定的參數調用bind，生成一個新的callable。

std::string s;

auto f = mq::bind(&std::string::push_back, std::ref(s), mq::ph<0>);

這裏用的是我自己的實現，bind的第一個參數是你要綁定的callable，這裏是一個成員函數，後面的是用來調用的參數，因為是一個成員函數指針，所以參數的第一個應該是一個對象實例，這裏是一個引用包裝的字符串

std::ref(s)

最後是一個placeholder，他表示對於生成的可調用對象，在調用時第0個參數要被傳到這裏。這裏和標準不一樣，標準的placeholder是從1開始的。

使用起來就是這樣的

f(‘a‘);
f(‘b‘);

這裏用來調用的參數就會被傳給綁定進去的push_back的第0個參數。

bind的實現

首先就是bind生成的對象，要做的就是把callable和後面傳的參數都丟進一個類裏面，這樣就構成了一個綁定對象，bind是這麽實現的，lambda的內部也是這麽實現的。生成的對象叫binder。

template<class TFunc, class
 
... TCaptures>
class binder
{
    using seq = std::index_sequence_for<TCaptures...>;
    using captures = std::tuple<std::decay_t<TCaptures>...>;
    using func = std::decay_t<TFunc>;

    func _func;
    captures _captures;
public:
    explicit binder(TFunc&& func, TCaptures&&... captures)
        : _func(std::forward<TFunc>(func))
        , _captures(std::forward<TCaptures>(captures)...)
    {
    }
    //...

這個實現相當的直接，func就是被綁定的函數，captures是一個tuple，裏面裝了bind調用時第1個參數後面的所有參數，構造函數把這些東西都forward進去存住。註意所有的類型參數都decay過，這是因為要去掉所有的引用，數組退化成指針，不然沒法放進tuple。

而bind，簡單點，就是用調用的參數構造binder而已。

template<class TFunc, class... TCaptures>
decltype(auto) bind(TFunc&& func, TCaptures&&... captures)
{
    return detail::binder<TFunc, TCaptures...>{ std::forward<TFunc>(func), std::forward<TCaptures>(captures)... };
}

這裏用了C++14的decltype(auto)返回值，這個寫法就是通過return語句直接推斷返回類型，並且不做任何decay操作。

binder構造好了，下面就是構造它的operator()重載，函數簽名也是相當的直接：

    //class binder
    template<class... TParams>
    decltype(auto) operator()(TParams&&... params);
};

接受不定數量的參數而已，這裏不同於標準的實現，我沒有用任何的SFINAE來做參數的限制，如果調用的參數有錯，那麽大概會出一大片編譯錯誤。

它的實現是這樣的，我把上面binder的實現再復制過來一份一起看

template<class TFunc, class... TCaptures>
class binder
{
    using seq = std::index_sequence_for<TCaptures...>;
    using captures = std::tuple<std::decay_t<TCaptures>...>;
    using func = std::decay_t<TFunc>;

    func _func;
    captures _captures;
public:
    explicit binder(TFunc&& func, TCaptures&&... captures)
        : _func(std::forward<TFunc>(func))
        , _captures(std::forward<TCaptures>(captures)...)
    {
    }

    template<class... TParams>
    decltype(auto) operator()(TParams&&... params);
};

template<class TFunc, class... TCaptures>
template<class... TParams>
decltype(auto) binder<TFunc, TCaptures...>::operator()(TParams&&... params)
{
    return bind_invoke(seq{}, _func, _captures, std::forward_as_tuple(std::forward<TParams>(params)...));
}

這裏operator()的實現就是調用的bind_invoke，參數是什麽呢，一個index_sequence，之前綁定好的函數和捕獲參數，和這裏傳入的參數列表，參數列表也轉發成tuple，為什麽要做成tuple呢，因為tuple好用啊，後面就看出來了。

bind_invoke獲得了上面這一大坨，它來負責params和_captures正確的組合出來，拿來調用_func。

我們像一下_func應該怎麽調用，這裏可以使用C++17的invoke，

invoke(_func, 參數1, 參數2, ...)

而這些參數1，參數2，是怎麽來的呢，回去看一下調用bind時的captures，如果這個capture不是placeholder，那麽這個就是要放進invoke的對應的位置，而如果是placeholder<I>，那麽就從params裏面取對應的第I個參數放進invoke的位置。

畫個圖就是這個樣子的：

那麽，怎麽實現這種參數的選擇呢，通過包展開

template<size_t... idx, class TFunc, class TCaptures, class TParams>
decltype(auto) bind_invoke(std::index_sequence<idx...>, TFunc& func, TCaptures& captures, TParams&& params)
{
    return std::invoke(func, select_param(std::get<idx>(captures), std::move(params))...);
}

bind_invoke的內部直接調用了標準的std::invoke，傳入了func，和後面的select_param包展開的結果，仔細看以下select_param的部分，這裏是每個select_param對應一個captures的元素和一整個params tuple

那麽select_param的實現大家也基本能猜出來， 對於第一個參數是placeholder<I>的情況，就返回後面的tuple的第I個元素，如果不是，那就返回它的第一個參數。

這裏需要註意，select_param是不能用簡單的重載的，因為對於

template<size_t I>
void foo(plaecholder<I>)

和

template<class T>
void foo(T)

這兩個重載，是不能正確區分placeholder<I>和其他參數的，需要用SFINAE過濾，而我選擇另一種解法，用模板特化，這樣更好擴展。

template<class TCapture, class TParams>
struct do_select_param
{
    decltype(auto) operator()(TCapture& capture, TParams&&)
    {
        return capture;
    }
};

template<size_t idx, class TParams>
struct do_select_param<placeholder<idx>, TParams>
{
    decltype(auto) operator()(placeholder<idx>, TParams&& params)
    {
        return std::get<idx>(std::move(params));
    }
};

這是do_select_param的實現（上）和它的一個特化版本（下），特化版本匹配了參數是placeholder的情況。

而select_param函數本身，就是轉發對do_select_param的調用而已

template<class TCapture, class TParams>
decltype(auto) select_param(TCapture& capture, TParams&& params)
{
    return do_select_param<TCapture, TParams>{}(capture, std::move(params));
}

這樣bind的實現基本上就完結了。還差一個placeholder沒提，這個實現也很簡單，就是

template<size_t idx>
struct placeholder
{
};

為了方便，使用C++14的變量模板來節省一下平時寫placeholder<0>{}的代碼

template<size_t idx>
constexpr auto ph = placeholder<idx>{};

那麽，bind的實現就基本完結了！

擴展支持嵌套bind

標準的bind是支持嵌套的，比如如下代碼

// nested bind subexpressions share the placeholders
auto f2 = std::bind(f, _3, std::bind(g, _3), _3, 4, 5);
f2(10, 11, 12); // makes a call to f(12, g(12), 12, 4, 5);

嵌套bind也要可以共享調用時的placeholder，這個實現也很簡單，只要給上面的do_select_param再增加一個特化，對於參數是binder的類型，嵌套地調用它就好了

template<class TFunc, class... TCaptures, class TParams>
struct do_select_param<binder<TFunc, TCaptures...>, TParams>
{
    decltype(auto) operator()(binder<TFunc, TCaptures...>& binder, TParams& params)
    {
        return apply(binder, std::move(params));
    }
};

這裏使用了C++17的apply，就是用tuple的參數包去調用一個函數，如果你的STL還沒有實現它，自己去cppreference抄一個實現也行。

至此，bind的實現就完成了，這個實現可以通過cppreference上的所有測試代碼，我沒有做進一步的測試，如果有錯，歡迎在下面評論區指出，謝謝。

淺談std::bind的實現