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.

順序 選擇 循環 總結