（P27-P32）可调用对象、可调用对象包装器、可调用对象绑定器

• • 1.可调用对象

在 C++ 中存在 “可调用对象” 这么一个概念。准确来说，可调用对象有如下几种定义：

• （1）是一个函数指针

int print(int a, double b)
{
    cout << a << b << endl;
    return 0;
}
// 定义函数指针
int (*func)(int, double) = &print;
using funcptr = void (*)(int, double) ;

• （2）是一个具有operator()成员函数的类对象（仿函数）
  是一个具有operator()成员函数的类对象（仿函数）
  和函数的调用方式一样

#include 
#include 
#include 
using namespace std;

struct Test
{
    // ()操作符重载
    void operator()(string msg)
    {
        cout << "msg: " << msg << endl;
    }
};

int main(void)
{
    Test t;
    t("我是要成为海贼王的男人!!!");	// 仿函数
    return 0;
}

• （3）是一个可被转换为函数指针的类对象

#include 
#include 
#include 
using namespace std;

using func_ptr = void(*)(int, string);
struct Test
{
    static void print(int a, string b)
    {
        cout << "name: " << b << ", age: " << a << endl;
    }

    // 将类对象转换为函数指针
    operator func_ptr()
    {
        return print;
    }
};

int main(void)
{
    Test t;
    // 对象转换为函数指针, 并调用
    t(19, "Monkey D. Luffy");

    return 0;
}

• （4）是一个类成员函数指针或者类成员指针

#include 
#include 
#include 
using namespace std;

struct Test
{
    void print(int a, string b)
    {
        cout << "name: " << b << ", age: " << a << endl;
    }
    int m_num;
};

int main(void)
{
    // 定义类成员函数指针指向类成员函数
    void (Test::*func_ptr)(int, string) = &Test::print;
    // 类成员指针指向类成员变量
    int Test::*obj_ptr = &Test::m_num;

    Test t;
    // 通过类成员函数指针调用类成员函数
    (t.*func_ptr)(19, "Monkey D. Luffy");
    // 通过类成员指针初始化类成员变量
    t.*obj_ptr = 1;
    cout << "number is: " << t.m_num << endl;

    return 0;
}

• 测试：
  
  在上面的例子中满足条件的这些可调用对象对应的类型被统称为可调用类型。
• C++ 中的可调用类型虽然具有比较统一的操作形式，但定义方式五花八门，这样在我们试图使用统一的方式保存，或者传递一个可调用对象时会十分繁琐。
• 现在，C++11通过提供std::function 和 std::bind统一了可调用对象的各种操作。

#include 
#include 
using namespace std;

int add(int a, int b)
{
    cout << a << " + " << b << " = " << a + b << endl;
    return a + b;
}

class T1
{
public:
    static int sub(int a, int b)
    {
        cout << a << " - " << b << " = " << a - b << endl;
        return a - b;
    }
};

class T2
{
public:
    int operator()(int a, int b)
    {
        cout << a << " * " << b << " = " << a * b << endl;
        return a * b;
    }
    void testfunc(int a, string b)
    {
        cout << " a= " << a << " b= " << b << endl;
    }
};

int main(void)
{
    // 绑定一个普通函数
    function f1 = add;
    // 绑定以静态类成员函数
    function f2 = T1::sub;
    // 绑定一个仿函数
    T2 t;
    function f3 = t;

    //绑定类中的一个成员函数
    T2 t2;
    std::function f4 = [&t2](int a, string b) { return t2.testfunc(a, b); };

    // 函数调用
    f1(9, 3);
    f2(9, 3);
    f3(9, 3);
    f4(1, "test");

    return 0;
}

P30

• 参考：可调用对象包装器、绑定器，如何将成员函数赋值给使用std::function定义的成员变量？