函数 bind 实现原理初探（一）

最新推荐文章于 2022-08-25 18:57:17 发布
最新推荐文章于 2022-08-25 18:57:17 发布
阅读量64 收藏
点赞数
文章标签： c/c++ python
原文链接：https://my.oschina.net/zhcosin/blog/205426
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

    C++ 并不是一门支持函数式编程的语言，但它可以通过函数对象这个概念在一定程度上模仿函数式编程的方式。在很多情况下，往往需要将某个函数的部分参数进行提前绑定后形成一个新的函数以供使用，例如我们需要遍历一个容器，将其中小于某个指定值的元素删除，这里就需要一个函数对象，接受一个参数，并判断此参数是否小于指定值。在通常情况下我们是有一个元素类型的大小比较的函数，但它接受的是两个参数，这就需要一个接口适配，这就带来了挑战。幸而我们有绑定技术，比如 boost::bind，则可以将其中一个参数进行绑定，从而将接受两个参数的函数转化为只接受一个参数的函数对象（注意是对象，它是一个类的对象）。

    函数对象在这里是一个核心概念，它是重载了 operator() 函数的类的对象，从而它表现得像个函数一样可以进行传参并调用。而绑定技术就是在函数对象内部保存原始函数的指针，并将被绑定的参数也保存起来，在使用这个对象调用的时候则将保存的参数取出来与传入的参数一起传递给原始函数完成调用。例如就前面提到的问题，可以将大小比较函数（假如是小于）的第二个参数绑定为指定值得到一个函数对象，此时函数对象内部保存了这个指定值，而第一个参数则是使用被称为“占位符”的东西所占据，在后面进行调用这个函数并传递一个参数的时候，它使用传入的函数作为原始函数的第一个实参，而将内部保存的参数作为原始函数的第二个实参，然后调用原始函数，完成大小比较并返回 bool 值以供作是否删除的依据。

    绑定原理大致如此，但现在我更感兴趣的是如何实现，虽然我没有看过 boost::bind 的实现代码（事实上是看过但没看懂），但照着上面的思路还是实现了一个简单版本出来，本文接下来就是讲解实现过程，以接受两个参数的函数为例。

    我们需要一个“占位符”之类的东东，这东西主要是在构造函数对象的时候指定原始函数的哪些参数是需要在调用函数的时候传递的，而剩下的参数则是需要在构造函数时进行绑定的。它的实现没有什么内容，内部就是一个整数，指明它占的是第几个参数，但由于我们需要在编译期知道这个索引，所以使用了模板:

template<int index>
class place_holder
{
public:
     static const int place_index = index;
};

place_holder<1> _1;
place_holder<2> _2;

    上面顺便定义了两个占位符，分别用来占第一个参数的位置和第二个参数的位置。然后我们需要在函数对象内部保存原始函数的指针，所以我们在 bind 的内部有如下定义:

template<typename RT, typename T1, typename T2>
class bind
{
     typedef RT (*fun_type)(T1, T2);
     fun_type f;
};

    其中 RT 是函数返回值类型，T1 与 T2 分别是两个参数的类型。接下来考虑要在函数对象内部保存绑定的参数，所以需要一个表示参数的东东，而且这个参数也可能是通过占位符表示的，所以有：

template<typename T>
class arg_item
{
 T val;
 bool holder;

public:
 arg_item(const T& v, bool h) : val(v), holder(h) {}
 T value() {return val;}
 bool isholder() {return holder;}
};

    成员 holder 代表此参数是否是用占位符代替的，而 val 则代表参数的值.接下来考虑如何在函数对象内保存参数列表.我们专门写一个容器来容纳参数列表，为了将 arg_item<T> 都放入一个容器里，我们需要arg_item<T> 都有同一类型(T不同则类型则不同)，所以我们先给 arg_item 添加一个基类，以便在容器里放置基类的指针:

class arg_item_base
{
public:
 virtual ~arg_item_base() {}
};

    而 arg_item<T> 现在就要从这个基类进行继承了：

