C++ Task 的实现（lambda 是个好东西）
来源：互联网 发布：宁波二手房交易数据 编辑：程序博客网 时间：2024/06/11 07:37
2017/12/04 更新：
- 添加了对类成员函数的支持
本文目的在于实现一个简单易用的 task 类。它的目的在于将将要执行的动作和上下文相关信息（如参数）保存起来，然后在想要执行的时候，发起这个动作。
完成品的实例如下：
struct A{ int b;};task t([](A a, A b, int c)->void{ a.a += b.b+c;}, A(233), A(A_v), 4);t();那么这个task 的应用场景在哪里呢？
emmm……举个例子。
在socket 的编程中，我们需要一个线程来处理接收到的buffer 信息。
然而，每个socket 开一个线程太昂贵了。
所以，我们可以开固定个线程，然后把需要处理的信息放进task里，再把task 丢进任务列表里面就行了。
Lambda 函数的本质
C++ 11 开始支持匿名函数，也就是lambda 语法。
一个典型的lambda 例子如下：
auto func = [this](int a) -> void { //todo something};lambda 函数和一般函数的区别在于，它多了个捕获列表，也就是[] 括起来的那些内容。捕获类型又分为按值捕获和按引用捕获。
那么，不妨思考一下，Lambda 函数的本质是什么。
假如你是编译期厂商，你拿到了C++ 委员会发布的C++11 标准，老板要求你支持lambda 函数的语法，你会怎么去实现呢。
emmm…………我提一下自己的想法。
在我看来，一个Lambda 函数，在编译的时候，编译期会检测它捕获的上下文相关信息，然后生成一个匿名结构体。这个结构体有一个 operator() 函数，包含有捕获的上下文变量信息。
那还是举个例子吧：
int a, b;auto func = [a, &b](int c)->int{ b += a + c; return b; };编译期看到上面的这些信息之后，就生成了下面这个结构体：
struct lambda_abcd{ lambda_abcd(int p1, int& p2) : p1(p1), p2(p2) {} int operator() (int c) { p2 += p1 + c; return p2; } int p1, &p2;};Lambda 函数最宝贵的特性，在于它能够由编译器自动生成我们需要的结构体类。
不妨思考一下，Lambda 函数的sizeof 到底是多少？捕获一个变量和捕获两个变量是一样的吗？可以试着验证一下。
task 类的需求
前面铺垫了一下lambda 函数的特性，因为它是实现task 关键的技术。
下面说一下设计task 的思想。
我的目的是，一个简单易用的task 类，它除了能够保存参数的信息，将其延后调用之外，尽量看起来和正常的函数行为是一样的。
那我们就可以用lambda 函数，将参数的信息保存起来了。
首先，先设计一个接口，task 的执行单元：
struct task_unit{ virtual ~task_unit() {} virtual void operator() () {}};它主要是定义了 operator () 操作符，使得它像函数一样产生作用。
（* 个人喜欢，可能do 或者work 的函数命名也是可以的）
接下来我们设计一个模板类，让它能够适配不同的lambda 函数。
template<class Func>struct task_unit_impl : public task_unit{ task_unit_impl(Func in_func) : m_func(in_func) {} virtual void operator() () { m_func(); }private: Func m_func;};当我们写这个的时候，应该时刻谨记着，Func 是能够接受任何可以调用 operator() 操作符的类型。
可以是函数指针，重载了operator() 的结构体，lambda 函数等。
而且，在构造函数中，m_func是传值实例化的。明白这点的话，就要清楚地知道，当你写代码的时候，它的代价是多少。
现在我们终于可以掏出一个面向客户的task 类了。
emm，先简单设计一下接口：
class task{public: template<class Func, class .... Args> task(Func func,Args&& ... args) {} void reset() // todo void operator () () { (*m_task_unit)(); }private: task_unit* m_task_unit;};到达这一步之后，核心就是如何实例化一个合适的m_task_unit ，让它可以胜任保存 函数体和参数的作用。
不过在此之前，我希望先解释一下可变参数和模板的推导规则。
注意到，task 的构造函数接受一个函数体（我称呼它为函数体，实际上它可以是任何接受operator() 操作符调用的类型），和可变参数。函数体是按值传递，而可变参数是右值引用的方式。
实际上，右值引用是可变参数的通用表达形式。
C++ 的模板推导规则中，符合以下条例：
- 左值 + && 变成左值引用
- 右值 + && 变成右值
（更多可查询【1】【2】），也就是说，不管传递的参数是什么，最后要么是左值引用（也就是一般的引用类型， &），要么是右值引用（&&）。
当我们传递参数的时候，有三种情况：
- 按值传参
- 按左值引用传参
- 按右值引用传参
由于使用可变参数模板，按值传参是无法实现的（实际上我们也可以选择按值传参，但是这样就没有办法按引用传参了，也许可以使用一些小技巧，但是这会违背我们一开始设计的初衷）。
万幸的是，按右值传参可以实现按值传参的效果！真棒！
解决了这个问题之后，我们继续思考，如何利用Lambda 函数来捕获参数信息呢？
由于使用了可变参数模板，Lambda 函数捕获的时候，要么就按值捕获，要么就按引用捕获。这并不是我们想要的。
emmm，似乎遇到了一点麻烦，不过还不碍事。
我们可以通过设计一个模板类，它可以把引用类型的参数保存起来，然后让Lambda 函数按值去捕获它。
template<class T> struct parameter_packer { }; template<class T> struct parameter_packer<T&> { parameter_packer(T& value) : param(value) {} T& param; }; template<class T> struct parameter_packer<T&&> { parameter_packer(T&& value) : param( move(value) ) {} parameter_packer(const parameter_packer& other) : param(move(other.param) ){} T&& param; };这个模板类它会完美地将引用类型保存起来。
template<class T> struct parameter_packer<T&&>这个版本为什么会额外需要一个copy constructor 呢。
因为它有一个右值引用的类成员。当按值传递 parameter_packer 的时候，需要正确的实现它。
到了这一步，我们终于把所有的内容都铺垫好了，接下来把函数内容补充完全。
template<class Func, class ... Args> task(Func func, Args&& ... args) { reset_impl(func, parameter_packer< decltype( std::forward<Args>(args) ) > (std::forward<Args>(args ) ) ...); } private: template<class Func, class ... Args> void reset_impl(Func func, Args ... args) { auto lambda_helper = [func, args ...]()->void { func( (args.param)...); }; m_task_unit.reset( new task_unit_impl<decltype(lambda_helper) >(lambda_helper) ); }到这一步，就算是完成主要的内容了。
通过parameter_packer 的设计，完成函数参数的封装。
如何支持类成员函数
在实际的使用过程中，我们经常会调用类的成员函数。
那么对类的成员函数有支持，将会极大丰富它的功能性。
但是，调用类的成员函数，是需要保存类的对象指针的。
所以，针对这个版本，我们可以实现如下：
template<class ReturnT, class ClassT, class ... ClassFuncArgs>void reset(ReturnT(ClassT::* func)(ClassFuncArgs ...), ClassT * obj_ptr, ClassFuncArgs&& ... args){ reset_class_func_impl(func, obj_ptr, parameter_packer<decltype(std::forward<ClassFuncArgs>(args)) > (std::forward<ClassFuncArgs>(args)) ...);}template<class Func, class T, class ... Args>void reset_class_func_impl(Func func, T* obj_ptr, Args ... args){ auto lambda_helper = [func, obj_ptr, args ...]()->void { (obj_ptr->*func)((args.param) ...); }; m_task_unit.reset(new task_unit_impl<decltype(lambda_helper) >(lambda_helper));}注意到，对于类的成员函数指针，模板是能够标识出来的。通过这个，我们就可以编写针对类成员函数指针的reset 函数了。
第二个参数是调用这个对象的类指针。
使用示例如下：
class A{public: void dosome(int a) { int i = a; i += 4; cout << i << endl; }};A a;xj::task t;t.reset(&A::dosome, &a, 5);t();补全代码
接着把一下内容补全就行，包括：
- task 的copy 和 move 的constructor 和 assignment 函数
- 一个reset 函数
- 将
m_task_unit用智能指针封装起来，进行资源管理
emmm，看起来一切都很好。
不对，还有一个问题没有解决。
如果我们本意是希望按值传递参数的话，可能需要做点小小的改动。
看代码：
struct A {};void somefunction(int i, A a) {}int i = 3;A value;task t(somefunction, i, value); //错误的按值传递task t2(somefunction, int(i), A(value) ); // int 没有按值传递，A 按值传递。因为该死的int()语法是强制转换语法所以，事实上按值传递的参数将会被转发为右值引用，从而被parameter_packer 保存下来。
所以，我们可以加一个函数：
template<class T> inline T param_maker(T value) { return value; }用法变成了如下：
task t(somefunction, param_maker(i), param_maker(value) ); emm，把一些都处理好以后，整个文件的内容如下：
#pragma once#include <utility>#include <memory>#include <iostream>using namespace std;namespace xj{ struct task_unit { virtual ~task_unit() {} virtual void operator() () {} }; template<class Func> struct task_unit_impl : public task_unit { task_unit_impl(Func in_func) : m_func(in_func) {} virtual void operator() () { m_func(); } private: Func m_func; }; template<class T> struct parameter_packer { }; template<class T> struct parameter_packer<T&> { parameter_packer(T& value) : param(value) {} T& param; }; template<class T> struct parameter_packer<T&&> { parameter_packer(T&& value) : param(move(value)) {} parameter_packer(const parameter_packer& other) : param(move(other.param)) {} T&& param; }; template<class T> inline T param_maker(T value) { return value; } class task { public: task() : m_task_unit(nullptr) { } task(task& other) { m_task_unit.swap(other.m_task_unit); } task(task&& other) :m_task_unit(std::move(other.m_task_unit)) {} task& operator = (task& other) { if (&other != this) { m_task_unit.swap(other.m_task_unit); } return *this; } task& operator = (task&& other) { if (&other != this) { m_task_unit = std::move(other.m_task_unit); } return *this; } template<class Func, class ... Args> task(Func func, Args&& ... args) { reset_impl(func, parameter_packer< decltype(std::forward<Args>(args)) > (std::forward<Args>(args)) ...); } template<class Func> task(Func func) { m_task_unit.reset(new task_unit_impl<Func >(func)); } template<class ReturnT, class ClassT, class ... ClassFuncArgs> task(ReturnT(ClassT::* func)(ClassFuncArgs ...), ClassT * obj_ptr, ClassFuncArgs&& ... args) { reset_class_func_impl(func, obj_ptr, parameter_packer<decltype(std::forward<ClassFuncArgs>(args)) > (std::forward<ClassFuncArgs>(args)) ...); } template<class Func, class ... Args> void reset(Func func, Args&& ... args) { reset_impl(func, parameter_packer<decltype(std::forward<Args>(args)) > (std::forward<Args>(args)) ...); } template<class ReturnT, class ClassT, class ... ClassFuncArgs> void reset(ReturnT(ClassT::* func)(ClassFuncArgs ...), ClassT * obj_ptr, ClassFuncArgs&& ... args) { reset_class_func_impl(func, obj_ptr, parameter_packer<decltype(std::forward<ClassFuncArgs>(args)) > (std::forward<ClassFuncArgs>(args)) ...); } template<class Func> void reset(Func func) { m_task_unit.reset(new task_unit_impl<Func >(func)); } void operator() () { if (m_task_unit) { (*m_task_unit)(); } } private: template<class Func, class ... Args> void reset_impl(Func func, Args ... args) { auto lambda_helper = [func, args ...]()->void { func((args.param)...); }; m_task_unit.reset(new task_unit_impl<decltype(lambda_helper) >(lambda_helper)); } template<class Func, class T, class ... Args> void reset_class_func_impl(Func func, T* obj_ptr, Args ... args) { auto lambda_helper = [func, obj_ptr, args ...]()->void { (obj_ptr->*func)((args.param) ...); }; m_task_unit.reset(new task_unit_impl<decltype(lambda_helper) >(lambda_helper)); } std::unique_ptr<task_unit> m_task_unit; };}//xj以下附上一些测试用例。
最后，欢迎一起交流想法。
#include <iostream>using namespace std;#include "xj_task.h"using namespace xj;struct A{ A(int in_b = 4) : b(in_b) { cout << "A constructor " << endl; } A(const A& other) : b(other.b) { cout << "A copy contructor " << endl; } A(A&& other) { b = other.b; cout << "A move" << endl; } ~A() { cout << "A destructor" << endl; } int b;};int somefunc(int a, A& b){ cout << a + b.b << endl; return a + b.b;}int somefunc(int*a, A&b){ cout << *a + b.b << endl; return *a + b.b;}using first_type = int(*)(int, A&);using second_type = int(*)(int*, A&);void empty_func(){ cout << "empty_func" << endl;}int main(){ task tt(empty_func); tt(); if (false) { A A_v; A& A_ref = A_v; int int_v = 3; task t(first_type(somefunc), param_maker(int_v), A_v); task t2((first_type)somefunc, 3, A(A_v)); task t3((first_type)somefunc, 3, A_ref); task t4((second_type)somefunc, &int_v, A_v); task t5([](A a, A b, int c)->void { cout << somefunc(c, a) + b.b << endl; }, A(233), A(A_v), 4); //t(), t2(), t3(); ++int_v; t(); t2(); t3(); ++int_v; t4(); t5(); task t6; t6.reset(first_type(somefunc), param_maker(int_v), A_v); t6(); task t7(t5); t7(); t5(); } { task t((first_type)somefunc, 4, A(233) ); task t2(t); t2(); t(); }}【参考资料】
【1】模板实参推导
【2】引用声明
- C++ Task 的实现（lambda 是个好东西）
- c#Task的continuewith
- lambda的实现
- 图论：一个叫做SPFA的东西(C语言代码实现)
- Objective-C是个好东西（简介）
- Ｃ＃中可取消的Task
- GNU C用宏实现lambda表达式
- boost::lambda的实现模拟
- Lift ( lambda 的新实现 )
- Javascript Lambda的简单实现
- lambda表达式的底层实现
- lambda表达式的简单实现
- Spring3 Schedule Task之注解实现 （两次起动Schedule Task 的解决方案）
- C# Task ContinueWith的实现
- lambda表达式（python & C++）
- C语言的一些东西
- [c#]: Lambda
- C#-Lambda
- Androidstudio_Plugs
- Linux 文件结构 简介
- 知道三边判断一个三角形
- python之装饰器与生成器
- 解决webapps目录下不存在Tomcat的部署项目
- C++ Task 的实现（lambda 是个好东西）
- Cordova插件实现原理概论
- Python3与OpenCV3.3 图像处理（一）--环境搭建与简单DEMO
- python中 %总结
- 97/100 Interleaving String/Same Tree
- CF#420 B. Okabe and Banana Trees 思维｜暴力｜几何
- 使用SwingWorker类完成耗时操作
- Python练习实例3
- Python学习教程（八）——异常
