浅谈C/C++排序函数中cmp()比较函数的写法

个人总结：

1. sort中cmp的参数类型为值，返回类型为bool，比较过程用>和<，升序为a<b，降序为a>b

2. qsort中cmp的参数类型为const void*，返回类型为int，升序为a-b，降序为b-a

3. STL容器用sort排序

[cpp] view plain copy

print?

1. #include <cstdio>  
2. #include <cstdlib>  
3. #include <iostream>  
4. #include <vector>  
5. #include <algorithm>  
6. using namespace std;  
7. bool cmp(const int a, const int b) {  
8.     return a > b;  
9. }  
10. int main(int argc, char const *argv[]) {  
11.     int n;  
12.     while (scanf(“%d”, &n) != EOF) {  
13.         vector<int> a(n, 0);  
14.         for (int i = 0; i < n; ++i) {  
15.             cin >> a[i];  
16.         }  
17.         sort(a.begin(), a.end(), cmp);  
18.         // qsort((void*)a, a.size(), sizeof(int), cmp);  
19.         vector<int>::iterator iter = unique(a.begin(), a.end());  
20.         a.erase(iter, a.end());  
21.         for (int i = 0; i < a.size()-1; ++i) {  
22.             cout << a[i] << ” ”;  
23.         }  
24.         cout << a[a.size()-1] << endl;  
25.     }  
26.     return 0;  
27. }  

}

======================================================================================================================

原文地址：http://blog.csdn.net/lionel_d/article/details/41746135

首先，我们来谈谈大名鼎鼎的void qsort(void *base,int nelem,int width,int (*fcmp)(const void *,const void *));

它属于C语言标准库函数，应该是运用最多的了，今天我不是来教你们怎么用qsort的，只是来交流一下排序函数的最后一个参数cmp()（它不仅可以叫cmp，你还可以给他取名叫什么pig啊dog的只要是英文单词都可以，cmp只是人们对compare的一种常用缩写）比较函数的写法。

下面是cmp的写法：

[cpp] view plain copy

 print?

1. 
   int cmp(const void *a ,const void *b)  
2. 
   {  
3. 
       return (int )a - (int )b ;          //从小到大排序，把a，b位置反过来就是从大到小   
4. 
   }  

注意：qsort的cmp()函数千万别写成下面这样

[cpp] view plain copy

 print?

1. 
   //错错错错错错错 错错错错错错错 错错错错错错错 错错错错错错错   
2. 
   int cmp(const void *a ,const void *b)  
3. 
   {  
4. 
       return (int )a > (int )b ;       // > 与 < 都不行 ！      
5. 
   }  
6. 
   //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  

有一次就是写了下面的cmp(),结果排序死活不对！

下面是完整的测试代码：

[cpp] view plain copy

 print?

1. 
   #include <stdio.h>  
2. 
   #include <stdlib.h>  
3. 
     
4. 
   int cmp(const void *a ,const void *b)  
5. 
   {  
6. 
       return (int )a - (int )b ;      //从小到大排序，把a，b位置反过来就是从大到小   
7. 
   }  
8. 
   int main()  
9. 
   {  
10. 
        int a[10]={-1,9,5,7,-11,2,6,8,9,6};  
11. 
        qsort(a,10,sizeof(int),cmp);  
12. 
        for(int i = 0 ; i < 10 ; ++i)  
13. 
        {  
14. 
            printf(”%d ”,a[i]);  
15. 
        }  
16. 
        printf(”\n”) ;  
17. 
        return 0 ;  
18. 
    }  

测试结果：

第二个cmp(),就是void sort( iterator start, iterator end, StrictWeakOrdering cmp );下面是标准声明：

  template <class RandomAccessIterator, class Compare>  void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

他的头文件是<algorithm>，这个是标准C++头文件里的。

[cpp] view plain copy

 print?

1. bool cmp(int a ,int b)  
2. {  
3.     return a < b ;       //从小到大排序，把 < 换成 > 就是从大到小   
4. }  

好的，问题又来了，这个cmp与qsort的cmp不一样了，正好相反，他不能写成下面这样：