template<typename T>
class arg_item : public arg_item_base
{
 T val;
 bool holder;

public:
 arg_item(const T& v, bool h) : val(v), holder(h) {}
 T value() {return val;}
 bool isholder() {return holder;}
};

    而我们参数容器，则可以实现如下：

template<typename T1, typename T2>
class arg_list
{
 std::vector<arg_item_base*> arg_container;

public:
 arg_list(T1 p1, T2 p2)
 {
 arg_container.push_back(new arg_item<T1>(p1, false));
 arg_container.push_back(new arg_item<T2>(p2, false));
 }
 arg_list(const place_holder<1>&, T2 p2)
 {
 arg_container.push_back(new arg_item<T1>(T1(), true));
 arg_container.push_back(new arg_item<T2>(p2, false));
 }
 arg_list(T1 p1, const place_holder<2>&)
 {
 arg_container.push_back(new arg_item<T1>(p1, false));
 arg_container.push_back(new arg_item<T2>(T2(), true));
 }
 arg_list(const place_holder<1>&, const place_holder<2>&)
 {
 arg_container.push_back(new arg_item<T1>(T1(), true));
 arg_container.push_back(new arg_item<T2>(T2(), true));
 }

 ~arg_list()
 {
 for (std::size_t i = 0; i < arg_container.size(); ++i)
 {
 delete arg_container[i];
 }
 }
};

    这里要注意构造函数中，如果第一个参数使用占位符，则必须使用 place_holder<1>，如果第二个参数使用占位符，则必须使用 place_holder<2>，千万不能乱来，并且对于占位符的情况，相应的 arg_item<T> 的构造函数第二个参数一定要传递 true，以代表该参数是使用占位符表示的。这里 arg_item 都是通过 new 在堆上进行分配的，这显然性能不佳，后面再讲如何将它们放到栈上来，这里先以讲原理为主。

    接下来我们就可以考虑在 bind 里放置一个 arg_list<T1, T2> 的成员以代表参数列表，但是在后面进行调用的时候需要从参数列表里取出某些参数，所以 arg_list 需要提供这样的接口，给一个索引，就给出相应位置上的参数项 arg_item<T>，所以添加一个 get 成员函数，但由于各参数项的实际类型并不相同(参数类型T不一样)，所以 get 函数的返回类型需要做一个处理，为参数的索引和对应的参数类型作一个关联，于是 arg_list<T1, T2> 修改如下：

template<typename T1, typename T2>
class arg_list
{
 std::vector<arg_item_base*> arg_container;

public:
 template<int index>
 struct arg_index_type_traits;

 template<>
 struct arg_index_type_traits<1>
 {
 typedef T1 value_type;
 };

 template<>
 struct arg_index_type_traits<2>
 {
 typedef T2 value_type;
 };

public:
 arg_list(T1 p1, T2 p2)
 {
 arg_container.push_back(new arg_item<T1>(p1, false));
 arg_container.push_back(new arg_item<T2>(p2, false));
 }
 arg_list(const place_holder<1>&, T2 p2)
 {
 arg_container.push_back(new arg_item<T1>(T1(), true));
 arg_container.push_back(new arg_item<T2>(p2, false));
 }
 arg_list(T1 p1, const place_holder<2>&)
 {
 arg_container.push_back(new arg_item<T1>(p1, false));
 arg_container.push_back(new arg_item<T2>(T2(), true));
 }
 arg_list(const place_holder<1>&, const place_holder<2>&)
 {
 arg_container.push_back(new arg_item<T1>(T1(), true));
 arg_container.push_back(new arg_item<T2>(T2(), true));
 }

 ~arg_list()
 {
 for (std::size_t i = 0; i < arg_container.size(); ++i)
 {
 delete arg_container[i];
 }
 }

public:
 template<int index>
 inline arg_item<typename arg_index_type_traits<index>::value_type>*
 get()
 {
 typedef typename arg_index_type_traits<index>::value_type arg_type;
 return dynamic_cast<arg_item<arg_type>*>(arg_container[index - 1]);
 }

};

    到了这里，准备工作就做的相当足够了，剩下的事就是实现 bind 了，这个不是什么难事，如下：

