使用C++标准库sort自定义比较函数导致死循环问题

永远让比较函数对相等的值返回false(来自Effective C++)

---------------------------------------------------------------------------------------------------------

转自http://www.cnblogs.com/yuanzz/p/3735213.html

最近写代码,无意中发现了一个坑,关于自定义比较函数的stl sort函数的坑,于是记录下来。

先贴代码:

复制代码
 1 #include 
 2 #include 
 3 #include 
 4 
 5 struct finder
 6 {
 7         bool operator()(int first, int second){return first <= second;}
 8 } my_finder;
 9 
10 int main(int argc, char** argv)
11 {
12         int value = atoi(argv[1]);
13         int num = atoi(argv[2]);
14         std::vector<int> vecTest;
15         for(int i=0; i!=num; ++i)
16                 vecTest.push_back(value);
17 
18         std::sort(vecTest.begin(), vecTest.end(), my_finder);
19         for(int i=0; i!=vecTest.size(); ++i)
20                 std::cout<'\t';
21         std::cout<<std::endl;
22 
23         return 0;
24 }
复制代码

这段代码看上去好好的,实际上却有core的可能。

且看图:

敏思苦想很久,也想不出为啥会core,后来查了资料,才发现了问题所在,现在通过源码分析一下原因。

于是定位到sort函数:

复制代码
 1   template
 2     inline void
 3     sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
 4          _Compare __comp)
 5     {
 6       typedef typename iterator_traits<_RandomAccessIterator>::value_type
 7         _ValueType;
 8 
 9       // concept requirements
10       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
11             _RandomAccessIterator>)
12       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, _ValueType,
13                                   _ValueType>)
14       __glibcxx_requires_valid_range(__first, __last);
15 
16       if (__first != __last)
17         {
18           std::__introsort_loop(__first, __last, __lg(__last - __first) * 2,
19                                 __comp);
20           std::__final_insertion_sort(__first, __last, __comp);
21         }
22     }
复制代码

这是stl_algo.h中的sort函数,且忽略10-14行的参数检查,实际上sort函数先是用了introsort(内省排序,http://en.wikipedia.org/wiki/Introsort),然后采用了insertsort(插入排序)。

1、我们先来分析内省排序吧。

  先来看看__introsort_loop的函数原型

复制代码
 1   template
 2     void
 3     __introsort_loop(_RandomAccessIterator __first,
 4                      _RandomAccessIterator __last,
 5                      _Size __depth_limit)
 6     {
 7       typedef typename iterator_traits<_RandomAccessIterator>::value_type
 8         _ValueType;
 9 
10       while (__last - __first > int(_S_threshold))
11         {
12           if (__depth_limit == 0)
13             {
14               std::partial_sort(__first, __last, __last);
15               return;
16             }
17           --__depth_limit;
18           _RandomAccessIterator __cut =
19             std::__unguarded_partition(__first, __last,
20                                        _ValueType(std::__median(*__first,
21                                                                 *(__first
22                                                                   + (__last
23                                                                      - __first)
24                                                                   / 2),
25                                                                 *(__last
26                                                                   - 1))));
27           std::__introsort_loop(__cut, __last, __depth_limit);
28           __last = __cut;
29         }
30     }
复制代码

  如果__last - __first > int(_S_threshold)的时候,就开始循环了。

  关于_S_threshold的定义:

1 enum { _S_threshold = 16 };

  好吧,是写死的,为【16

  注意,我为什么把16标红,这就是坑开始的地方了。如果元素小于16(第10行),就直接略过,开始了:

  std::__final_insertion_sort(__first, __last, __comp);  // 本次不对其进行分析

  我们继续往下走,__depth_limit哪来的呢。看代码:

复制代码
1   template
2     inline _Size
3     __lg(_Size __n)
4     {
5       _Size __k;
6       for (__k = 0; __n != 1; __n >>= 1)
7         ++__k;
8       return __k;
9     }
复制代码

  还记得sort调用introsort吗?

  std::__introsort_loop(__first, __last, __lg(__last - __first) * 2, __comp);

  当__depth_limit != 0时,则开始了introsort递归,而真正影响它的是__unguarded_partition函数。

  __unguarded_partition函数原型: 

复制代码
 1   template
 2     _RandomAccessIterator
 3     __unguarded_partition(_RandomAccessIterator __first,
 4                           _RandomAccessIterator __last,
 5                           _Tp __pivot, _Compare __comp)
 6     {
 7       while (true)
 8         {
 9           while (__comp(*__first, __pivot))
10             ++__first;
11           --__last;
12           while (__comp(__pivot, *__last))
13             --__last;
14           if (!(__first < __last))
15             return __first;
16           std::iter_swap(__first, __last);
17           ++__first;
18         }
19     }
复制代码

  好吧,终于要找到原因了,就是这个__pivot了。

  还记得我们自定义的__comp函数吗?  

  struct finder
  {
    bool operator()(int first, int second){return first <= second;}
  } my_finder;

  当*__first == __pivot的时候,返回了true,然后,执行了16行的元素交换。

  那如果像我测试的代码那样,所有元素都相等呢?岂不就是走进了死循环,等着的就可能是越界了。

  为什么__unguarded_partition不检查边界呢?有人分析称是为了效率,再大数据排序的时候,每次都需要校验边界,确实也是个很大开销。

  后来看人总结:永远让比较函数对相等的值返回false(来自Effective C++)

  附上正确代码: 

复制代码
 1 #include 
 2 #include 
 3 #include 
 4 
 5 struct finder
 6 {
 7         //永远让比较函数中对相等值返回false
 8         bool operator()(int first, int second){return first < second;}
 9 } my_finder;
10 
11 int main(int argc, char** argv)
12 {
13         int value = atoi(argv[1]);
14         int num = atoi(argv[2]);
15         std::vector<int> vecTest;
16         for(int i=0; i!=num; ++i)
17                 vecTest.push_back(value);
18 
19         std::sort(vecTest.begin(), vecTest.end(), my_finder);
20         for(int i=0; i!=vecTest.size(); ++i)
21                 std::cout<'\t';
22         std::cout<<std::endl;
23 
24         return 0;
25 }
复制代码

结果:

你可能感兴趣的:(C++)