C++中的 sort函数、函数指针、仿函数

原创

qq61b6d41d3f9e6 2021-12-27 11:45:58 ©著作权

©著作权归作者所有：来自51CTO博客作者qq61b6d41d3f9e6的原创作品，请联系作者获取转载授权，否则将追究法律责任

sort函数有2种常见的写法，一种是不带参的，也就是默认的升序，一种是传入函数指针的，用函数自定义排序规则。

示例：

#include<iostream>
#include<algorithm>
#include<functional>
using namespace std;

class cmp
{
public:
  bool operator()(int a, int b)  //从小到大
  {
    return a < b;
  }
};

bool cmp2(int a, int b)  //从大到小
{
  return a > b;
}

int main()
{
  int num[4] = { 1, 3, 4, 2 };
  sort(num, num + 4);
  cout << num[0] << num[1] << num[2] << num[3] << endl;
  sort(num, num + 4, cmp2);
  cout << num[0] << num[1] << num[2] << num[3] << endl;
  sort(num, num + 4, cmp());
  cout << num[0] << num[1] << num[2] << num[3] << endl;
  sort(num, num + 4, greater<>());
  cout << num[0] << num[1] << num[2] << num[3] << endl;
  sort(num, num + 4, less<>());
  cout << num[0] << num[1] << num[2] << num[3] << endl;
  return 0;
}

输出：

1234

4321

1234

4321

1234

其中，sort(num, num + 4);是默认的升序排序，

sort(num, num + 4, cmp2); 是传入cmp2这个函数指针，

而sort(num, num + 4, c); 是传入一个对象，对象中包含一个仿函数。

greater<>() 和 less<>() 都是头文件<functional>中的函数。

仿函数，就是在类中重载（）运算符，使得一个类表现得像一个函数。

C++中的sort函数由于用了模板编程，使得用处非常广泛，而且时间复杂度是O（n log n），效率也很高。

附上C++中sort的实现代码：

template<class _RanIt,
  class _Pr> inline
  void sort(_RanIt _First, _RanIt _Last, _Pr _Pred)
  { // order [_First, _Last), using _Pred
  _DEBUG_RANGE(_First, _Last);
  _DEBUG_POINTER(_Pred);
  _Sort(_Unchecked(_First), _Unchecked(_Last), _Last - _First, _Pred);
  }

    // TEMPLATE FUNCTION sort
template<class _RanIt> inline
  void sort(_RanIt _First, _RanIt _Last)
  { // order [_First, _Last), using operator<
  _STD sort(_First, _Last, less<>());
  }

可以看出，默认的比较函数就是less<>()

再附上其中_Sort函数的代码：

template<class _RanIt,
  class _Diff,
  class _Pr> inline
  void _Sort(_RanIt _First, _RanIt _Last, _Diff _Ideal, _Pr _Pred)
  { // order [_First, _Last), using _Pred
  _Diff _Count;
  for (; _ISORT_MAX < (_Count = _Last - _First) && 0 < _Ideal; )
    { // divide and conquer by quicksort
    pair<_RanIt, _RanIt> _Mid =
      _Unguarded_partition(_First, _Last, _Pred);
    _Ideal /= 2, _Ideal += _Ideal / 2;  // allow 1.5 log2(N) divisions

    if (_Mid.first - _First < _Last - _Mid.second)
      { // loop on second half
      _Sort(_First, _Mid.first, _Ideal, _Pred);
      _First = _Mid.second;
      }
    else
      { // loop on first half
      _Sort(_Mid.second, _Last, _Ideal, _Pred);
      _Last = _Mid.first;
      }
    }

  if (_ISORT_MAX < _Count)
    { // heap sort if too many divisions
    _STD make_heap(_First, _Last, _Pred);
    _STD sort_heap(_First, _Last, _Pred);
    }
  else if (1 < _Count)
    _Insertion_sort(_First, _Last, _Pred);  // small
  }