有意与无意之间

对于一个对象或表达式，如果可以对其使用运算符，则称它为可调用的。

包含如下：

普通函数

int int_add(const int a, const int b) {
    return a + b;
}

函数指针

// 定义一个接受两个int参数 返回int的函数指针
typedef int(*compute)(int, int);

int min(int x, int y) { return x <= y ? x : y; }
int max(int x, int y) { return x >= y ？ x : y; }

int compute_x_y(int x, int y, compute fc) { return fc(x, y); }

int main(void) {
    int x =3, int y = 5;

    std::cout << "min:" << compute_x_y(x, y, min) << std::endl; // 3
    std::cout << "max:“ << compute_x_y(x, y, max) << std::endl; // 5

    // 无捕获的lambda表达式可以转换为相同类型的函数指针
    auto sum = [](int x, int y) { return x+y; }
    std::cout << "sum:" << compute_x_y(x, y, sum) << std::endl; // 8
}

return 0;

类成员函数、类静态函数、防函数

class some {
public:
   // 仿函数
   int operator()(int a, int b) {
      return a + b;
   }

   // 类成员函数
   int add_a(int a, int b) {
       return a + b;
   }    

   // 类静态函数
   static int add_b(int a, int b) {
       return a + b;
   }
}

lambda表达式

auto add = [](int a, int b)->int { return a + b; }

std::funtion

#include  <functional>

std::function<int(int, int)> Add()

其他函数实体转换为std::function

std::functiion 兼容所有具有相同参数类型的函数实体, 包括带捕获的lamda表达式，类的成员函数等。

#include <iostream>
#include <functional>

// std::function
std::function<int(int, int)> SumFunction;

// 普通函数
int func_sum(int a, int b)
{
    return a + b;
}

class Calcu
{
public:
    int base = 20;
    // 类的成员方法，参数包含this指针
    int class_func_sum(const int a, const int b) const { return this->base + a + b; };
    // 类的静态成员方法，不包含this指针
    static int class_static_func_sum(const int a, const int b) { return a + b; };
};

// 仿函数
class ImitateAdd
{
public:
    int operator()(const int a, const int b) const { return a + b; };
};

// lambda函数
auto lambda_func_sum = [](int a, int b) -> int { return a + b; };

// 函数指针
int (*func_pointer)(int, int);

int main(void) 
{
    int x = 2; 
    int y = 5;

    // 普通函数
    SumFunction = func_sum;
    int sum = SumFunction(x, y);
    std::cout << "func_sum：" << sum << std::endl;

    // 类成员函数
    Calcu obj;
    SumFunction = std::bind(&Calcu::class_func_sum, obj, 
        std::placeholders::_1, std::placeholders::_2); // 绑定this对象
    sum = SumFunction(x, y);
    std::cout << "Calcu::class_func_sum：" << sum << std::endl;

    // 类静态函数
    SumFunction = Calcu::class_static_func_sum;
    sum = SumFunction(x, y);
    std::cout << "Calcu::class_static_func_sum：" << sum << std::endl;

    // lambda函数
    SumFunction = lambda_func_sum;
    sum = SumFunction(x, y);
    std::cout << "lambda_func_sum：" << sum << std::endl;

    // 带捕获的lambda函数
    int base = 10;
    auto lambda_func_with_capture_sum = [&base](int x, int y)->int { return x + y + base; };
    SumFunction = lambda_func_with_capture_sum;
    sum = SumFunction(x, y);
    std::cout << "lambda_func_with_capture_sum：" << sum << std::endl;

    // 仿函数
    ImitateAdd imitate;
    SumFunction = imitate;
    sum = SumFunction(x, y);
    std::cout << "imitate func：" << sum << std::endl;

    // 函数指针
    func_pointer = func_sum;
    SumFunction = func_pointer;
    sum = SumFunction(x, y);
    std::cout << "function pointer：" << sum << std::endl;

    getchar();
    return 0;
}

std::bind通用的函数适配器

见上面的代码