C++11 std::function函数包装器

【1】std::function简介

std::function是一个函数包装器模板，最早来自boost库，对应其boost::function函数包装器。

一个std::function类型对象实例可包装以下可调用元素类型等等：

（1）函数

（2）函数指针

（3）类成员函数指针

（4）任意类型的函数对象（例如：定义了operator()操作符重载的类型）。

std::function对象可被拷贝和转移，并且可以使用指定的调用特征来直接调用目标元素。

当std::function对象未包裹任何实际的可调用元素，调用该std::function对象将抛出std::bad_function_call异常。

【2】std::funciton使用

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

int subtract(int m, int n)
{
    return (m - n);
}

template <class T>
T g_sub(T m, T n)
{
    return (m - n);
}

auto g_Lambda = [](int m, int n)
{
    return (m - n);
}; // 注意：匿名函数此处有分号

struct Sub
{
    int operator()(int m, int n)
    {
        return (m - n);
    }
};

template <class T>
struct SubTemp
{
    T operator()(T m, T n)
    {
        return (m - n);
    }
};

class SubOper
{
public:
    static int st_sub(int m, int n)
    {
        return (m - n);
    }

    template <class T>
    static T temp_sub(T m, T n)
    {
        return (m - n);
    }

    double result(double m, double n)
    {
        return (m - n);
    }

    double const_result(double m, double n) const
    {
        return (m - n);
    }
};

int main()
{
    // 旧式写法
    typedef int (*pFunc) (int, int);
    pFunc oldFunc = subtract;
    cout << "Test old style :: " << (*oldFunc)(9, 10) << endl; // -1

    // [0] 包装函数指针对象
    std::function<int(int, int)> from_pFunc = oldFunc;
    cout << "Test0 :: " << from_pFunc(10, 10) << endl; // 0

    // [1]包装普通函数
    std::function<int(int, int)> newFunc = subtract;
    cout << "Test1 :: " << newFunc(11, 10) << endl;   // 1

    // [2]包装模板函数
    std::function<int(int, int)> tempFunc = g_sub<int>;
    cout << "Test2 :: " << tempFunc(12, 10) << endl;   // 2

    // [3]包装Lambda函数
    std::function<int(int, int)> lambdaFunc = g_Lambda;
    cout << "Test3 :: " << lambdaFunc(13, 10) << endl;   // 3

    // [4]包装仿函数
    std::function<int(int, int)> objFunc = Sub();
    cout << "Test4 :: " << objFunc(14, 10) << endl;     // 4

    // [5]包装模板函数对象
    std::function<int(int, int)> tempFuncObj = SubTemp<int>();
    cout << "Test5 :: " << tempFuncObj(15, 10) << endl;     // 5

    // [6] 类静态函数
    std::function<int(int, int)> stFunc = &SubOper::st_sub;
    cout << "Test6 :: " << stFunc(16, 10) << endl;   // 6

    // [7] 类静态模板函数
    std::function<int(int, int)> tempSTFunc = &SubOper::temp_sub<int>;
    cout << "Test7 :: " << tempSTFunc(17, 10) << endl;  // 7

    // [8] 类普通函数（普通函数绑定需要依赖类对象）
    SubOper subOperObject;

    // [8.1] 使用bind，将类对象地址绑定上
    std::function<double(double, double)> resultFunc = std::bind(&SubOper::result, &subOperObject, placeholders::_1, placeholders::_2);
    cout << "Test8.1 :: " << resultFunc(18.2, 10.1) << endl;   // 8.1

    // [8.2] 不使用bind
    std::function<double(SubOper &, double, double)> resultFunc2 = &SubOper::result;
    cout << "Test8.2 :: " << resultFunc2(subOperObject, 18.3, 10.1) << endl;   // 8.2

    // [8.3] const
    std::function<double(SubOper &, double, double)> const_resultFunc2 = &SubOper::const_result;
    cout << "Test8.3 :: " << const_resultFunc2(subOperObject, 18.4, 10.1) << endl;   // 8.3

    // [8.4] 常量对象
    const SubOper subOperConst;
    std::function<double(const SubOper &, double, double)> const_Func2 = &SubOper::const_result;
    cout << "Test8.4 :: " << const_Func2(subOperConst, 18.5, 10.1) << endl;   // 8.4

    // [9] 应用示例（为了解耦）
    class TestA
    {
    public:
        bool destoryByName(const std::string& name)
        {
            return doDestoryByName(name);
        }

    public:
        std::function<bool(const std::string&)> destory_handler;

    private:
        bool doDestoryByName(std::string name)
        {
            return destory_handler(name);
        }
    };

    class TestB
    {
    public:
        bool destory(const std::string& name) 
        {
            cout << "Test9 :: Call TestB destory | name : " << name << endl;
            return true;
        };
    };

    TestB objB;
    TestA objA;
    objA.destory_handler = [&](const std::string & name)->bool {
        // 摧毁操作
        return objB.destory(name);
    };
    objB.destory("kaizen");

    // [10] 为空时运行时异常
    std::function<int(int, int)> dealWithFunc;

    try
    {
        if (nullptr == dealWithFunc)
        {
            throw runtime_error("std::bad_function_call");   //抛出异常
        }
        else
        {
            dealWithFunc(100, 10);
        }
    }
    catch (exception e)
    {
        cout << "Test10 :: " << e.what() << endl;   // 捕获异常，然后程序结束
    }

    system("pause");
}

/* rusult
Test old style :: -1
Test0 :: 0
Test1 :: 1
Test2 :: 2
Test3 :: 3
Test4 :: 4
Test5 :: 5
Test6 :: 6
Test7 :: 7
Test8.1 :: 8.1
Test8.2 :: 8.2
Test8.3 :: 8.3
Test8.4 :: 8.4
Test9 :: Call TestB destory | name : kaizen
Test10 :: std::bad_function_call
请按任意键继续. . .
*/

good good study, day day up.

顺序 选择 循环 总结