C++博客-善始者实繁，克终者盖寡。-文章分类-深入探索 boost::lambda 系列

深入探索 boost::lambda 系列（三）

尹东斐 — Sun, 22 Feb 2009 14:11:00 GMT

看看之前做到哪里了：实现了一个赋值的lambda表达式。

这次来看看怎么添加新的运算进去，然后再说点关于表达式的问题，为以后的扩展打下理论基础。

先看看之前的代码吧，

 1 template <typename _U>
 2 struct op
 3 {
 4     op(_U i)
 5         : _i(i)
 6     {}
 7 
 8     _U _i;
 9 
10     template<typename _T>
11     _T& operator()(_T& i)
12     {
13         i = _i;
14     }
15 };
16 
17 struct place_holder
18 {
19     template <typename _T>
20     op<_T> operator=(_T i)
21     {
22         return op<_T>(i)
23     }
24 };
25 
26 place_holder _1;
27 
28 vector<double> v;
29 for_each(v.begin(), v.end(), _1 = 3);

现在，要在这个基础上，添加新的操作进来，比如说operator+=吧。要怎么做呢？

1. place_holder要重载operator+= 才可以，因为place_holder的主要任务就是替我们生成一个仿函数。
2. 要有相应的仿函数来真正的做 += ，也就是说在仿函数的operator()里面，要有真正干活的操作。

好了，开始吧，先看看实现，然后在解释。

 1 struct op
 2 {
 3     op(int i)
 4         : _i(i)
 5     {}
 6 
 7     int _i;
 8 
 9     int operator()(int& i)
10     {
11         return i = _i;
12     }
13 };
14 
15 struct op1
16 {
17     op1(int i)
18         : _i(i)
19     {}
20 
21     int _i;
22 
23     int operator()(int& i)
24     {
25         return i += _i;
26     }
27 };
28 
29 struct place_holder
30 {
31     op operator=(int i)
32     {
33         return op(i);
34     }
35 
36     op1 operator+=(int i)
37     {
38         return op1(i);
39     }
40 };
41 
42 place_holder _1;
43 
44 void main()
45 {
46 
47     vector<int> v;
48     v.push_back(12);
49     v.push_back(1342);
50     v.push_back(23);
51 
52     for_each(v.begin(), v.end(), _1 += 3);
53 }

好了，现在+=操作已经被支持了。多么简单呀。来看看都做了些什么：

1. 给place_holder增加了一个operator+=函数， operator+= 返回op1类型的仿函数。
2. 增加了一个op1的仿函数（类模板），用来真正的执行 += 的运算。

当编译器看到 _1 += 3 时，去找到 place_holder::operator+=, 然后把模板参数推导成 int，返回一个 op1 对象。
在for_each里面，就调用op1::operator+=了。

当然也可以这么用：

1 double x = 0.0;
2 (_1 += 10.4)(x);

到这里大家想必已经可以照猫画虎，实现其他操作了吧。但是当实现的操作多起来的时候，新的问题就来了，比如想要个 _1 = _2 + 3.0 的时候呢？看看下面的代码：

 1 _1 = _2 + 3.0    //lambda表达式
 2 
 3 void fun(double& lhs, const double& rhs)  //相同功能函数
 4 {
 5     lhs = rhs + 3.0;
 6 }
 7 
 8 struct op
 9 {
10     template <typename _T>
11     _T operator(_T& lhs, const _T& rhs)
12     {
13         lhs = rhs + 3.0;
14     }
15 };
16 

看看lambda表达式为我们省了多少代码！当然我不是为了说这个而写这么长段代码，我想说，那个op是我们的最终目标，能实现吗？不能！因为在op里面直接出现了3.0，按照前面的惯例，应该在op里面有一个成员变量来保存3.0，不是吗？根本问题不在这里。

仔细想想我们到底在做什么，我们在用template的技法，“编译”表达式。
place_holder其实就像C++的表达式，op就像汇编语言，通过template技法，把place_holder的表达式“编译”成用op组成的操作，op是可以直接被C++运行的仿函数。也就是说是一个从lambda语法到C++语法的编译器，但是这个编译器靠template技法实现，由真正的C++编译器进行模板推导，最后“编译”成C++的仿函数。所以一句话就是：