template<typename RT, typename T1, typename T2>
class bind
{
 typedef RT (*fun_type)(T1, T2);
 fun_type f;
 arg_list<T1, T2> para_list;

public:
 bind(fun_type fun, T1 p1, T2 p2) : f(fun), para_list(p1, p2) {}
 bind(fun_type fun, const place_holder<1>& ph1, T2 p2) : f(fun), para_list(ph1, p2) {}
 bind(fun_type fun, T1 p1, const place_holder<2>& ph2) : f(fun), para_list(p1, ph2) {}
 bind(fun_type fun, const place_holder<1>& ph1, const place_holder<2>& ph2) : f(fun), para_list(ph1, ph2) {}

 RT operator()()
 {
 assert(!para_list.get<1>()->isholder());
 assert(!para_list.get<2>()->isholder());

 return f(para_list.get<1>()->value(), para_list.get<2>()->value());
 }

 RT operator()(T1 r1)
 {
 assert(para_list.get<1>()->isholder());
 assert(!para_list.get<2>()->isholder());

 return f(r1, para_list.get<2>()->value());
 }

 RT operator()(T2 r2)
 {
 assert(!para_list.get<1>()->isholder());
 assert(para_list.get<2>()->isholder());

 return f(para_list.get<1>()->value(), r2);
 }

 RT operator()(T1 r1, T2 r2)
 {
 assert(para_list.get<1>()->isholder());
 assert(para_list.get<2>()->isholder());

 return f(r1, r2);
 }
};

    然后写点测试代码测测看：

int test(int n, bool b)
{
 return b ? ++n : --n;
}

int main()
{
 bind<int, int, bool> add_fun(test, _1, true);
 std::cout << "add_fun(10) = " << add_fun(10) << std::endl;

 bind<int, int, bool> de_fun(test, _1, false);
 std::cout << "de_fun(10) = " << de_fun(10) << std::endl;

 bind<int, int, bool> u_fun(test, _1, _2);
 std::cout << "u_fun(10, true) = " << u_fun(10, true) << std::endl;
 std::cout << "u_fun(10, false) = " << u_fun(10, false) << std::endl;

 bind<int, int, bool> ua_fun(test, 10, true);
 std::cout << "ua_fun() = " << ua_fun() << std::endl;

 bind<int, int, bool> ud_fun(test, 10, false);
 std::cout << "ud_fun() = " << ud_fun() << std::endl;


 return 0;
}

    不出意外的话，你将看到如下输出：

add_fun(10) = 11
de_fun(10) = 9
u_fun(10, true) = 11
u_fun(10, false) = 9
ua_fun() = 11
ud_fun() = 9

    到现在为止，一切似乎都工作的很好，原则性问题已经解决，但还有若干问题需要解决，首先是性能的问题，因为在保存参数列表的时候使用了堆内存，这个怎么都是不可接受的，要使用栈上的空间也不是难事，且看重新实现的 arg_list：

template<typename T1, typename T2>
class arg_list
{
 std::vector<arg_item_base*> arg_container;
 arg_item<T1> a1;
 arg_item<T2> a2;

 void init()
 {
 arg_container.push_back(&a1);
 arg_container.push_back(&a2);
 }

public:
 template<int index>
 struct arg_index_type_traits;

 template<>
 struct arg_index_type_traits<1>
 {
 typedef T1 value_type;
 };

 template<>
 struct arg_index_type_traits<2>
 {
 typedef T2 value_type;
 };

public:
 arg_list(T1 p1, T2 p2) : a1(p1, false), a2 (p2,false)
 {
 init();
 }
 arg_list(const place_holder<1>&, T2 p2) : a1(T1(), true), a2(p2, false)
 {
 init();
 }
 arg_list(T1 p1, const place_holder<2>&) : a1(p1, false), a2(T2(), true)
 {
 init();
 }
 arg_list(const place_holder<1>&, const place_holder<2>&) : a1(T1(), true), a2(T2(), true)
 {
 init();
 }

