国产精品久久国产精品99盘,一本大道加勒比久久综合,久久免费国产精品一区二区

Sun, 22 Feb 2009 14:11:00 GMT

看看之前做到哪里了：实现了一个赋值的lambda表达式�?br>
�q�次来看看怎么��d��新的�q�算�q�去�Q�然后再说点关于表达式的问题�Q��ؓ以后的扩展打下理论基��?br>
先看看之前的代码吧，

 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);

现在�Q�要在这个基��上，��d��新的操作�q�来�Q�比如说operator+=吧。要怎么做呢�Q?br>
1. place_holder要重载operator+= 才可以，因�ؓplace_holder的主要�Q务就是替我们生成一个仿函数�?br>2. 要有相应的仿函数来真正的�?+= �Q�也��是说在仿函数的operator()里面�Q�要有真正干�zȝ��操作�?br>
好了�Q�开始吧�Q?先看看实玎ͼ�然后在解释�?br>

 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 }

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

1. �l�place_holder增加了一个operator+=函数�Q?operator+= �q�回op1�c�d��的仿函数�?br>2. 增加了一个op1的仿函数�Q�类模板�Q�，用来真正的执�?+= 的运��?br>
当编译器看到 _1 += 3 �Ӟ��L��?place_holder::operator+=, 然后把模板参数推导成 int�Q�返回一�?op1 对象�?br>在for_each里面�Q�就调用op1::operator+=了�?br>
当然也可以这么用�Q?br>

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

到这里大家想必已�l�可以照猫画虎，实现其他操作了吧。但是当实现的操作多��h��的时候，新的问题��来了，比如惌��?_1 = _2 + 3.0 的时候呢�Q�看看下面的代码�Q?br>

 1 _1 = _2 + 3.0    //lambda表达�?/span>
 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表达式�ؓ我们省了多少代码�Q�当然我不是��Z��说这个而写�q�么长段代码�Q�我惌��Q�那个op是我们的最�l�目标，能实现吗�Q�不能！因�ؓ在op里面直接出现�?.0�Q�按照前面的惯例�Q�应该在op里面有一个成员变量来保存3.0�Q�不是吗�Q�根本问题不在这里�?br>
仔细��x��我们到底在做什么，我们在用template的技法，“�~�译”表达式�?br>place_holder其实��像C++的表辑ּ��Q�op��像汇编语言�Q�通过template技法，把place_holder的表辑ּ�“�~�译”成用op�l�成的操作，op是可以直接被C++�q�行的仿函数。也��是说是一个从lambda语法到C++语法的编译器�Q�但是这个编译器靠template技法实玎ͼ��q��正的C++�~�译器进行模板推��|��最�?#8220;�~�译”成C++的仿函数。所以一句话��是�Q?br>
用template技法实现的从lambda语法到C++语法�?#8220;�~�译�?#8221;�?br>
所以根本问题在于op的这�U�写法没有办法扩展，��N��对于每种�q��v来的操作�Q�都分别写一个op吗（比如_1 = (_2 + 3.0) * (_2 - 3.0)�Q�C++中表辑ּ�无数�Q�要是每�U�都要写个op�Q�那要lambda何用 �Q�？op相当于汇�~�，只要几个��单的�q�算��OK�Q�关键在于按照place_holder的表达，把op�l�合��h��?br>
下一��准备介�l�一下boost::tuple�Q�和表达式编译，因�ؓ它们是实现lambda的关键武器�?

��东�?/a> 2009-02-22 22:11 发表评论

Fri, 20 Feb 2009 11:21:00 GMT

上次说到在假讄��型int下，成功的实��C��一�?#8220;lambda”�Q�这�ơ，当然不能�q�在int的假设下了。我们的武器��是模板�Q�说��h��模板�Q�话��长了�?br>�q�里略过�Q�讲重点�?/p>

�q�是上次最后的代码�Q��ؓ了方便描�q�ͼ�再脓一份�?br>

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的依赖，先仔�l�想惛_��int的依赖都在哪里？说明白点��是整个�E�序�Q�哪里都有int�Q?br>1. op的构造函数参数是int
2. op里面的成员变�?_i的类型是int
3. op的operator() 的返回值和参数都有int
4. place_holder的operator=的参数是int

当然 vector 也有int�Q�但�q�个不算 �Q�）

�ȝ��来说�Q�int�?一个变�?int op::_i�Q?三个函数 op::op(int i), op::operaator(int& i) �?place_holder::operator=(int) 有关�p�，�q�一点很重要�Q�类和函数在泛型中的作用不一��P��
看看 http://www.shnenglu.com/yindf/archive/2009/02/20/74397.html 中说的类模板和函数模板的区别吧�?/p>

再细分一点，�?_1 有关的int��只有op::operator()一个，其他都和 _1 没关�p�R�?br>剩下的都�?3 有关�p�，��x�� 3 的传递�\径， �?place_holder::operator = �?op::op(int i)�Q?再到 op::_i�?/p>

