摘要：C是一个比较底层的语言，没有提供高级语言的很多特性，如接口，泛型等，但我们要用C写一些通用的库却很需要这些机制。《代码大全》里说过：“我们不要在一门语言上编程，而要深入一门语言去编程”，就是说我们不要受语言的限制，可以加一些人为的约定来提高语言的表达能力，达到我们的目的。一个特定的排序程序
　　排序是一个很普通的任务，我们先随便用一个排序算法实现对一个int数组的排序，先定义一个compar_int函数用来比较两个int指针指向的类型，如果a比b大，则返回一个大于0的int值，如果a比b小，则返回一个小于0的int值，如果a和b相等，则返回0。
　　sort_int函数完整对int数组的排序，它需要3个参数，第一个参数是一个函数指针，该函数指针的签名（就是函数声明的参数及返回值的定义）和compar_int是一致的，第二个参数是一个int型指针，指向要排序的数组，第3个参数是要排序的数组元素个数。该函数的实现比较简单，对数组遍历n次，每次找到一个最小的数组元素放在数组的最左边，遍历完成后数组从左到右依次是从小达到排序了。
　　test_sort_int是一个单元测试函数，因为C语言的单元测试类库都比较复杂，咱们测试一个小程序就自己写测试代码验证就行了。声明一个int数组arr并初始化，调用sort_int进行排序后，然后用一个for循环打印出排序后的数组

  1. int compar_int(int *a, int *b){
  2.      return *a - *b;
  3. }
  4. void sort_int(int (*f)(int*, int*),int *arr,int n){
  5.      printf("sort_int\n");
  6.  
  7.      int temp = *arr;
  8.      int *p_i = arr;
  9.      int i = 0, j = 0;
  10.      for(i = 0; i < n; i++){
  11.          int *p_j = p_i;
  12.          for(j = i + 1; j < n; j++){
  13.              p_j++;
  14.              if(f(p_i, p_j) > 0){
  15.                  temp = *p_i;
  16.                  *p_i = *p_j;
  17.                  *p_j = temp;
  18.              }
  19.          }
  20.          p_i++;
  21.      }
  22. }
  23. void test_sort_int(){
  24.      int arr[] = {3, 2, 1, 5, 4};
  25.      sort_int(compar_int, arr, 5);
  26.      int i = 0;
  27.      for (i = 0; i < 5; i++){
  28.          printf("arr%d=%d\n", i, arr[i]);
  29.      }
  30. }
复制代码


单元测试结果如下

  1. sort_int
  2. arr0=1
  3. arr1=2
  4. arr2=3
  5. arr3=4
  6. arr4=5
复制代码

一个通用的排序程序
　　在.NET里实现排序，只要这个类型System.IComparable<T>，然后用System.Array.Sort<T>(T[] Array)方法就可以对其数组进行排序，这就是高级语言的优点，有接口，有泛型，类库的通用性很好，算法重用性很强，我们也想用C写一个通用的排序库（我们假设stdlib.h里没有定义qsort函数）。
　　我们知道在面向对象的语言里，委托和接口有时候是可以互相替换的，一个对象是否实现了一个接口，就是说一个对象是否支持这个接口定义的行为，委托也定义了一个行为，该行为可以由任何对象去实现，只要符合委托定义的参数和返回值就行。在C语言里没有强类型的委托，但有与之相对应的函数指针可以用，这个问题就解决了。
　　另外就是高级语言里的泛型可以更好的支持算法的重用，尤其一些容器类的实现，C语言里也没有，但C语言里的void指针可以指向任何类型，并可以在必要的时候做强制转换。很多人都说不要随便用void指针，我的观点是不要因噎废食，你要清楚你自己的目标是什么，你的目标是明确的，void指针只是你实现目标的工具而已，你把void指针的实现封装你对外暴露的接口之内，别人又看不到你使用了void指针，或者你注释里写清楚你提供的函数怎么用，我想使用者不会被迷惑的。既然c语言提供了这个机制，肯定有它的最佳使用场景，在.NET没有支持泛型之前，那些ArrayList,HashTable不也只支持一个通用的object参数吗，你取出对象的时候不也得照样强制转换吗，而且取出的是值类型的话，还得拆箱，C语言里把void*转换成具体类型指针连这个消耗都没有，为啥不用呀，难道为每一个类型写一个排序程序就比用void*实现一个通用的排序程序优雅了吗？我们要花大量的时间来提高代码的通用性，封装性，提供成熟的，稳定的，接口良好，说明准确的模块，而不是花时间去研究怎么刻意的不去用void指针，或者为每一种类型写一套类库。　　
　　好了，看下我们从sort_int演变而来的通用的sort函数：

  1. void copy(char *target, char *source, int len)
  2. {
  3.      while(len-- > 0)
  4.          *target++ = *source++;
  5. }
  6. void sort(int (*f)(void*, void*), void *arr, int n, int size)
  7. {
  8.      char temp[size];
  9.      char *p_i = arr;
  10.      int i = 0, j = 0;
  11.      for(i = 0; i < n; i++){
  12.          char *p_j = p_i;
  13.          for(j = i + 1; j < n; j++){
  14.              p_j+=size;
  15.              if((*f)(p_i, p_j) > 0){
  16.                  copy(temp, p_i, size);
  17.                  copy(p_i, p_j, size);
  18.                  copy(p_j, temp, size);
  19.              }
  20.          }
  21.          p_i+=size;
  22.      }
  23. }
复制代码