 ~arg_list(){}

public:
 template<int index>
 inline arg_item<typename arg_index_type_traits<index>::value_type>*
 get()
 {
 typedef typename arg_index_type_traits<index>::value_type arg_type;
 return dynamic_cast<arg_item<arg_type>*>(arg_container[index - 1]);
 }

};

    咋一看，似乎参数有重复保存的问题，但要注意那个 vector 里保存的是指针，所以这并不是问题，而且避免了堆内存的申请和释放，所得远远大于所失啊。

    接着有一个更为严重的问题，就是上述实现对正确使用的情况没有问题，但如果我的绑定与我的调用不匹配，比如我第一个参数使用了占位符，而在调用的时候却给了一个布尔值（意图让其传递给第二个参数），这明显是绑定意图与调用意图不相匹配，但程序却能运行下去，只是在给原始函数传递第一个参数的时候，由于是按照占位符的情况构造的 arg_item<int>，里面保存的 val 是一个默认值0，从而导致运行结果不是我们期望的结果！这显然是一个致命的问题，我们希望在绑定与调用不相匹配的情况下让程序出错，可以是运行时崩溃，最好是连编译都通不过。

   本人只讲让其运行时崩溃的办法，叙述如下，从 bind 的 operator() 实现可以看出，对于绑定的参数，是通过 arg_item<T> 的 value() 成员取出它之前保存的值，而如果这个参数当初是用占位符形式构造的，是不应当有对 value() 的调用的，于是希望能对用真实值构造的 arg_item 与用点位符构造的 arg_item 做一个类型上的区分，让用占位符构造的 arg_item 直接就没有 value() 成员函数，于是将 arg_item 添加一个模板参数，以指示该参数是否用点位符:

template<typename T, bool isholder>
class arg_item;

template<typename T>
class arg_item<T, false> : public arg_item_base
{
 T val;

public:
 static const bool isholder = false;

 arg_item() {}
 arg_item(const T& v) : val(v){}

 T value() {return val;}
};

template<typename T>
class arg_item<T, true> : public arg_item_base
{
public:
 static const bool isholder = true;
};

    相应的 arg_list 也要做出调整：

template<typename T1, typename T2>
class arg_list
{
 std::vector<arg_item_base*> arg_container;

 arg_item<T1, true> ap1;
 arg_item<T1, false> a1;

 arg_item<T2, true> ap2;
 arg_item<T2, false> a2;

public:
 template<int index>
 struct arg_index_type_traits;

 template<>
 struct arg_index_type_traits<1>
 {
 typedef T1 value_type;
 };

 template<>
 struct arg_index_type_traits<2>
 {
 typedef T2 value_type;
 };

public:
 arg_list(T1 p1, T2 p2) : a1(p1), a2 (p2)
 {
 arg_container.push_back(&a1);
 arg_container.push_back(&a2);
 }
 arg_list(const place_holder<1>&, T2 p2) : a2(p2)
 {
 arg_container.push_back(&ap1);
 arg_container.push_back(&a2);
 }
 arg_list(T1 p1, const place_holder<2>&) : a1(p1)
 {
 arg_container.push_back(&a1);
 arg_container.push_back(&ap2);
 }
 arg_list(const place_holder<1>&, const place_holder<2>&)
 {
 arg_container.push_back(&ap1);
 arg_container.push_back(&ap2);
 }

 ~arg_list(){}

public:
 inline arg_item_base* get(int index)
 {
 return arg_container[index - 1];
 }

};

    可以看出，每个参数保存了两个，一个是用真实值绑定的，一个是用占位符的，但 vector 内却是用了哪个保存哪个，而另外 get 的接口也做了一个调整，因为在这里它并不知道里面保存的是 arg_item<T, true> 还是 arg_item<T, false>，这个由后面调用的时候去处理。

    而 bind 的实现也应做出相应的变动：

