如何在C语言中实现简单的泛型编程

题外话

              鄙人最近在家里听斯坦福大学的开放课程——《编程范式Programming Paradigms》。

附上veryCD的资源下载地址：

http://www.verycd.com/topics/2838268/

        这个是英文授课，现在还是没有中文或英文字幕的。就课程来说非常不错。其中Lecture 4中讲到了一种在C语言中不用C++中的template实现泛型编程的方法。我在这里总结了它的笔记后，加入了我自己的一些思考和试验写下了这篇文章分享一些经验给大家。

正题

        泛型编程让你编写完全一般化并可重复使用的算法，其效率与针对某特定数据类型而设计的算法相同。所谓泛型(Genericity)，是指具有在多种数据类型上皆可操作的含意。C++通过参数化类型来实现通用的容器。如Java则引入了单根继承的概念。比泛型更加让你熟悉的可能就是STL，Standard template library,标准模板库。STL是一种高效、泛型、可交互操作的软件组件。STL以迭代器 (Iterators)和容器(Containers)为基础，是一种泛型算法(Generic Algorithms)库，容器的存在使这些算法有东西可以操作。STL包含各种泛型算法(algorithms)、泛型指针（iterators）、泛型容器(containers)以及函数对象(function objects)。STL并非只是一些有用组件的集合，它是描述软件组件抽象需求条件的一个正规而有条理的架构。

        而在C语言中，同样也可以通过一些手段实现这样的泛型编程。如通过宏。这里讲的是另一种方法——通过无类型指针void*。

        看下面的一个实现交换两个元素内容的函数swap，以整型int为例。

[cpp:nogutter] view plaincopyprint?

1. void swap(int* i1,int* i2){  
2.          int temp;  
3.          temp=*i1;  
4.          *i1=*i2;  
5.          *i2=temp;  
6. }  

void swap(int* i1,int* i2){ int temp; temp=*i1; *i1=*i2; *i2=temp;} 

当你想交换两个char类型时，你还得重写一个参数类型为char的函数，你会多么想念C++中使用模板。等一下，是不是能用无类型的指针来作为参数呢？看如下改动：

[cpp:nogutter] view plaincopyprint?

1. void swap(void *vp1,void *vp2){  
2.        void temp=*vp1;  
3.        *vp1=*vp2;  
4.        *vp2=temp;  
5. }  

void swap(void *vp1,void *vp2){ void temp=*vp1; *vp1=*vp2; *vp2=temp;} 

这段代码是错误的，是通不过编译的。首先，变量是不能声明为void无类型的。而你不知道调用此函数传进的参数是什么类型的，无法确定一种类型的声明。同时，不能将*用在无类型指针上，因为系统没有此地址指向对象大小的信息。在编译阶段，编译器无法得知传入此函数参数的类型的。这里要想实现泛型的函数，需要在调用的地方传入相关要交换的对象的地址空间大小size，同时利用在头文件string.h中定义的memcpy（）函数来实现。改动如下：

[cpp:nogutter] view plaincopyprint?

1. void swap(void *vp1,void *vp2,int size){  
2.       char buffer[size];/*注意此处gcc编译器是允许这样声明的，而我印象中VC编译器是不可以的。*/  
3.       memcpy(buffer,vp1,size);  
4.       memcpy(vp1,vp2,size);  
5.       memcpy(vp2,buffer,size);  
6. }  

void swap(void *vp1,void *vp2,int size){ char buffer[size];/*注意此处gcc编译器是允许这样声明的，而我印象中VC编译器是不可以的。*/ memcpy(buffer,vp1,size); memcpy(vp1,vp2,size); memcpy(vp2,buffer,size);} 

函数memcpy()

原型：void* memcpy(void *dest,void *src,unsigned int n)

作用：由src所指内存区域复制n个字节到dest所指内存区域。

说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针。

之所以将buffer声明为char类型，只是因为char类型的大小是1字节，这样声明可以为buffer指向的空间分配size字节大小的空间。

在调用这个函数时，可以像如下这样调用（同样适用于其它类型的x、y）：

[cpp:nogutter] view plaincopyprint?

1. int x=27,y=2;  
2. swap(&x,&y,sizeof(int));  

int x=27,y=2;swap(&x,&y,sizeof(int)); 

其实，你会发现，这样的调用也是没有报错的：

[cpp:nogutter] view plaincopyprint?

1. int i=44;  
2. short s=5;  
3. swap(&i,&s,sizeof(short));  

int i=44;short s=5;swap(&i,&s,sizeof(short)); 

