您的位置：首页 > 编程语言 > C语言/C++

C++ Task 的实现（lambda 是个好东西）

2017-11-15 12:38 176 查看

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语言 lambda

相关文章推荐

新的分享

章节导航