template<typename RT, typename T1, typename T2>
class bind
{
 typedef RT (*fun_type)(T1, T2);
 fun_type f;
 arg_list<T1, T2> para_list;

public:
 bind(fun_type fun, T1 p1, T2 p2) : f(fun), para_list(p1, p2) {}
 bind(fun_type fun, const place_holder<1>& ph1, T2 p2) : f(fun), para_list(ph1, p2) {}
 bind(fun_type fun, T1 p1, const place_holder<2>& ph2) : f(fun), para_list(p1, ph2) {}
 bind(fun_type fun, const place_holder<1>& ph1, const place_holder<2>& ph2) : f(fun), para_list(ph1, ph2) {}

 RT operator()()
 {
 arg_item<T1, false> *arg1 = dynamic_cast<arg_item<T1, false>*>(para_list.get(1));
 arg_item<T2, false> *arg2 = dynamic_cast<arg_item<T2, false>*>(para_list.get(2));

 return f(arg1->value(), arg2->value());
 }

 RT operator()(T1 r1)
 {
 arg_item<T2, false> *arg2 = dynamic_cast<arg_item<T2, false>*>(para_list.get(2));

 return f(r1, arg2->value());
 }

 RT operator()(T2 r2)
 {
 arg_item<T1, false> *arg1 = dynamic_cast<arg_item<T1, false>*>(para_list.get(1));

 return f(arg1->value(), r2);
 }

 RT operator()(T1 r1, T2 r2)
 {
 return f(r1, r2);
 }
};

    现在如果你将上面测试代码中使用 bind<int, int, bool> add_fun(test, _1, true),而在调用时使用 add_fun(true)时程序就将直接崩溃，因为在对 operator()(T2 r2) 的调用中，取出第一个参数时有一个基类指针到子类指针的转换，转换的目标类型是 arg_item<int, false>，也就是如果要按这种方式调用的话，第一个参数在绑定时就不应该是占位符，而是用真实值进行的绑定，但现在第一个参数由于绑定时使用了占位符，所以实际上它的类型是 arg_item<int, true>，所以这个转换失败，指针 arg1 成为空指针，对它进行解引用调用 value() 成员必定导致程序崩溃。虽然这只有在运行时才会出问题，但总比运行时都能运行要好得多。至于如何让其通不过编译，限于篇幅关系，留再后续文章进行讨论。

    临了强调一下，本文中的实现是有缺陷的，比如原始函数的两个参数类型相同，则 bind 中只接受一个参数的 operator() 就有两个版本，所以如果要支持这种情况，需要对 bind 提供一个特化版本，里面只提供一个只接受一个参数的 operator() 函数，另外，本实现也不支持原始函数为成员函数的情况。

    最后，将完整的实现代码和测试代码贴在下面：

bind.h

#ifndef __common_test_bind_h__
#define __common_test_bind_h__

#include <vector>
#include <cassert>

namespace common_test
{
namespace bind
{

template<int index>
class place_holder
{
public:
 static const int place_index = index;
};

place_holder<1> _1;
place_holder<2> _2;

class arg_item_base
{
public:
 virtual ~arg_item_base() {}
};

template<typename T, bool isholder>
class arg_item;

template<typename T>
class arg_item<T, false> : public arg_item_base
{
 T val;

public:
 static const bool isholder = false;

 arg_item() {}
 arg_item(const T& v) : val(v){}

 T value() {return val;}
};

template<typename T>
class arg_item<T, true> : public arg_item_base
{
public:
 static const bool isholder = true;
};

template<typename T1, typename T2>
class arg_list
{
 std::vector<arg_item_base*> arg_container;

 arg_item<T1, true> ap1;
 arg_item<T1, false> a1;