[cpp] view plain copy

 print?

1. //错错错错错错错 错错错错错错错 错错错错错错错 错错错错错错错   
2. bool cmp(int a ,int b)  
3. {  
4.     return a - b ;            
5. }  
6. //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  

切记，切记！

下面是sort的测试代码：

[cpp] view plain copy

 print?

1. #include <iostream>  
2. #include <algorithm>  
3.   
4. using namespace std ;  
5.   
6. bool cmp(int a ,int b)  
7. {  
8.     return a < b ;           //从小到大排序，把 < 换成 > 就是从大到小   
9. }  
10.   
11. int main()  
12. {  
13.     int a[10]={-1,9,5,7,-11,2,6,8,9,6};  
14.     sort(a,a+10,cmp);  
15.     for(int i = 0 ; i < 10 ; ++i)  
16.     {  
17.         cout<<a[i]<<” ” ;   
18.     }  
19.     cout<<endl ;   
20.     return 0 ;  
21. }  

测试结果：

在C++中，我们经常需要用到set，map等容器，他们的cmp基本写法都与sort的相同，当然set，map的cmp可不仅仅是函数了，而是函数对象：

[cpp] view plain copy

 print?

1. struct cmp{  
2.     bool operator ()(const int a , const int b)  
3.     {  
4.         return a < b ;           // 从小到大，反过来就是从大到小   
5.     }  
6. };  

下面仅仅对set做代码测试：

[cpp] view plain copy

 print?

1. 
   #include <iostream>  
2. 
   #include <cstring>  
3. 
   #include <set>  
4. 
     
5. 
   using namespace std ;  
6. 
     
7. 
   struct Person{  
8. 
       int age;  
9. 
       char name[20];  
10. 
        Person(int Age , const char Name[]):age(Age){strcpy(name,Name);}  
11. 
    };  
12. 
    struct cmp{  
13. 
        bool operator ()(const Person a , const Person b)  
14. 
        {  
15. 
            return a.age < b.age ;           //  从小到大 ;   
16. 
        }  
17. 
    };  
18. 
      
19. 
    int main()  
20. 
    {  
21. 
        set<Person,cmp> s ;  
22. 
        Person n1(46,”ggg”);  
23. 
        Person n2(-16,”fff”);           //年龄无负数，只是为了测试代码，下同   
24. 
        Person n3(45,”eee”);  
25. 
        Person n4(-25,”ddd”);  
26. 
        Person n5(34,”ccc”);  
27. 
        Person n6(22,”bbb”);  
28. 
        Person n7(2,”aaa”);  
29. 
        s.insert(n1);  
30. 
        s.insert(n2);  
31. 
        s.insert(n3);  
32. 
        s.insert(n4);  
33. 
        s.insert(n5);  
34. 
        s.insert(n6);  
35. 
        s.insert(n7);  
36. 
        set<Person,cmp>::iterator begin = s.begin();  
37. 
        set<Person,cmp>::iterator end = s.end();  
38. 
        for(set<Person,cmp>::iterator i = begin ; i != end ; ++i)  
39. 
        {  
40. 
            cout<<i->age<<” ”<<i->name<<endl ;  
41. 
        }  
42. 
        return 0 ;  
43. 
    }  

测试结果：

好的，废话也说了这么多了，那我们就来个总结吧:

在调用C的库函数qsort时，因为C语言没有明确的定义bool类型，只是笼统的说，零为假，任何非零都是真，而qsort的cmp函数是返回int的，通过<和>比较两个数据只能返回非零值(真)或零(假)，具体返回多少，得看编译器，据我猜测qsort内部是根据返回的正或负或0来判断两个数之间的大小或等于关系的，这时用<或>就不能正常排序了。

而在C++中，已经定义了bool类型，而且sort的cmp函数返回的是bool类型的，说明sort的判断方式与qsort不同的，需要返回一个布尔值，来判断两个数之间的关系的。

所以在C++中应该使用sort中t的cmp函数写法；

这篇文章纯属交流，有错请望指出！

ps：以上代码均在Dev C++ 5.4.1中实验。