笔记 关于std::function 和 函数对象

1： 函数对象

如果一个类将()运算符重载为成员函数，这个类就称为函数对象类，这个类的对象就是函数对象。函数对象是一个对象，但是使用的形式看起来像函数调用，实际上也执行了函数调用，因而得名。

通俗一点就是 运算符重载， 只不过 重载的 运算符是（） 。和别的 运算符号 重载 调用 一样。 支持重载 和缺省

使用 方法：

                 test t；

                 cout<<t(10，20)<<endl;

2: std::function

 function是一组函数对象包装类的模板，实现了一个泛型的回调机制。function与函数指针比较相似，优点在于它允许用户在目标的实现上拥有更大的弹性，即目标既可以是普通函数，也可以是函数对象和类的成员函数，而且可以给函数添加状态。

声明一个function时，需要给出所包装的函数对象的返回值类型和各个参数的类型。比如，声明一个function，它返回一个bool类型并接受一个int类型和一个float类型的参数，可以像下面这样：

function<bool (int, float)> f;

个人 认为 和map  一起使用 可以达到对 函数进行包装的效果: 相当于 接口，更简洁，方便

• 函数模板说明

       以cplusplus.com中描述的原型说明：

       基于Fn参数返回一个函数对象，并且以Args参数绑定为函数对象的参数。每个参数要么绑定一个参数值，要么绑定为一个std::placeholders。如果参数绑定成一个值，那么返回的函数对象将总使用绑定的参数值做为调用参数，即调用传入参数将不起作用；如果参数绑定为std::placeholders，那么返回的函数对象在被调用时需要传入实时参数，参数填充的位置即由placeholder指定的序号。

       bind函数返回的函数对象类型和Fn一致，除非用户在Ret参数中指定了返回类型。需要注意的是，Ret参数只是一个模板参数，它并不能由传入该函数的参数进行隐式推导。

• 模板参数说明

       以cplusplus.com中描述的原型说明：

       Fn    :  函数对象、普通函数指针或类成员函数指针。

       Args : 用于绑定的参数列表。其中每个参数要么是参数值要么是一个placeholder

std::bind详解

---

• 绑定普通函数

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

int g_Minus(int i, int j)
{
    return i - j;
}

int main()
{
    function<int(int, int)> f1 = bind(g_Minus, 1, 2);
    function<int()>         f2 = bind(g_Minus, 1, 2);                   // 绑定参数返回的函数对象实际等同这种形式
    function<int(int, int)> f3 = bind(g_Minus, placeholders::_1, placeholders::_2);
    function<int(int)>      f4 = bind(g_Minus, 1, placeholders::_1);    // 绑定第一个参数
    function<int(int)>      f5 = bind(g_Minus, placeholders::_1, 1);    // 绑定第二个参数

    cout << f1(3, 2) << endl;                                           // -1，实际传入参数将不起作用
    cout << f2()     << endl;                                           // -1
    cout << f3(3, 2) << endl;                                           // 1
    cout << f4(3)    << endl;                                           // -2
    cout << f5(3)    << endl;                                           // 2

    return 1;
}

• 绑定模板函数

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

template <class T>
T g_Minus(T i, T j)
{
    return i - j;
}

int main()
{
    function<int(int, int)> f1 = bind(g_Minus<int>, 1, 2);
    function<int()>         f2 = bind(g_Minus<int>, 1, 2);                  // 绑定参数返回的函数对象实际等同这种形式
    function<int(int, int)> f3 = bind(g_Minus<int>, placeholders::_1, placeholders::_2);
    function<int(int)>      f4 = bind(g_Minus<int>, 1, placeholders::_1);   // 绑定第一个参数
    function<int(int)>      f5 = bind(g_Minus<int>, placeholders::_1, 1);   // 绑定第二个参数

    cout << f1(3, 2) << endl;                                               // -1，实际传入参数将不起作用
    cout << f2()     << endl;                                               // -1
    cout << f3(3, 2) << endl;                                               // 1
    cout << f4(3)    << endl;                                               // -2
    cout << f5(3)    << endl;                                               // 2

    return 1;
}

• 绑定lambda表达式

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

int main()
{
    function<int(int, int)> f = bind([](int i, int j){ return i - j; }, placeholders::_1, placeholders::_2);
    cout << f(2, 3) << endl;                                            // -1
    return 1;
}

• 绑定函数对象

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

struct Minus
{
    int operator() (int i, int j)
    {
        return i - j;
    }
};

int main()
{
    function<int(int, int)> f = bind(Minus(), placeholders::_1, placeholders::_2);
    cout << f(2, 3) << endl;                                            // -1
    return 1;
}

• 绑定类静态成员函数

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

class Math
{
public:
    static int Minus(int i, int j)
    {
        return i - j;
    }
};

int main()
{
    function<int(int, int)> f = bind(&Math::Minus, placeholders::_1, placeholders::_2);
    cout << f(2, 3) << endl;                                            // -1
    return 1;
}

• 绑定类对象成员函数

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

class Math
{
public:
    int Minus(int i, int j)
    {
        return i - j;
    }
};

int main()
{
    Math m;
    function<int(int, int)> f = bind(&Math::Minus, &m, placeholders::_1, placeholders::_2);
    cout << f(2, 3) << endl;                                            // -1
    return 1;
}

• 返回值的类型转换

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

class Math
{
public:
    int Minus(int i, int j)
    {
        return i - j;
    }
};

struct Result
{
    int m_Result;

    Result() : m_Result(0) {}
    Result(int result) : m_Result(result) {}
};

int main()
{
    Math m;
    auto   f = bind<Result>(&Math::Minus, &m, placeholders::_1, placeholders::_2);
    Result r = f(2, 3);
    cout << r.m_Result << endl;                                         // -1
    return 1;
}