两个不同类型的变量同样也可以实现交换。而根据系统的不同，即是小端法还是大端法保存数据，显示的结果是不同的。以Windows或linux下更常见的小端法为例，函数swap将整型i的低16位和短整型的16位进行了交换。

这样的调用是可行的，也提醒我们C语言下这样实现泛型编程是不安全的，编译器只进行有限的检查，更多的需要程序员的细心。如下的调用是可以的，但却毫无意义：

 

 

[cpp:nogutter] view plaincopyprint?

1. int i=22;  
2. short s=11;  
3. swap(&i,&s,8);  

int i=22;short s=11;swap(&i,&s,8); 

调用此函数，将交换i的地址向后8字节的内容与s的地址后8字节的内容的交换，而对于大小为2字节的short类型的s，大小为4字节的int类型的i这样的操作一般情况下是没有意义的。在编程时也要注意这个。C语言为我们提供了许多接近机器底层的操作，但也是一把双刃剑。

下面看这样的调用：

[cpp:nogutter] view plaincopyprint?

1. char *husband=strdup("Fred");  
2. char *wife=strdup("Linda");  
3. swap(&husband,&wife,sizeof(char*));  

char *husband=strdup("Fred");char *wife=strdup("Linda");swap(&husband,&wife,sizeof(char*)); 

函数strdup():原型：char* strdup（char* s）。作用是复制字符串。

husband与wife是两个字符串，在交换这样的类型时，不能直接将两个字符串的地址传入swap函数，因为两个字符串的大小是不一定的，进行复制肯定会出现错误。这里是将保存两个字符串首地址的指针的地址进行交换，使两个指针指向对方的字符串，实现字符串的交换。sizeof()中写成 char**也是可以的，写成double*也是可以的，因为所有指针的大小都是4字节。但写成char*，更加明确，在别人读代码会引起更少的误解，因为husband与wife是char类型的一级指针。

 

下面看另一种功能的函数：

[cpp:nogutter] view plaincopyprint?

1. int lsearch(int key,int array[],int size){  
2.       for(int i=0;i<size;++i)  
3.                   if(array[i]==key)  
4.                            return i;  
5.      return -1;  
6. }  

int lsearch(int key,int array[],int size){ for(int i=0;i<size;++i) if(array[i]==key) return i; return -1;} 

此函数在数组array中查找key元素，找到后返回它的索引，找不到返回-1.如上，也可以实现泛型的函数：

[cpp:nogutter] view plaincopyprint?

1. void* lsearch(void* key,void *base,int n,int elemSize){  
2.          for(int i=0;i<n;++i){  
3.                     void *elemAddr=(char *)base+i*elemSize;/*重点，认真看这行代码*/  
4.                    if(memcmp(key,elemAddr,elemSize)==0)  
5.                                   return elemAddr;  
6.           return NULL;  
7.           }  
8. }  

void* lsearch(void* key,void *base,int n,int elemSize){ for(int i=0;i<n;++i){ void *elemAddr=(char *)base+i*elemSize;/*重点，认真看这行代码*/ if(memcmp(key,elemAddr,elemSize)==0) return elemAddr; return NULL; }} 

代码第三行：将数组的首地址强制转换为指向char类型的指针，是利用char类型大小为1字节的特性，使elemAddr指向此”泛型“数组的第 i-1个元素的首地址。因为之前已经说过，此时你并不知道你传入的是什么类型的数据，系统无法确定此数组一个元素有多长，跳向下个元素需要多少字节，所以强制转换为指向char的指针，再加上参数传入的元素大小信息和累加数i的乘积，即偏移地址，即可得此数组第i-1个元素的首地址。这样使无论传入的参数是指向什么类型的指针，都可以得到指向正确元素的指针，实现泛型编程。

函数memcmp(),原型：int memcmp(void *dest,const void *src,int n)，比较两段长度为n首地址分别为dest、src的地址空间中的内容。

此函数在数组base中查找key元素，找到则返回它的地址信息，找不到则返回NULL。

如果使用函数指针，则可以实现其行为的泛型：

[cpp:nogutter] view plaincopyprint?

1. void *lsearch(void *key,void *base,int n,int elemSize,int(*cmpfn)(void*,void*,int)){  
2.          for(int i=0;i<n;++i){  
3.                     void *elemAddr=(char *)base+i*elemSize;  
4.                    if(cmpfn(key,elemAddr,elemSize)==0)  
5.                                   return elemAddr;  
6.           return NULL;  
7.           }  
8. }  
9. }  

void *lsearch(void *key,void *base,int n,int elemSize,int(*cmpfn)(void*,void*,int)){ for(int i=0;i<n;++i){ void *elemAddr=(char *)base+i*elemSize; if(cmpfn(key,elemAddr,elemSize)==0) return elemAddr; return NULL; }}} 