 arg_item<T2, true> ap2;
 arg_item<T2, false> a2;

public:
 template<int index>
 struct arg_index_type_traits;

 template<>
 struct arg_index_type_traits<1>
 {
 typedef T1 value_type;
 };

 template<>
 struct arg_index_type_traits<2>
 {
 typedef T2 value_type;
 };

public:
 arg_list(T1 p1, T2 p2) : a1(p1), a2 (p2)
 {
 arg_container.push_back(&a1);
 arg_container.push_back(&a2);
 }
 arg_list(const place_holder<1>&, T2 p2) : a2(p2)
 {
 arg_container.push_back(&ap1);
 arg_container.push_back(&a2);
 }
 arg_list(T1 p1, const place_holder<2>&) : a1(p1)
 {
 arg_container.push_back(&a1);
 arg_container.push_back(&ap2);
 }
 arg_list(const place_holder<1>&, const place_holder<2>&)
 {
 arg_container.push_back(&ap1);
 arg_container.push_back(&ap2);
 }

 ~arg_list(){}

public:
 inline arg_item_base* get(int index)
 {
 return arg_container[index - 1];
 }

};

template<typename RT, typename T1, typename T2>
class bind
{
 typedef RT (*fun_type)(T1, T2);
 fun_type f;
 arg_list<T1, T2> para_list;

public:
 bind(fun_type fun, T1 p1, T2 p2) : f(fun), para_list(p1, p2) {}
 bind(fun_type fun, const place_holder<1>& ph1, T2 p2) : f(fun), para_list(ph1, p2) {}
 bind(fun_type fun, T1 p1, const place_holder<2>& ph2) : f(fun), para_list(p1, ph2) {}
 bind(fun_type fun, const place_holder<1>& ph1, const place_holder<2>& ph2) : f(fun), para_list(ph1, ph2) {}

 RT operator()()
 {
 arg_item<T1, false> *arg1 = dynamic_cast<arg_item<T1, false>*>(para_list.get(1));
 arg_item<T2, false> *arg2 = dynamic_cast<arg_item<T2, false>*>(para_list.get(2));

 return f(arg1->value(), arg2->value());
 }

 RT operator()(T1 r1)
 {
 arg_item<T2, false> *arg2 = dynamic_cast<arg_item<T2, false>*>(para_list.get(2));

 return f(r1, arg2->value());
 }

 RT operator()(T2 r2)
 {
 arg_item<T1, false> *arg1 = dynamic_cast<arg_item<T1, false>*>(para_list.get(1));

 return f(arg1->value(), r2);
 }

 RT operator()(T1 r1, T2 r2)
 {
 return f(r1, r2);
 }
};

}
}

#endif

main.cpp

#include "bind.h"
#include <iostream>

using namespace common_test::bind;

int test(int n, bool b)
{
 return b ? ++n : --n;
}

int main()
{
 bind<int, int, bool> add_fun(test, _1, true);
 std::cout << "add_fun(10) = " << add_fun(10) << std::endl;

 bind<int, int, bool> de_fun(test, _1, false);
 std::cout << "de_fun(10) = " << de_fun(10) << std::endl;

 bind<int, int, bool> u_fun(test, _1, _2);
 std::cout << "u_fun(10, true) = " << u_fun(10, true) << std::endl;
 std::cout << "u_fun(10, false) = " << u_fun(10, false) << std::endl;

 bind<int, int, bool> ua_fun(test, 10, true);
 std::cout << "ua_fun() = " << ua_fun() << std::endl;

 bind<int, int, bool> ud_fun(test, 10, false);
 std::cout << "ud_fun() = " << ud_fun() << std::endl;


 return 0;
}


转载于:https://my.oschina.net/zhcosin/blog/205426