用template技法实现的从lambda语法到C++语法的“编译器”。

所以根本问题在于op的这种写法没有办法扩展，难道对于每种连起来的操作，都分别写一个op吗（比如_1 = (_2 + 3.0) * (_2 - 3.0)，C++中表达式无数，要是每种都要写个op，那要lambda何用）？op相当于汇编，只要几个简单的运算就OK，关键在于按照place_holder的表达，把op组合起来。

下一篇准备介绍一下boost::tuple，和表达式编译，因为它们是实现lambda的关键武器。

尹东斐 2009-02-22 22:11 发表评论

深入探索 boost::lambda 系列（二）

尹东斐 — Fri, 20 Feb 2009 11:21:00 GMT

上次说到在假设类型int下，成功的实现了一个“lambda”，这次，当然不能还在int的假设下了。我们的武器就是模板，说起来模板，话就长了。
这里略过，讲重点。

这是上次最后的代码，为了方便描述，再贴一份。

1 struct op
2 {
3     op(int i)
4         : _i(i)
5     {}
6
7     int _i;
8
9     int operator()(int& i)
10     {
11         i = _i;
12     }
13 };
14
15 struct place_holder
16 {
17     op operator=(int i)
18     {
19         return op(i)
20     }
21 };
22
23 place_holder _1;
24
25 for_each(v.begin(), v.end(), _1 = 3);

要去掉对int的依赖，先仔细想想对int的依赖都在哪里？说明白点就是整个程序，哪里都有int？
1. op的构造函数参数是int
2. op里面的成员变量 _i的类型是int
3. op的operator() 的返回值和参数都有int
4. place_holder的operator=的参数是int

当然 vector 也有int，但这个不算：）

总的来说，int和一个变量 int op::_i，三个函数 op::op(int i), op::operaator(int& i) 和 place_holder::operator=(int) 有关系，这一点很重要，类和函数在泛型中的作用不一样，
看看 http://www.cppblog.com/yindf/archive/2009/02/20/74397.html 中说的类模板和函数模板的区别吧。

再细分一点，和 _1 有关的int就只有op::operator()一个，其他都和 _1 没关系。
剩下的都和 3 有关系，想想 3 的传递路径，从 place_holder::operator = 到 op::op(int i)，再到 op::_i。

也就是说op::operator()要一个独立的模板参数。
想想看，其实op::op(int i) 和 op::_i 是一个东西，构造函数就是为了初始化这个变量。所以这里选择泛化整个op，就是说构造函数的参数和变量是同一个类型。
对于place_holder::operator =，是要泛化整个place_holder呢，还是只泛化place_holder::operator=呢，当然泛化函数，因为类不会进行类型推导。
意思是如果泛化类的话，你就要有为无数类型特化过的place_holder，这里很难理解，不理解的话，继续看下去吧。

现在就开始实做吧。

1 template <typename _U>
2 struct op
3 {
4     op(_U i)
5         : _i(i)
6     {}
7
8     _U _i;
9
10     template<typename _T>
11     _T& operator()(_T& i)
12     {
13         i = _i;
14     }
15 };
16
17 struct place_holder
18 {
19     template <typename _T>
20     op<_T> operator=(_T i)
21     {
22         return op<_T>(i)
23     }
24 };
25
26 place_holder _1;
27
28 for_each(v.begin(), v.end(), _1 = 3);

好了，泛化完成。难道就这么简单？事实就是这么简单。
来分析一下模板推导的过程吧， _1 = 3 调用，从下面这个函数开始，

1 template <typename _T>
2 op<_T> place_holder::operator=(_T i);

那么这个_T 被推导为 int, 然后返回一个 op, 然后 op 里面就有一个 int op::_i;

于是，在for_each里面，相当于有这么一句：

1 op<int> p;
2 p(*iter);

op的模板参数被推定义为int了（不是推导的，类模板不会推导）。

所以手法是先靠函数推导模板参数，再靠类保存类型信息。

于是，下面的函数模板

1 template<typename _T>
2 _T& op<int>::operator()(_T& i)
3 {
4 i = _i;
5 }

的模板参数 _T 就被推导成 *iter 的类型了，也就是容器的 value_type 了。

