C++function,future,packaged_task
1.function和bind
这两个函数需要包含头文件#inlude
std::function是一种封装函数的工具或者说方法。std::function封装包普通函数、Lambda表达式、函数指针、以及其它函数对象等。std::function功能比函数指针更多，也更安全。
下面是function的使用示例：
#include
#include
#include
int func1(int& a,int b)
{
return a + b;
}
int main()
{
int a = 3;
int b = 1;
std::function f;
f = func1;
std::cout << f(a,b) << '\n';
return 0;
} 上面展示了function是如何包装函数的。除此之外它还可以和bind结合绑定参数，如下：
#include
#include
#include
int func1(int& a,int b)
{
return a + b;
}
int main()
{
int a = 3;
int b = 1;
//bind将a,b绑定到了func1里，因此f是int()而非(int(int&,int))
std::function f;
f = std::bind(func1, std::ref(a), b);
std::cout << f() << '\n';
return 0;
} bind相当于将参数提前绑定到函数里，此后调用无需参数。f可以理解成下面那个样子：
int func1(int& a,int b)
{
return a + b;
}
std::function f;
f = std::bind(func1, std::ref(a), b);
此时的f可以看成下面那样
int f()
{
int& a1=a;
int b1=b;
return a1+b1;
} 我们可以采取这种方式提前将函数参数传入，这种方式可以更方便的回调，如下面伪代码
int func1(int& a,int b) {}
int func2(int a,int b，int c) {}
void func(std::function f)
{
f();
}
std::function f1;
std::function f2;
f1 = std::bind(func1, std::ref(a), b);
f2 = std::bind(func1, a, b, c); 可以看出这种方式封装的函数作回调函数时无需传递参数，使得需要调用该回调函数的func无需考虑到多种情况设置参数。
2.async和future
使用这两个函数需要包含头文件#include
2.1 async和future的简单用法：
async会返回一个future类型的数据，future的作用是获得异步操作的结果，无需使用全局变量。先看看使用方法：
#include
#include
#include
#include
#include
int func1(int& a,int b)
{
return a + b;
}
void func2(int& a)
{
for (int i = 0; i < 10; i++)
{
a++;
usleep(500 * 1000);
}
}
int main()
{
int a = 3;
int b = 1;
std::future f1 = std::async(func2, std::ref(a));
f1.wait();
std::cout << a << '\n';
std::future f = std::async(func1, std::ref(a), b);
std::cout << f.get() << '\n';
return 0;
} 如上代码执行结果如下：
可以看到主函数第一部分并没有直接输出处于for循环时的a的中间值，而是等for循环结束才输出a的值。可以看出f1.wait()函数等到f1结束才进行后面代码。在主函数第二部分我们也发现我们可以直接输出func1的返回值。
2.2 async的参数：
从2.1的示例程序看async的参数比较好理解，后面跟随的时函数名和参数。但实际上我们看一下async此时的源码：
template
inline future<__async_result_of<_Fn, _Args...>>
async(_Fn&& __fn, _Args&&... __args)
{
return std::async(launch::async|launch::deferred,
std::forward<_Fn>(__fn),
std::forward<_Args>(__args)...);
} 可以看出它返回的async有一个参数“launch::async|launch::deferred”。实际上async在函数名和参数之前还有一个参数，该参数可选为std::launch::async或std::launch::deferred。
std::launch::async相当于开辟一个新的线程执行函数,如下代码：
#include
#include
#include
#include
#include
void func(int& a)
{
for (int i = 0; i < 10; i++)
{
a++;
std::cout << i << ' ';
}
}
int main()
{
int a = 3;
std::future f1 = std::async(std::launch::async, func, std::ref(a));
usleep(1000 * 1000);
std::cout << std::endl << "ok" << std::endl;
f1.wait();
return 0;
} 输出结果如下：
可以看出主线程在usleep过程中func已经执行完毕，因此可以猜测确实开启了一个新线程。我们再采取打出线程号的方式：
#include
#include
#include
#include
#include
void func(int& a)
{
for (int i = 0; i < 10; i++)
{
a++;
/*std::cout << i << ' ';*/
}
std::cout << std::this_thread::get_id() << '\n';
}
int main()
{
int a = 3;
int b = 1;
std::cout< f1 = std::async(std::launch::async,func, std::ref(a));
usleep(1000 * 1000);
//std::cout << std::endl << "ok" << std::endl;
f1.wait();
return 0;
} 结果如下：
可以发现线程号并不一样，到此可以判断是开启了一个新的线程。
第一个参数为std::launch::deferred时系统不会开启一个新的线程，而是会在调用f1.wait()或f1.get()时在本线程调用，代码如下：
#include
#include
#include
#include
#include
void func(int& a)
{
for (int i = 0; i < 10; i++)
{
a++;
/*std::cout << i << ' ';*/
}
std::cout << std::this_thread::get_id() << '\n';
}
int main()
{
int a = 3;
std::cout< f1 = std::async(std::launch::deferred,func, std::ref(a));
usleep(1000 * 1000);
//std::cout << std::endl << "ok" << std::endl;
f1.wait();
return 0;
} 结果如下：
可以看出此时并未开启新的线程。
如果不加参数那么等效于第一个参数为launch::async|launch::deferred，此时是否开辟新的线程决于系统的负载，我们无法控制。
3.packaged_task
pacakaged_task需要包含头文件#include
3.1 packaged_task用法：
packaged_task也是一种封装函数的方式，用法的伪代码如下：
void func(int& a) {}
int a(0);
std::packaged_task < void(int&) > p1(func);
p1(a);
std::packaged_task < void() > p2(std::bind(func, std::ref(a)));
p2();可以看出packaged_task可以封装函数,而且也支持提前传入参数。但是packaged_task封装的函数无法获得返回值，即便封装的是int或者其它有返回值类型函数。我们看一下packaged_task的operator()源码：
// Execution
void
operator()(_ArgTypes... __args)
{
__future_base::_State_base::_S_check(_M_state);
_M_state->_M_run(std::forward<_ArgTypes>(__args)...);
}无论封装的函数是什么类型，调用operator()时都是void类型，因此我们无法像普通函数和std::function一样直接得到返回值。那可能有人要问有了function为什么还要无法直接获得返回值的packaged_task ？实际上当使用pacakaged_task绑定一个函数时，为这个函数建立了一个future类型，我们可以拿到future类型来得到返回值，伪代码如下：
std::packaged_task < int() > p1(std::bind(func, std::ref(a)));
p1();
std::cout << p1.get_future().get();这样可以获得返回值。
从它可以返回一个future可以看出pacakaged_task封装的对象可以实现异步。
3.2 packaged_task在多线程：
我们先看下列代码：
#include
#include
#include
#include
#include
int func(int& a)
{
for (int i = 0; i < 10; i++)
{
a++;
/*std::cout << i << ' ';*/
}
std::cout << std::this_thread::get_id() << '\n';
return 0;
}
int main()
{
int a = 3;
std::cout< p1(std::bind(func, std::ref(a)));
auto f1 = p1.get_future();
std::thread t1(std::move(p1));
usleep(1000 * 1000);
f1.wait();
return 0;
} 结果如下：
可以发现p1可以用在其它线程，并且可以通过get_future得到返回值或者调用wait实现线程同步。
和std::function相比packaged_task可以在多线程中使用并且异步获得返回值。
与std::async相比我们发现async绑定函数(launch::async方式)后会立即执行，而此种方式绑定的函数我们可以自由选择执行的时机，使得我们使用时可以更灵活。