#include <functional>

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

2 bind1st

3 function

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

#include <iostream>
#include <functional>
using namespace std;

//仿函数，创建一个函数指针，引用一个结构体内部或者一个类内部的public公有函数

struct MyStruct
{
    void add1(int a)
    {
        std::cout << a << std::endl;
    }

    void add2(int a, int b)
    {
        std::cout << a + b << std::endl;
    }

    void add3(int a, int b, int c)
    {
        std::cout << a + b + c << std::endl;
    }
};

void main()
{
    MyStruct struct1;//创建一个结构体变量

    //auto自动变量，地址，函数指针
    //对于参数要使用占位符 std::placeholders::_1
    //auto 变量名 = bind(引用内部函数, 实体对象的地址, 占位符);
    auto func = bind(&MyStruct::add1, &struct1, std::placeholders::_1);

    auto func2 = bind(&MyStruct::add2, &struct1, std::placeholders::_1, std::placeholders::_2);

    auto func3 = bind(&MyStruct::add3, &struct1, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);

    func(100);//100

    func2(10, 20);//30

    func3(10, 20, 30);//60

    //创建一个函数指针，指向结构体内部的函数。由于结构体的数据是独有的，而函数是共享的，因此无法指向某个结构体变量的函数，只能指向结构体的函数
    //函数通过调用，调用需要传递对象名
    void(MyStruct::*p)(int) = &MyStruct::add1;//使用函数也可以解决，但是没有bind好用    
    
    system("pause");
}

2 bind1st

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

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

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

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

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

int main()
{
    std::vector<int>myvector;

    myvector.push_back(11);
    myvector.push_back(2);
    myvector.push_back(16);
    myvector.push_back(1);
    myvector.push_back(18);

    auto ib = myvector.begin();
    auto ie = myvector.end();

    for (; ib != ie; ib++)
    {
        std::cout << *ib << std::endl;
    }
    std::cout << std::endl;

    auto ifind = find_if(myvector.begin(), myvector.end(), std::bind1st(std::greater<int>(), 3));//bind1st绑定一个函数，greater也是函数，比大小
    //作用：从头到尾，查找比3小的第一个元素
    //用途，查找不及格的人

    std::cout << *ifind << std::endl;

    return 0;
}

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

另外写一个函数实现

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

bool less3(int x)
{
    return x < 3;
}

int main()
{
    std::vector<int>myvector;

    myvector.push_back(11);
    myvector.push_back(2);
    myvector.push_back(16);
    myvector.push_back(1);
    myvector.push_back(18);

    auto ib = myvector.begin();
    auto ie = myvector.end();

    for (; ib != ie; ib++)
    {
        std::cout << *ib << std::endl;
    }
    std::cout << std::endl;

    auto ifind = find_if(myvector.begin(), myvector.end(), less3);//bind1st绑定一个函数，greater也是函数，比大小
    //作用：从头到尾，查找比3小的第一个元素
    //用途，查找不及格的人

    std::cout << *ifind << std::endl;

    return 0;
}

3 std::function

std::function实现函数包装器

 

std::function实现函数包装器

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

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

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

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

函数包装器管理内嵌函数

#include <iostream>
#include <functional>
using namespace std;

//函数包装器
//第一，设计执行接口，接口可以设计关卡（收费，插入if...else）、计数器
//第二，函数包装器依赖于函数模板，实现通用泛型
//第三，函数代码可以内嵌在另外一个函数，实现函数怀孕
//第四，函数包装器可以用于管理内嵌函数和外部函数调用

//函数包装器，T是数据类型，F是函数
template <typename T, typename F>
T run(T v, F f)//第一个参数是数据，第二个参数是函数
{
    static int count = 0;//计数器
    count++;
    std::cout << "一个参数的包装器 执行" << count << "次" << std::endl;
    if (count > 1)//通过计数器，限定函数执行次数
    {
        T vx(0);
        return vx;
    }

    return f(v);//函数传入参数
}

template <typename T, typename F>
T run(T v1, T v2, F f)//第一个参数是数据，第二个参数是数据，第三个参数是函数
{
    return f(v1, v2);//函数传入参数
}

void main()
{
    double db = 12.9;
    int num1 = 19;
    int num2 = 29;

    //    <返回值类型(参数类型)>
    //fun1是函数指针
    std::function <double(double)>fun1 = [](double u)
    {
        return u * 2;
    };

    std::function <double(double)>fun2 = [](double u)
    {
        return u*u;
    };

    //    <返回值类型(参数类型, 参数类型)>
    std::function <int(int, int)>fun3 = [](int u1, int u2)
    {
        return u1 + u2;
    };

    std::cout << run(db, fun1) << std::endl;//25.8

    std::cout << run(db, fun2) << std::endl;

    std::cout << run(num1, num2, fun3) << std::endl;//48

    system("pause");
}

 

函数包装器管理外部函数

#include <iostream>
#include <functional>
using namespace std;

//函数包装器
//第一，设计执行接口，接口可以设计关卡（收费，插入if...else）、计数器
//第二，函数包装器依赖于函数模板，实现通用泛型
//第三，函数代码可以内嵌在另外一个函数，实现函数怀孕
//第四，函数包装器可以用于管理内嵌函数和外部函数调用

//函数包装器，T是数据类型，F是函数
template <typename T, typename F>
T run(T v1, T v2, F f)//第一个参数是数据，第二个参数是数据，第三个参数是函数
{
    return f(v1, v2);//函数传入参数
}

int cheng(int a, int b)//外部函数，实现乘法
{
    return a*b;
}

void main()
{
    double db = 12.9;
    int num1 = 19;
    int num2 = 29;

    //fun4是函数指针
    //    <函数返回值类型(参数类型, 参数类型)>
    std::function <int(int, int)>fun4 = cheng;

    std::cout << run(num1, num2, fun4) << std::endl;//551

    system("pause");
}