　　可以看到，从代码的结构上来看，sort和sort_int差不多，逻辑都是一样的，只不过是把int *换成了void *，增加一个int类型的size参数的原因是我们不知道void指针到底是个指向什么类型的指针，不知道类型，就不知道它占用的字节数，而指针的算术运算需要根据指向类型占用的字节数来计算偏移量，因此我们不能对它进行算术运算。但我们把void *转换成char *后就可以进行算术运算了，char类型占用一个字节（一般情况下），并且我们通过size参数知道了void *指向的类型的宽度，那么我们让char *加上一个size长度的偏移量，就相当于void *指针指向的数组向后移动了一个元素，这样我们就可以遍历void *指向的原始数组了。
　　另外这里还引入了一个copy子函数，因为不知道void *指向的类型，所以我们声明了一个char temp[size]的变量，正好能放下一个这种类型的对象，我们不管它是什么类型，我们只关心它有多大，然后copy函数是用来从一个char*的地址（由void*强制转换得来，代表要排序数组的一个元素）往另一个char*的地址（我们刚刚声明的temp）复制N个char宽度（1字节）的内存，这样其实就实现了一个类似赋值的过程。测试我们通用排序程序
　　我们先测试一个double类型数组，首先我们要定义 一个compar_double的函数来比较两个double类型谁大谁小，是否相等，这相当于.NET里的IComparable的成员方法。

  1. int compar_double(void *a, void *b){
  2.     double diff = *(double*)a - *(double*)b;
  3.     if(fabs(diff) < 0.00005)
  4.         return 0;
  5.     else if(diff > 0.0)
  6.         return 1;
  7.     else
  8.         return -1;
  9. }
复制代码


　　我们都知道double类型是不能直接比较的，由于精度的问题，要想比较两个double对象是否相等，要把它们的差取绝对值后看是否小于某个特别小的浮点数，如果小于的话，我们就假设它们在这个要求的精度上是相等的。注意fabs要include <math.h>。测试代码也很好写，声明一个double数组arr并初始化，调用sort函数，第一个参数传递刚刚定义的compar_double函数，最后一个参数传递sizeof(double)。

  1. void test_sort_double(){
  2.      printf("sort_double\n");
  3.      double arr[] = {3.2,2.4,1.3,5.1,4.7};
  4.      sort(compar_double, arr, 5, sizeof(double));
  5.      int i = 0;
  6.      for (i = 0; i < 5; i++){
  7.          printf("arr%d=%.2f\n",i, arr[i]);
  8.      }
  9. }
复制代码


执行结果符合预期，如下

  1. sort_double
  2. arr0=1.30
  3. arr1=2.40
  4. arr2=3.20
  5. arr3=4.70
  6. arr4=5.10
复制代码

对指针数组的排序
　　刚才对一个double的数组进行了排序，在排序的过程中要对数组的元素进行实际的位置交换，交换的话就要涉及内存的拷贝，拷贝一个double对象就要拷贝sizeof(double)个字节，咱这个算法又是一个复杂度很高的函数，O(n*n)吧应该是，所以这样算起来效率更低了，如果对一个很大的结构对象进行拷贝，那影响更大了，所以我们如果对一个大对象数组进行排序的话，可以把一个一个的大对象的指针搞成一个指针数组，对指针数组进行排序，那拷贝就只是一个指针的大小，指针应该很小，32位机器就是始终4个字节。
　　比如我们要对一个字符串数组进行排序吧，注意是字符串数组，不是字符数组，每个字符串是一个字符数组，多个字符串构成一个字符串数组，但我们最终的数组的元素只是一个个指向字符串（字符数组）的指针。我们在设计compar_string的时候，就应该知道void *a是一个指向指针的指针，我们先把a转换成一个指向指针的指针(char**)a，然后再对其进行*取值，这样就得到了具体的字符串的指针，也就是一个char*了，然后对char*比较，库函数里有现成的，就是strcmp,我们直接调用它来完成对字符串比较。strcmp需要include <string.h>。

  1. int compar_string(void *a, void *b){
  2.      return strcmp(*(char**)a, *(char**)b);
  3. }
复制代码


　　相应的测试程序和上面的差不多，只不过要arr的类型是一个指针数组，声明字符串数组很简单，因为字符串本身就是字符数组，字符数组名字本身就是一个指针常量，所以初始化arr就写的比较直观了，不用大括号套着大括号了，如下。

  1. void test_sort_string(){
  2.      printf("sort_string\n");
  3.      char *arr[] = {
  4.          "lilei",
  5.          "han×××",
  6.          "jim",
  7.          "poly",
  8.          "miss gao"
  9.      };
  10.      sort(compar_string, arr, 5, sizeof(char *));
  11.      char **arr_p = arr;
  12.      int i = 0;
  13.      for (i = 0; i < 5; i++){
  14.          printf("arr%d=%s\n",i, *arr_p++);
  15.      }
  16. }
复制代码


　　值得注意的一点是arr虽然是指针数组，是一个数组名，数组名又代表一个指针，但却是一个指针常量，不能对其进行自增操作，所以我们得声明 一个指向指针的指针char **arr_p来指向arr，然后才能遍历指针数组并打印它的值。测试结果如下

  1. sort_string
  2. arr0=han×××
  3. arr1=jim
  4. arr2=lilei
  5. arr3=miss gao
  6. arr4=poly
复制代码

小节
　　用C语言实现泛型（模板）除了用指针外还可以使用宏，但宏理解起来更麻烦，调试也麻烦，还不如耗点儿性能用指针强制转换呢。我是一个C的新手，可能在帖子里有一些幼稚的错误，欢迎大家多多指点，我是写了半天程序了，才知道类库里有一个qsort函数和我想要实现的函数几乎一样，参数的类型个数都一样，真巧了，热。