好了，到现在，一个赋值的lambda就做好了，它还能这么用：

1 double x;
2 (_1 = 5)(x);

就给x赋值5了，神奇吧。
因为 (_1 = 5)返回的是个lambda表达式，也就是个仿函数，:)

现在才看到lambda核心的一小部分，已经让人感觉眩晕了。
看看现在还存在的问题，只实现了一个赋值操作，其他的呢？下篇继续。。。

尹东斐 2009-02-20 19:21 发表评论

深入探索 boost::lambda 系列（一）

尹东斐 — Thu, 19 Feb 2009 11:19:00 GMT

刚注册好cppblog的用户，这算是处女作了。最近在学习boost::lambda, 分享下学习心得，共同进步。

当然这篇不是讲boost::lambda的用法的，如有有人感兴趣，可以参照：http://www.boost.org/doc/libs/1_38_0/doc/html/lambda.html

boost::lambda很复杂，一两句话也说不清楚，我尽力描述的简单一点，慢慢增加难度。

对我来说，boost::lambda省了不少事，我是喜欢stl algorithm的，现在基本上除非特殊情况，程序里面都不出现循环了。用for_each, transform 等等都可以搞定，否则，就要考虑数据结构和算法是不是有问题了。

但是问题在于每次用for_each的时候，都要定义一个仿函数（Modern C++ Design 这么叫的），麻烦，程序看起来也不怎么优雅顺畅，总要停下来去看那个仿函数到底干什么了，写的时候还要想是不是要泛化，很头痛。有了boost::lambda，就爽多了。看起来一目了然，写起来简单明了，不用关心类型。（是不是搞推销的？）

言归正传吧。

比如下面这段代码：

1 vector<int> v;
2 v.push_back(12);
3 v.push_back(1342);
4 v.push_back(23);
5
6 struct OP
7 {
8     void operator()(int &i)
9     {
10         i = 3;
11     }
12 };
13
14 for_each(v.begin(), v.end(), OP());

够简单吧，把整个容器的值都改成3. 看到那个OP了吧，很简单的一件事情，非要让人写这么个struct，要是写成class，还要public，更郁闷。

看看用了boost::lambda以后的效果吧。

1 vector<int> v;
2 v.push_back(12);
3 v.push_back(1342);
4 v.push_back(23);
5 
6 for_each(v.begin(), v.end(), _1 = 3);
7 

比不用lambda整整少了一个OP定义呀，因为 string("OP()").length() == string("_1=3").length() .

那么，怎么才能达到这个效果呢，在这里，先假设我们只用int类型，关于泛化，下一篇再说，一次吃多了消化不良的。

熟悉for_each的都知道，for_each的第3个参数是个函数对象（我不用指针抱歉），注意区分仿函数和函数对象，仿函数是个类型，函数对象是个对象。

那么也就是说 _1 = 3 的结果应该是个函数对象，而且是个一元函数对象（不了解的去看for_each实现）。知道了这个，很容易写个大概：

1 struct op
2 {
3     ??? operator()(int& i)
4     {
5         i = ???;
6     }
7 };
8
9 struct place_holder
10 {
11     op operator=(int i)
12     {
13         return op???;
14     }
15 };
16
17 place_holder _1;
18
19 for_each(v.begin(), v.end(), _1 = 3);

？？？不是乱码，这里只是暂时不知道写什么。
我说过，这篇里面类型都是int，但是那个3怎么处理呢，明显要保存的仿函数里面去么，所以上面的代码进一步修改，
个OP里面增加变量，来保存3，函数返回值现在不重要，就写成int吧，以后有问题再说。
于是代码变成：

问题解决。

看到这里，整个程序已经可以执行了。把容器的值改成3，没问题吧。

整片文章都在一个假设之下，就是只用int，那要是不用int呢，情况就复杂一点了，下篇再讨论。如果熟悉template的话，下篇很容易，否则，复习咯。

尹东斐 2009-02-19 19:19 发表评论

C++博客-善始者实繁，克终者盖寡。-文章分类-深入探索 boost::lambda 系列

深入探索 boost::lambda 系列（三）

深入探索 boost::lambda 系列（二）

深入探索 boost::lambda 系列 （一）

深入探索 boost::lambda 系列（一）