#include <functional>

 

1 bind(引用内部函数, 实体对象的地址, 占位符); 

2 bind1st

3 function

 

1 auto 变量名 = bind(引用内部函数, 实体对象的地址, 占位符); 

 

 1 #include <iostream>
 2 #include <functional>
 3 using namespace std;
 4 
 5 //仿函数，创建一个函数指针，引用一个结构体内部或者一个类内部的public公有函数
 6 
 7 struct MyStruct
 8 {
 9     void add1(int a)
10     {
11         std::cout << a << std::endl;
12     }
13 
14     void add2(int a, int b)
15     {
16         std::cout << a + b << std::endl;
17     }
18 
19     void add3(int a, int b, int c)
20     {
21         std::cout << a + b + c << std::endl;
22     }
23 };
24 
25 void main()
26 {
27     MyStruct struct1;//创建一个结构体变量
28 
29     //auto自动变量，地址，函数指针
30     //对于参数要使用占位符 std::placeholders::_1
31     //auto 变量名 = bind(引用内部函数, 实体对象的地址, 占位符);
32     auto func = bind(&MyStruct::add1, &struct1, std::placeholders::_1);
33 
34     auto func2 = bind(&MyStruct::add2, &struct1, std::placeholders::_1, std::placeholders::_2);
35 
36     auto func3 = bind(&MyStruct::add3, &struct1, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
37 
38     func(100);//100
39 
40     func2(10, 20);//30
41 
42     func3(10, 20, 30);//60
43 
44     //创建一个函数指针，指向结构体内部的函数。由于结构体的数据是独有的，而函数是共享的，因此无法指向某个结构体变量的函数，只能指向结构体的函数
45     //函数通过调用，调用需要传递对象名
46     void(MyStruct::*p)(int) = &MyStruct::add1;//使用函数也可以解决，但是没有bind好用    
47     
48     system("pause");
49 }

 

2 bind1st

 

std::bind1st(std::greater<int>(), 3)

 

//bind1st绑定一个函数，greater也是函数，比大小

//作用：从头到尾，查找比3小的第一个元素

//用途，查找不及格的人

 

 1 #include <iostream>
 2 #include <vector>
 3 #include <algorithm>
 4 #include <functional>
 5 
 6 int main()
 7 {
 8     std::vector<int>myvector;
 9 
10     myvector.push_back(11);
11     myvector.push_back(2);
12     myvector.push_back(16);
13     myvector.push_back(1);
14     myvector.push_back(18);
15 
16     auto ib = myvector.begin();
17     auto ie = myvector.end();
18 
19     for (; ib != ie; ib++)
20     {
21         std::cout << *ib << std::endl;
22     }
23     std::cout << std::endl;
24 
25     auto ifind = find_if(myvector.begin(), myvector.end(), std::bind1st(std::greater<int>(), 3));//bind1st绑定一个函数，greater也是函数，比大小
26     //作用：从头到尾，查找比3小的第一个元素
27     //用途，查找不及格的人
28 
29     std::cout << *ifind << std::endl;
30 
31     return 0;
32 }

 

std::bind1st(std::greater<int>(), 3)

另外写一个函数实现

 

 1 #include <iostream>
 2 #include <vector>
 3 #include <algorithm>
 4 #include <functional>
 5 
 6 bool less3(int x)
 7 {
 8     return x < 3;
 9 }
10 
11 int main()
12 {
13     std::vector<int>myvector;
14 
15     myvector.push_back(11);
16     myvector.push_back(2);
17     myvector.push_back(16);
18     myvector.push_back(1);
19     myvector.push_back(18);
20 
21     auto ib = myvector.begin();
22     auto ie = myvector.end();
23 
24     for (; ib != ie; ib++)
25     {
26         std::cout << *ib << std::endl;
27     }
28     std::cout << std::endl;
29 
30     auto ifind = find_if(myvector.begin(), myvector.end(), less3);//bind1st绑定一个函数，greater也是函数，比大小
31     //作用：从头到尾，查找比3小的第一个元素
32     //用途，查找不及格的人
33 
34     std::cout << *ifind << std::endl;
35 
36     return 0;
37 }

 

3 std::function

 

std::function实现函数包装器

 

std::function实现函数包装器

//第一，设计执行接口，接口可以设计关卡（收费，插入if...else）、计数器

//第二，函数包装器依赖于函数模板，实现通用泛型

//第三，函数代码可以内嵌在另外一个函数，实现函数怀孕

//第四，函数包装器可以用于管理内嵌函数和外部函数调用

 

函数包装器管理内嵌函数

 

 1 #include <iostream>
 2 #include <functional>
 3 using namespace std;
 4 
 5 //函数包装器
 6 //第一，设计执行接口，接口可以设计关卡（收费，插入if...else）、计数器
 7 //第二，函数包装器依赖于函数模板，实现通用泛型
 8 //第三，函数代码可以内嵌在另外一个函数，实现函数怀孕
 9 //第四，函数包装器可以用于管理内嵌函数和外部函数调用
10 
11 //函数包装器，T是数据类型，F是函数
12 template <typename T, typename F>
13 T run(T v, F f)//第一个参数是数据，第二个参数是函数
14 {
15     static int count = 0;//计数器
16     count++;
17     std::cout << "一个参数的包装器 执行" << count << "次" << std::endl;
18     if (count > 1)//通过计数器，限定函数执行次数
19     {
20         T vx(0);
21         return vx;
22     }
23 
24     return f(v);//函数传入参数
25 }
26 
27 template <typename T, typename F>
28 T run(T v1, T v2, F f)//第一个参数是数据，第二个参数是数据，第三个参数是函数
29 {
30     return f(v1, v2);//函数传入参数
31 }
32 
33 void main()
34 {
35     double db = 12.9;
36     int num1 = 19;
37     int num2 = 29;
38 
39     //    <返回值类型(参数类型)>
40     //fun1是函数指针
41     std::function <double(double)>fun1 = [](double u)
42     {
43         return u * 2;
44     };
45 
46     std::function <double(double)>fun2 = [](double u)
47     {
48         return u*u;
49     };
50 
51     //    <返回值类型(参数类型, 参数类型)>
52     std::function <int(int, int)>fun3 = [](int u1, int u2)
53     {
54         return u1 + u2;
55     };
56 
57     std::cout << run(db, fun1) << std::endl;//25.8
58 
59     std::cout << run(db, fun2) << std::endl;
60 
61     std::cout << run(num1, num2, fun3) << std::endl;//48
62 
63     system("pause");
64 }

 

函数包装器管理外部函数

 

 1 #include <iostream>
 2 #include <functional>
 3 using namespace std;
 4 
 5 //函数包装器
 6 //第一，设计执行接口，接口可以设计关卡（收费，插入if...else）、计数器
 7 //第二，函数包装器依赖于函数模板，实现通用泛型
 8 //第三，函数代码可以内嵌在另外一个函数，实现函数怀孕
 9 //第四，函数包装器可以用于管理内嵌函数和外部函数调用
10 
11 //函数包装器，T是数据类型，F是函数
12 template <typename T, typename F>
13 T run(T v1, T v2, F f)//第一个参数是数据，第二个参数是数据，第三个参数是函数
14 {
15     return f(v1, v2);//函数传入参数
16 }
17 
18 int cheng(int a, int b)//外部函数，实现乘法
19 {
20     return a*b;
21 }
22 
23 void main()
24 {
25     double db = 12.9;
26     int num1 = 19;
27     int num2 = 29;
28 
29     //fun4是函数指针
30     //    <函数返回值类型(参数类型, 参数类型)>
31     std::function <int(int, int)>fun4 = cheng;
32 
33     std::cout << run(num1, num2, fun4) << std::endl;//551
34 
35     system("pause");
36 }

 

转载于:https://www.cnblogs.com/denggelin/p/5651456.html