posts - 18,  comments - 104,  trackbacks - 0

上次说到在假设类型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和 一个变量 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<int>, 然后 op<int> 里面就有一个 int op<int>::_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核心的一小部分,已经让人感觉眩晕了。
看看现在还存在的问题,只实现了一个赋值操作,其他的呢? 下篇继续。。。

posted on 2009-02-20 19:21 尹东斐 阅读(846) 评论(5)  编辑 收藏 引用 所属分类: 深入探索 boost::lambda 系列

FeedBack:
# re: 深入探索 boost::lambda 系列(二)
2009-02-20 21:51 | 发生地方
貌似比较复杂啊  回复  更多评论
  
# re: 深入探索 boost::lambda 系列(二)[未登录]
2009-02-21 08:27 | cppexplore
顶博主
多发写相关的东西啊
坐下来慢慢看  回复  更多评论
  
# re: 深入探索 boost::lambda 系列(二)
2009-02-23 15:23 | luke
博主研究c++想必有多年的功力了吧,支持一下!!!  回复  更多评论
  
# re: 深入探索 boost::lambda 系列(二)
2010-10-14 15:55 | 匿名
Great!崇拜一下!  回复  更多评论
  
# re: 深入探索 boost::lambda 系列(二)
2012-11-05 17:04 | 匿名
为什么op类的模板参数和operator()的模板参数需要两个呢?为什么op::operator()也需要十个模板函数呢?  回复  更多评论
  

只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理


<2020年9月>
303112345
6789101112
13141516171819
20212223242526
27282930123
45678910

常用链接

留言簿(3)

随笔档案

文章分类

文章档案

相册

好友博客

搜索

  •  

最新评论

阅读排行榜

评论排行榜