函数指针，function，bind, lambda

函数指针，

sd::function<type0 (type1, type2...)> functionObject, 

std::bind()

1. 函数指针是类型不安全的，为什么？

#include<stdio.h>
int max(int x,int y){return (x>y? x:y);}
int main()
{
    int (*ptr)(int, int);
    int a, b, c;
    ptr = max;
    scanf("%d%d", &a, &b);
    c = (*ptr)(a,b);
    printf("a=%d, b=%d, max=%d", a, b, c);
    return 0;
}

C语言的函数指针就是一个地址变量，在赋值和调用的时候没有任何类型检查。

任何一种函数指针都可以转型为其他类型的函数指针， 当转型回来时， 与原函数指针相同。

必须由程序员自己记住究竟是什么类型。

转型错了，cast完蛋。

这就是类型不安全的。

函数指针无法提前在编译器给出错误提示。这个是于

2. std::function

将一个函数放入一个函数对象中

#include < functional>
 
std::function< size_t(const char*)> print_func;
 
/// normal function -> std::function object
size_t CPrint(const char*) { ... }
print_func = CPrint;
print_func("hello world"):

// 以下效果相同
//====================
/// functor -> std::function object
class CxxPrint
{
public:
    size_t operator()(const char*) { ... }
};
CxxPrint p;
print_func = p;
print_func("hello world");

function<float (int x, int y)> f;        // 构造一个函数对象，它能表示的是一个返回值为float，两个参数为int，int的函数

function的参数类型会进行类型检查，保证类型安全。

3. std::bind

将变量或值绑定到函数参数中，对于预先绑定的参数，是pass-by-value的

#include < functional>
 
int Func(int x, int y);
auto bf1 = std::bind(Func, 10, std::placeholders::_1);
bf1(20); ///< same as Func(10, 20)

std::bind绑定后，可以赋值给auto变量，也可以给function对象。

auto自动类型定义。

A a;
auto bf2 = std::bind(&A::Func, a, std::placeholders::_1, std::placeholders::_2);
bf2(10, 20); ///< same as a.Func(10, 20)
 
std::function< int(int)> bf3 = std::bind(&A::Func, a, std::placeholders::_1, 100);
bf3(10); ///< same as a.Func(10, 100)

1. 对于不事先绑定的参数，需要传std::placeholders进去，从_1开始，依次递增。placeholder是pass-by-reference的

2. bind的返回值是可调用实体，可以直接赋给std::function对象

3. bind能保证类型安全，但对于绑定变量的内容，需要程序员保证有效性

4. lambda

用于实现一个匿名函数，最大的用途就是callback回调函数。

实例1：

vector< int> vec;
/// 1. simple lambda
auto it = std::find_if(vec.begin(), vec.end(), [](int i) { return i > 50; });

其效果等同于一个函数对象。

可以有返回值，如果capture上下文环境，可以使用外部的局部变量，或类的成员变量

/// 2. lambda expr: capture of local variable
{
    int min_val = 10;
    int max_val = 1000;
 
    auto it = std::find_if(vec.begin(), vec.end(), [=](int i) {
        return i > min_val && i < max_val; 
        });
}

[=], [&], 

=表示capture的变量pass-by-value, 第二个小拿出中&表示capture的变量pass-by-reference

在使用function时，参数多的时候,bind要传入很多的std::placeholders，而且看着没有lambda表达式直观，所以通常建议优先考虑使用lambda表达式

参考学习：

http://www.wuzesheng.com/?p=2032