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);
    };
    objA.destoryByName("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;   // 捕获异常，然后程序结束
    }
    
    // [11] 作为形参类型使用
    class Print
    {
    public:
        void doPrint(std::string content)
        {
            cout << "Test11 :: Call Print Class doPrint : " << content << endl;
        }
    };

    class Person
    {
    public:
        Person(std::string name = {}) : m_name(name)
        { }

        void show(std::function<void(std::string)> printFunc)
        {
            printFunc(m_name);
        }
    private:
        std::string m_name;
    };

    // error
    Person oObj1{ "hello" };
    //p1.show(&Print::doPrint); // 无法将参数 1 从“void (__cdecl main::Print::* )(std::string)”转换为“std::function<void (std::string)>”
    
    // 方式一：
    std::function<void(std::string)> printFunc1 = [](std::string str) {
        Print{}.doPrint(str);
    };
    Person{"C++"}.show(printFunc1);

    // 方式二：
    Print oPrint;
    std::function<void(std::string)> printFunc2 = std::bind(&Print::doPrint, &oPrint, placeholders::_1);
    Person{"Python"}.show(printFunc2);

    system("pause");
}

/* result
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
Test11 :: Call Print Class doPrint : C++
Test11 :: Call Print Class doPrint : Python
请按任意键继续. . .
*/