【STL终极奥义❀解耦合思想的实现❀】函数对象、谓词与函数适配器——从for_each、transform、count_if、sort算法源码的角度分析（二）

1. template<typename _MyType>
2. class _TransformClass
3. {
4. public:
5.  _MyType operator()(_MyType& t1, _MyType& t2)
6.  {
7.    return (t1 + t2);
8.  }
9. };
10. 
11. template<typename _MyType>
12. _MyType _TransformFunc(_MyType& t1, _MyType& t2)
13. {
14.   return (t1 + t2);
15. }

1. vector<string> v3(for_each_obj.get_count() + 1);
2. v3[6] = "end";
3. transform(v1.begin(), v1.end(), v1.begin(), v3.begin(), _TransformClass<string>());
4. for_each(v3.begin(), v3.end(), _FroEachClass<string>());
5. cout << endl;
6. vector<string>::iterator it = transform(v1.begin(), v1.end(), v1.begin(), v3.begin(), _TransformFunc<string>);
7. for_each(v3.begin(), v3.end(), _FroEachClass<string>());
8. cout << endl;
9. cout << *it << endl; //transform 返回的是: v1 + v2 最后一个元素相加后，后面的那个位置的迭代器

1. vector<string>::iterator it = transform(v1.begin(), v1.end(), v1.begin(), v3.begin(), _TransformFunc<string>);
2. for_each(v3.begin(), v3.end(), _FroEachClass<string>());
3. cout << endl;
4. cout << *it << endl; //transform 返回的是: v1 + v2 最后一个元素相加后，后面的那个位置的迭代器

1. template <class _RanIt, class _Pr>
2. void sort(const _RanIt _First, const _RanIt _Last, _Pr _Pred) { // order [_First, _Last), using _Pred
3.  _Adl_verify_range(_First, _Last);
4.  const auto _UFirst = _Get_unwrapped(_First);
5.  const auto _ULast = _Get_unwrapped(_Last);
6.  _Sort_unchecked(_UFirst, _ULast, _ULast - _UFirst, _Pass_fn(_Pred));
7. }

1. template <class _RanIt, class _Pr>
2. void _Sort_unchecked(_RanIt _First, _RanIt _Last, _Iter_diff_t<_RanIt> _Ideal, _Pr _Pred) {
3. // order [_First, _Last), using _Pred
4.     _Iter_diff_t<_RanIt> _Count;
5. while (_ISORT_MAX < (_Count = _Last - _First) && 0 < _Ideal) { // divide and conquer by quicksort
6. auto _Mid = _Partition_by_median_guess_unchecked(_First, _Last, _Pred);
7. // TRANSITION, VSO#433486
8.         _Ideal = (_Ideal >> 1) + (_Ideal >> 2); // allow 1.5 log2(N) divisions
9. 
10. if (_Mid.first - _First < _Last - _Mid.second) { // loop on second half
11.             _Sort_unchecked(_First, _Mid.first, _Ideal, _Pred);
12.             _First = _Mid.second;
13.         } else { // loop on first half
14.             _Sort_unchecked(_Mid.second, _Last, _Ideal, _Pred);
15.             _Last = _Mid.first;
16.         }
17.     }
18. 
19. if (_ISORT_MAX < _Count) { // heap sort if too many divisions
20.         _Make_heap_unchecked(_First, _Last, _Pred);
21.         _Sort_heap_unchecked(_First, _Last, _Pred);
22.     } else if (2 <= _Count) {
23.         _Insertion_sort_unchecked(_First, _Last, _Pred); // small
24.     }
25. }

1. //二元谓词
2. template<typename _MyType>
3. class _SortClass
4. {
5. public:
6.  bool operator()(_MyType& t1, _MyType& t2)
7.  {
8.    return (t1 > t2);
9.  }
10. };
11. 
12. template<typename _MyType>
13. bool _SortFunc(_MyType& t1, _MyType& t2)
14. {
15.   return (t1 > t2);
16. }

1. v4.push_back(1);
2. sort(v4.begin(), v4.end(), _SortClass<int>());
3. for_each(v4.begin(), v4.end(), _FroEachClass<int>());
4. cout << endl;
5. sort(v4.begin(), v4.end(), _SortFunc<int>);
6. for_each(v4.begin(), v4.end(), _FroEachClass<int>());
7. cout << endl;

1. sort(v4.begin(), v4.end(), greater<int>()); //使用预定义函数对象
2. for_each(v4.begin(), v4.end(), _FroEachClass<int>());
3. cout << endl;

1. int n = 5;
2. int num = count_if(v4.begin(), v4.end(), bind2nd(greater<int>(), n));
3. //count_if 接收一元函数对象或一元谓词，我们借用二元谓词greater实现计算大于5的元素个数
4. //这时可以使用绑定器 bind2nd 把预定义函数对象greater和一个参数n适配为一元谓词
5. cout << "greater " << n << " : " << num << endl;