std::function学习日记

/*
 * 定义：1、类模板 std::function 是 通用 多态函数 封装器。
 *      2、std::function的实例能存储、复制及调用 任何可调用（Callable）目标——函数、lambda表达式、bind表达式或其他函数对象，
 *      还有指向成员函数指针和指向数据成员指针。
 *      3、它也是对C++中现有的可调用实体的一种类型安全的包裹（相对来说，函数指针的调用不是类型安全的）
 * 操作：function<T>f f是用来存储可调用对象的空function，这些可调用对象的调用形式应该与函数类型T相同（即T使retType（args））
 */
/*
 * 定义：1、类模板 std::function 是 通用 多态函数 封装器。
 *      2、std::function的实例能存储、复制及调用 任何可调用（Callable）目标——函数、lambda表达式、bind表达式或其他函数对象，
 *      还有指向成员函数指针和指向数据成员指针。
 *      3、它也是对C++中现有的可调用实体的一种类型安全的包裹（相对来说，函数指针的调用不是类型安全的）
 * 操作：function<T>f f是用来存储可调用对象的空function，这些可调用对象的调用形式应该与函数类型T相同（即T使retType（args））
 */
#include <iostream>
#include <functional>
using namespace std;

struct Foo
{
    Foo(int num) : num_(num){}
    void print_add(int i) const {std::cout << num_ + i << '\n'; }
    int num_;
};

void print_num(int i)
{
    std::cout << i << '\n';
}

struct PrintNum
{
    void operator()(int i) const
    {
        std::cout << i << '\n';
    }
};

void g_Minus(int i, int j)
{
    std::cout << i - j << endl;
}

template<class T>
T template_Minus(T t1, T t2)
{
    return t1 - t2;
}

struct Minus_operator
{
    void operator()(int i1, int i2)
    {
        std::cout << i1 - i2 << endl;
    }
};

template<typename T>
struct Minus_operator_template
{
    void operator()(int i1, int i2)
    {
        std::cout << i1 - i2 << endl;
    }
};

class Math
{
public:
    static void Minus(int i1, int i2)
    {
        cout << i1 - i2 << endl;
    }
};

class Math_template
{
public:
    template<typename T>
    static void Minus(T i1, T i2)
    {
        cout << i1 - i2 << endl;
    }
};

class Math_normal
{
public:
    void Minus(int i1, int i2)
    {
        cout << i1 - i2 << endl;
    }
};

class Math_template_normal
{
public:
    template<typename T>
    void Minus(T i1, T i2)
    {
        cout << i1 - i2 << endl;
    }
};

int main()
{
    cout << "Hello World!" << endl;

    std::function<void(int)> f_display = print_num;                         //存储自由函数
    f_display(-9);

    std::function<void()> f_display_42 = [](){ print_num(42); };            //存储lambda表达式
    f_display_42();

    std::function<void()> f_display_311337 = std::bind(print_num, 311337);  //存储bind表达式
    f_display_311337();

    std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;   //存储成员函数
    const Foo foo(314159);
    f_add_display(foo, 1);
    f_add_display(314159, 1);   //???生成匿名对象

    std::function<int(Foo const&)> f_num = &Foo::num_;                      //存储成员访问器
    std::cout << "num_ : " << f_num(foo) << '\n';

    using std::placeholders::_1;    //占位符
    std::function<void(int)> f_add_display2 = std::bind(&Foo::print_add, foo, _1);  //存储成员函数和对象
    f_add_display2(2);

    std::function<void(int)> f_add_display3 = std::bind(&Foo::print_add, &foo, _1); //存储成员函数和对象指针
    f_add_display3(3);

    std::function<void(int)> f_display_obj = PrintNum();                    //存储函数对象（仿函数）
    f_display_obj(18);

    //---------------------------------------------------
    std::cout << "/-------------------------------------" << endl;

    std::function<void(int,int)> f_g_Minus = g_Minus;                       //存储普通函数
    f_g_Minus(6, 5);

    std::function<int(int,int)> f_template_Minus = template_Minus<int>;     //存储模板函数
    std::cout << f_template_Minus(9,5) << endl;

    auto lambda = [](int i1, int i2){ cout << i1 + i2 << endl; };           //存储lambda表达式
    function<void(int,int)> f_lambda = lambda;
    f_lambda(19, 1);

    function<void(int,int)> f_Minus_operator = Minus_operator();            //存储函数对象（仿函数）
    f_Minus_operator(6, 8);

    function<void(int,int)> f_Minus_operator_template = Minus_operator_template<int>();     //存储模板函数对象（仿函数）
    f_Minus_operator_template(9, 6);

    function<void(int,int)> f_Math = &Math::Minus;                          //存储类静态成员函数
    f_Math(15, 8);

    function<void(int,int)> f_Math_template = &Math_template::Minus<int>;   //存储类静态成员函数
    f_Math_template(15, 20);

    Math_normal m;
    function<void(int,int)> f_Math_normal_obj = bind(&Math_normal::Minus, &m, placeholders::_1, placeholders::_2);  //存储类成员方法，对象指针
    function<void(int,int)> f_Math_normal = bind(&Math_normal::Minus, m, placeholders::_1, placeholders::_2);  //存储类成员方法，对象
    f_Math_normal_obj(8, 9);
    f_Math_normal(8, 10);

    Math_template_normal m_template;
    function<void(int,int)> f_Math_obj = bind(&Math_template_normal::Minus<int>, &m_template, placeholders::_1, placeholders::_2);
    f_Math_obj(8, 11);

    return 0;
}