上次說到在假設(shè)類型int下，成功的實(shí)現(xiàn)了一個“lambda”，這次，當(dāng)然不能還在int的假設(shè)下了。我們的武器就是模板，說起來模板，話就長了。
這里略過，講重點(diǎn)。
這是上次最后的代碼，為了方便描述，再貼一份。
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的依賴，先仔細(xì)想想對int的依賴都在哪里？說明白點(diǎn)就是整個程序，哪里都有int？
1. op的構(gòu)造函數(shù)參數(shù)是int
2. op里面的成員變量 _i的類型是int
3. op的operator() 的返回值和參數(shù)都有int
4. place_holder的operator=的參數(shù)是int
當(dāng)然 vector<int> 也有int，但這個不算 ：）
總的來說，int和 一個變量 int op::_i， 三個函數(shù) op::op(int i), op::operaator(int& i) 和 place_holder::operator=(int) 有關(guān)系，這一點(diǎn)很重要，類和函數(shù)在泛型中的作用不一樣，
看看 http://www.shnenglu.com/yindf/archive/2009/02/20/74397.html 中說的類模板和函數(shù)模板的區(qū)別吧。
再細(xì)分一點(diǎn)，和 _1 有關(guān)的int就只有op::operator()一個，其他都和 _1 沒關(guān)系。
剩下的都和 3 有關(guān)系，想想 3 的傳遞路徑， 從 place_holder::operator = 到 op::op(int i)， 再到 op::_i。
也就是說op::operator()要一個獨(dú)立的模板參數(shù)。
想想看，其實(shí)op::op(int i) 和 op::_i 是一個東西，構(gòu)造函數(shù)就是為了初始化這個變量。所以這里選擇泛化整個op，就是說構(gòu)造函數(shù)的參數(shù)和變量是同一個類型。
對于place_holder::operator =， 是要泛化整個place_holder呢，還是只泛化place_holder::operator=呢，當(dāng)然泛化函數(shù)，因?yàn)轭惒粫M(jìn)行類型推導(dǎo)。
意思是如果泛化類的話，你就要有為無數(shù)類型特化過的place_holder，這里很難理解，不理解的話，繼續(xù)看下去吧。
現(xiàn)在就開始實(shí)做吧。
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);
好了，泛化完成。難道就這么簡單？事實(shí)就是這么簡單。
來分析一下模板推導(dǎo)的過程吧， _1 = 3 調(diào)用，從下面這個函數(shù)開始，
1 template <typename _T>
2 op<_T> place_holder::operator=(_T i);
那么這個_T 被推導(dǎo)為 int, 然后返回一個 op<int>, 然后 op<int> 里面就有一個 int op<int>::_i;
于是，在for_each里面，相當(dāng)于有這么一句：
1 op<int> p;
2 p(*iter);
op的模板參數(shù)被推定義為int了（不是推導(dǎo)的，類模板不會推導(dǎo)）。
所以手法是
先靠函數(shù)推導(dǎo)模板參數(shù)，再靠類保存類型信息。
于是，下面的函數(shù)模板
1 template<typename _T>
2 _T& op<int>::operator()(_T& i)
3 {
4 i = _i;
5 }
的模板參數(shù) _T 就被推導(dǎo)成 *iter 的類型了，也就是容器的 value_type 了。
好了，到現(xiàn)在，一個賦值的lambda就做好了，它還能這么用：
1 double x;
2 (_1 = 5)(x);
就給x賦值5了，神奇吧。
因?yàn)?nbsp; (_1 = 5)返回的是個lambda表達(dá)式，也就是個仿函數(shù)，:)
現(xiàn)在才看到lambda核心的一小部分，已經(jīng)讓人感覺眩暈了。
看看現(xiàn)在還存在的問題，只實(shí)現(xiàn)了一個賦值操作，其他的呢？ 下篇繼續(xù)。。。
posted on 2009-02-20 19:21
尹東斐 閱讀(1013)
評論(5) 編輯 收藏 引用 所屬分類:
深入探索 boost::lambda 系列