在调用时，可以将指向不同行为的形式相同的函数的指针传入此函数，以实现lsearch函数行为的不同。

函数指针：

返回类型 (*函数指针名)(形参表)

 

        综上，C语言也可以实现一定的泛型编程，但这样是不安全的，系统对其只有有限的检查。在编程时一定要多加细心。

题外话

今天听了《编程范式》的Lecture 5,继续上一篇的主题，用C语言实现简单的泛型编程，收个尾。

正题

回忆上一篇的最后一个函数：

[cpp:nogutter] view plaincopyprint?

1. void* lsearch(void* key,void* base,int n,int elemSize,int (*cmpfn)(void*,void*)){  
2.        for(int i=0;i<n;++i){  
3.                  void* elemAddr=(char *)base+i*elemSize;  
4.                  if(cmpfn(key,elemAddr)==0)  
5.                             return elemAddr;  
6.        }  
7.        return NULL;  
8. }  

void* lsearch(void* key,void* base,int n,int elemSize,int (*cmpfn)(void*,void*)){ for(int i=0;i<n;++i){ void* elemAddr=(char *)base+i*elemSize; if(cmpfn(key,elemAddr)==0) return elemAddr; } return NULL;} 

再定义一个要调用的函数：

[cpp:nogutter] view plaincopyprint?

1. int intCmp(void* elem1,void* elem2){  
2.         int* ip1=elem1;  
3.         int* ip2=elem2;  
4.         return *ip1-*ip2;  
5. }  

int intCmp(void* elem1,void* elem2){ int* ip1=elem1; int* ip2=elem2; return *ip1-*ip2;} 

看如下调用：

[cpp:nogutter] view plaincopyprint?

1. int array[]={1,2,3,4,5,6};  
2. int size=6;  
3. int number=3;  
4. int *found=lsearch(&number,array,size,sizeof(int),intCmp);  
5. if(found==NULL)  
6.           printf("-_-||");  
7. else  
8.          printf("^_^");  

int array[]={1,2,3,4,5,6};int size=6;int number=3;int *found=lsearch(&number,array,size,sizeof(int),intCmp);if(found==NULL) printf("-_-||");else printf("^_^"); 

若是一个C风格字符串，比如如下：

[cpp:nogutter] view plaincopyprint?

1. char *names[]={"Marvin","Marcus","Skyline","Forward"};  
2. char *favorName="Skyline";  
3. char **found=lsearch(&favorName,names,4,sizeof(char *),StrCmp);/*StrCmp函数将在下面定义。注意大写，因为在String.h中有strcmp()这个函数*/  

char *names[]={"Marvin","Marcus","Skyline","Forward"};char *favorName="Skyline";char **found=lsearch(&favorName,names,4,sizeof(char *),StrCmp);/*StrCmp函数将在下面定义。注意大写，因为在String.h中有strcmp()这个函数*/ 

注意names数组是保存指向字符串首地址指针的数组。其中的字符串保存在文字常量区。

C语言中的内存区域划分：

栈区（Stack）：由编译器自动分配、释放，存放函数参数值、局部变量的值等；

堆区（Heap）：一般由程序员分配、释放，若不释放，有可能被OS回收；

全局区（静态区）（Static）：全局变量和静态变量在这里存储。初始化的在一块，未初始化的在相邻的另一块。程序结束后由系统释放。

文字常量区：常量、字符串在这里储存。由系统释放。

程序代码区：存放函数体的二进制代码。

注意由于names数组存的是指向各字符串的地址，所以found为二级指针，以得到字符串。注意lsearch参数表中的favorName前的&，不能丢掉。

StrCmp()函数的定义：

[cpp:nogutter] view plaincopyprint?

1. int StrCmp(void* vp1,void* vp2){  
2.       char *s1=*(char **)vp1;//Attention!  
3.       char *s2=*(char **)vp2;//Attention!  
4.       return strcmp(s1,s2);  
5. }  

int StrCmp(void* vp1,void* vp2){ char *s1=*(char **)vp1;//Attention! char *s2=*(char **)vp2;//Attention! return strcmp(s1,s2);} 

注意第二第三行。C语言是强类型的语言。如果没有*(char**)，系统将不清楚vp1、vp2是指向什么类型的指针，编译系统将报错：void value not ignored as it ought to be.而lsearch函数中将传入的是指向指向字符串首地址的指针的指针，即二级指针，即char**类型，将其解引用，得到指向目标字符串首地址的指针，赋给s1指针，s2同理。然后返回调用系统函数strcmp()比较两个字符串s1、s2的结果。