也就是说op::operator()要一个独立的模板参数�?br>��x��看，其实op::op(int i) �?op::_i 是一个东西，构造函数就是�ؓ了初始化�q�个变量。所以这里选择泛化整个op�Q�就是说构造函数的参数和变量是同一个类型�?br>对于place_holder::operator =�Q?是要泛化整个place_holder呢，�q�是只泛化place_holder::operator=呢，当然泛化函数�Q�因为类不会�q�行�c�d��推导�?br>意思是如果泛化�cȝ��话，你就要有为无数类型特化过的place_holder�Q�这里很隄��解，不理解的话，�l�箋看下��d��?/p>

现在��开始实做吧�?br>

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);

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

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

那么�q�个_T 被推��gؓ int, 然后�q�回一�?op, 然后 op 里面��有一�?int op::_i;

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

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

op的模板参数被推定义�ؓint了（不是推导的，�c�L��板不会推��|��?br>
所以手法是先靠函数推导模板参数�Q�再靠类保存�c�d��信息�?br>
于是�Q�下面的函数模板

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

的模板参�?_T ��p��推导�?*iter 的类型了�Q�也��是容器�?value_type 了�?/p>

好了�Q�到现在�Q�一个赋值的lambda��做好了�Q�它�q�能�q�么用：

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

��q��x赋�?了，��奇吧�?br>因�ؓ (_1 = 5)�q�回的是个lambda表达式，也就是个仿函敎ͼ�:)

现在才看到lambda核心的一��部分，已经让�h感觉眩晕了�?br>看看现在�q�存在的问题�Q�只实现了一个赋值操作，其他的呢�Q?下篇�l�箋。。�?/p>

��东�?/a> 2009-02-20 19:21 发表评论

Thu, 19 Feb 2009 11:19:00 GMT

刚注册好cppblog的用��P��q�算是处女作了�?最�q�在学习boost::lambda, 分��n下学习心得，共同�q�步�?br>
当然�q�篇不是讲boost::lambda的用法的�Q�如有有人感兴趣�Q�可以参照：http://www.boost.org/doc/libs/1_38_0/doc/html/lambda.html

boost::lambda很复杂，一两句话也说不清楚�Q�我��力描述的简单一点，慢慢增加隑ֺ��?br>
�Ҏ��来说�Q�boost::lambda省了不少事，我是喜欢stl algorithm的，现在基本上除非特�D�情况，�E�序里面都不出现循环了。用for_each, transform �{�等都可以搞定，否则�Q�就要考虑数据�l�构和算法是不是有问题了�?br>
但是问题在于每次用for_each的时候，都要定义一个仿函数�Q�Modern C++ Design �q�么叫的�Q�，�ȝ��Q�程序看��h��也不怎么优雅��畅�Q�总要停下来去看那个仿函数到底�q�什么了�Q�写的时候还要想是不是要泛化�Q�很头痛。有了boost::lambda�Q�就爽多了。看��h��一目了�Ӟ��写�v来简单明了，不用兛_��c�d��。（是不是搞推销的？�Q?br>
�a�归正传吧�?br>
比如下面�q�段代码�Q?br>

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());

够简单吧�Q�把整个容器的值都�Ҏ��3. 看到那个OP了吧�Q�很��单的一件事情，非要让�h写这么个struct�Q�要是写成class�Q�还要public�Q�更郁闷�?br>
看看用了boost::lambda以后的效果吧�?br>

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定义呀�Q�因�?string("OP()").length() == string("_1=3").length() .

那么�Q�怎么才能辑ֈ��q�个效果呢，在这里，先假设我们只用int�c�d��Q�关于泛化，下一��再��_��一�ơ吃多了消化不良的�?br>
熟悉for_each的都知道�Q�for_each的第3个参数是个函数对象（我不用指针抱歉）�Q�注意区分仿函数和函数对象，仿函数是个类型，函数对象是个对象�?br>
那么也就是说 _1 = 3 的结果应该是个函数对象，而且是个一元函数对象（不了解的�ȝ��for_each实现�Q�。知道了�q�个�Q�很�Ҏ��写个大概�Q?br>

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);

�Q�？�Q�不是�ؕ码，�q�里只是暂时不知道写什么�?br>我说�q�，�q�篇里面�c�d��都是int�Q�但是那�?怎么处理呢，明显要保存的仿函数里面去么，所以上面的代码�q�一步修改，
个OP里面增加变量�Q�来保存3�Q�函数返回值现在不重要�Q�就写成int吧，以后有问题再说�?br>于是代码变成�Q?br>

问题解决�?br>
看到�q�里�Q�整个程序已�l�可以执行了。把容器的值改�?�Q�没问题吧�?br>
整片文章都在一个假设之下，��是只用int�Q�那要是不用int呢，情况��复杂一点了�Q�下��再讨论�?如果熟悉template的话�Q�下��很�Ҏ��Q�否则，复习咯�?

��东�?/a> 2009-02-19 19:19 发表评论