weixin_34293246
关注
深度解析bind实现原理
weixin_55756683的博客
11-04 695
深度解析bind实现原理
【函数式】Monads模式初探——Monad概念
热门推荐
Jason Ding的专栏
03-05 1万+
单子单子（Monad）是一种将函子组合应用的方法。在计算机科学里，单子经常用来代表计算（computation）。单子能用来把与业务无关的通用程序行为抽象出来，比如有用来处理并行（Future）、异常（Option和Try等）、甚至副作用的单子。 单子的flatMap和unit操作作为构建数据类型的基本操作，可以实现很多复杂的高阶函数。单子的程序描述Monad定义了unit和flatMap两个函数
函数 bind 原理初探（一）
zhcosin的专栏
03-05 2201
对函数绑定的原理进行了简单实现。
bind原理图释
weixin_34077371的博客
04-29 276
bind原理图释 (原文:http://blog.think-async.com/2010/04/bind-illustrated.html) 本文解释了bind是如何工作的。为了清晰，我对图中的语法作了一些简化（例如，省略函数调用操作符的参数类型），并且简化了bind的实现. 1. bind可以用来将用户提供的需要一个参数的函数转...
javascript原生一步步实现bind分析
weixin_33795743的博客
11-01 357
bind 官方描述 bind() 函数会创建一个新函数（称为绑定函数），新函数与被调函数（绑定函数的目标函数）具有相同的函数体（在 ECMAScript 5 规范中内置的call属性）。当目标函数被调用时 this 值绑定到 bind() 的第一个参数，该参数不能被重写。绑定函数被调用时，bind() 也接受预设的参数提供给原函数。一个绑...
bind的原理和bind的实现
前端小白的逆袭
12-07 5063
一、bind的特性 传递的第一个参数做为调用它的函数的this指向（bind可传递若干参数）。 若第一个参数传递基础数据类型，则调用他的函数的this指向该基础数据类型的包装类实例化对象。 若第一个参数为null或undefined，则调用他的函数的this指向window。 bind的第二个之后的参数为调用它的函数的参数列表。 bind方法会返回一个新的方法，并且该方法满足柯里化，仍可以传递参数，但这个方法的this不可被call、apply、bind改变。 bind方法返回的新方法，如果使用new实例
关于vue.js v-bind 的一些理解和思考
10-19
一、`v-bind`初探 `v-bind`指令的基本用法是在HTML元素中，通过`:属性名="预期值"`的方式，将Vue实例的数据绑定到元素属性。例如，下面的代码将`data`对象中的`title`属性值绑定到`<p>`元素的`title`属性： ```html...
std::bind与函数对象的内存管理：深入探讨对象生命周期的管理
现代C++中，`std::bind`是实现函数对象绑定的重要工具，它允许我们将函数和参数绑定到一起，从而得到一个新的可调用实体。这在需要延迟函数调用或者固定某些函数参数的场景中尤其有用。函数对象，也称为仿函数，是...
typescript初探之函数(function)与泛型(generic)
hello，是翠花呀
12-05 1936
之前我们有简单了解了一下使用接口表示函数类型。接下来我们了解 typescript 中的函数和泛型。 函数 //声明式 function add(x, y) { return x + y; } // 函数表达式 let myAdd = function(x, y) { return x + y; }; JavaScript 声明方式有声明式和表达式，另外有具名函数和匿名函数： // ...
网络编程初探：使用Socket实现简单通信
在本章节中，我们将介绍Socket编程的基础知识，包括Socket编程的概念、通信原理以及常用的Socket函数。 ### 2.1 Socket编程介绍 Socket编程是一种基于网络的编程方式，它使用套接字（Socket）来实现网络之间的通信...
boost之bind的使用
huangyimo的专栏
08-08 689
1、bind的工作原理 bind 并不是一个单独的类或函数，而是非常庞大的家族，依据绑定的参数的个数和要绑定的调用对象的类型，总共有数十种不同的形式，编译器会根据具体的绑定代码制动确定要使用的正确的形式，bind的基本形式如下： template bind(F f); template bind(F f,A1 a1); namespace { boost::arg _1; boost
std::bind实现原理
u013679159的博客
09-22 937
(原文:http://blog.think-async.com/2010/04/bind-illustrated.html) https://blog.csdn.net/xiexievv/article/details/50517964 本文解释了bind 是如何工作的。为了清晰，我对图中的语法作了一些简化（例如，省略函数调用操作符的参数类型），并且简化了 bind 的实现. bind 可以用来将用户提供的需要一个参数的函数转换成不需要参数的函数对象。绑定的值（在这个例子中是123）存储在函数对象内并
bind、call实现原理
weixin_41643133的博客
09-08 271
释义 bind()方法主要就是将函数绑定到某个对象，bind()会创建一个函数，函数体内的this对象的值会被绑定到传入bind()中的第一个参数的值，剩下的参数以逗号分隔，与call的传参数一样 bind用法 var person = { name: '妖怪' } function other (age, sex) { console.log(this.name + '的年龄是' + age + ',性别：' + sex) } // 注意bind使用时必用在结尾用（）执行，注意与cal
bind的原理深度剖析
qq_42259940的博客
11-14 687
bind()方法创建一个新的函数，在bind()被调用时，这个新函数的this被bind的第一个参数指定，其余的参数将作为新函数的参数供调用时使用。 **语法：**function.bind(thisArg[,arg1[,arg2[, …]]]) 返回一个原函数的拷贝，并拥有指定的this值和初始参数。 bind 方法与 call / apply 最大的不同就是前者返回一个绑定上下文的函数，而后两...
JavaScript-bind实现原理
weixin_59554510的博客
08-25 438
大家好，今天给大家带来的是bind的实现原理，比前两个call，apply稍微有点点难，但是大家想要玩转js高级，那就当然是模仿各种的实现原理，对自己的js理解啥的提升挺快的，bind的话，想必大家知道：作用就是改变this指向，不调用函数没，这个跟前两个有些不一样下面我就带大家来写一下bind的实现原理：（在实现bind的原理之前我们先看一下原生的是啥样的然后我们去模仿一下）发现结果没有问题，其实js 的一些原理挺简单的，当我们学会写原理之后js高级的一些东西，就发现会幡然醒悟，奥原来是这样。...
bind的实现原理
weixin_30411239的博客
07-10 422
//作用域问题 var a = { b: function() { var func = function() { console.log(this.c); } func(); }, c: 'hello' } a.b(); // undefined 这里的this指向的是全局作用域 console.lo...
深度解析bind原理、使用场景及模拟实现
我本可以容忍阳光，如果我不曾见过太阳，然而阳光已使我荒凉，成为更新的荒凉。
07-20 907
更新：谢谢大家的支持，最近折腾了一个博客官网出来，方便大家系统阅读，后续会有更多内容和更多优化，https://muyiy.cn/------ 以下是正文 ------bind()bin...
bind 函数的实现原理
weixin_33895016的博客
07-04 785
最近在看《你不知道的JavaScript》系列，看到这个地方的时候，第一眼没对上，没有确认过的眼神，所以就带着疑惑，深入解析一下，做了一份学习总结。Function.prototype.bind引用 MDN：bind() 方法创建一个新的函数, 当被调用时，将其 this 关键字设置为提供的值，在调用新函数时，在任何提供之前提供一个给定的参数序列。语法： fun.bind(thisArg[, a...
javascript-bind实现原理
weixin_42736886的博客
03-13 1686
bind特点 1、保存this返回一个函数 2、可以传入参数 3、一个绑定函数也能使用new操作符创建对象：这种行为就像把函数当成构造器。提供的this值被忽略，同时调用时的参数被提供给模拟函数 // eg var obj ={ value: 1 } function bar(yeah, ok){ this.age = "18" ...
探究JavaScript中bind函数的实现原理
资源摘要信息:"在JavaScript编程中，bind() 方法是一个非常重要的函数，它被广泛用于改变函数的执行上下文（context），也就是函数调用时的this值。本文将深入研究bind() 方法的工作原理及其在实际编程中的应用。 1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值