用C语言实现程序的多态性

多态 (polymorphism) 一词最初来源于希腊语 polumorphos，含义是具有多种形式或形态的情形。在程序设计领域，一个广泛认可的定义是“一种将不同的特殊行为和单个泛化记号相关联的能力”。然而在人们的直观感觉中，多态的含义大约等同于“同一个方法对于不同类型的输入参数均能做出正确的处理过程，并给出人们所期望获得的结果”，也许这正体现了人们对于多态性所能达到的效果所寄予的期望：使程序能够做到越来越智能化，越来越易于使用，越来越能够使设计者透过形形色色的表象看到代码所要触及到的问题本质。

作为读者的你或许对于面向对象编程已有着精深的见解，或许对于多态的方便与神奇你也有了深入的认识。这时候你讶异的开始质疑了：“多态，那是面向对象编程才有的技术，C 语言是面向过程的啊！”而我想说的是，C 语言作为一种编程语言，也许并不是为了面向对象编程而设计，但这并不意味着它不能实现面向对象编程所能实现的功能，就比如说，多态性。

在本文中我们使用一个简单的单链表作为例子，展示 C 语言是如何体现多态性的。


结构体：不得不说的故事

许多从写 C 代码开始，逐渐走向 C++ 的程序员都知道，其实 C++ 里面的 class，其前身正是 C 语言中的 structure。很多基于 C 语言背景介绍 C++ 的书籍，在介绍到 class 这一章的时候都会向读者清晰地展示，一个 C 语言里的 structure 是怎样逐渐变成一个典型的 C++ class 的，甚至最后得出结论：“structure 就是一个所有成员都公有的类”，当然了，class 还是 class，不能简单的把它看做一个复杂化了的 structure 而已。

下面我们来看看在 C 语言中定义一个简单的存储整型数据的单链表节点是怎么做的，当然是用结构体。大部分人会像我一样，在 linkList.h 文件里定义：

1. typedef struct Node* linkList;
   
2. struct Node                                       // 链表节点
   
3. {
   
4.     int data;                                 // 存储的整型数据
   
5.     linkList next;                            // 指向下一个链表节点
   
6. };

链表有了，下面就是你想要实现的一些链表的功能，当然是定义成函数。我们只举几个常用功能：

1. linkList initialLinklist();                               // 初始化链表
   
2. void insertFirst(linkList h,int data);              // 在已有链表的表头进行插入节点操作
   
3. void linkListOutput(linkList h);                           // 输出链表中数据到控制台

这些都是再自然不过的 C 语言的编程过程，然后我们就可以在 linkList.c 文件中实现上述两个函数，继而在 main.c 中调用它们了。

然而上面我们定义的链表还只能对整型数据进行操作。如果下次你要用到一个存储字符串类型的链表，就只好把上面的过程重新来过。也许你觉得这个在原有代码基础上做略微修改的过程并不复杂，可是也许我们会不断的增加对于链表这个数据结构的操作，而需要用链表来存储的数据类型也越来越多，这些都意味着海量的代码和繁琐的后期维护工作。当你有了上百个存储不同数据类型的链表结构，每当你要增加一个操作，或者修改某个操作的传入参数，工作量会变大到像一场灾难。

但是我们可以改造上述代码，让它能够处理你所想要让它处理的任何数据类型：实行，字符型，乃至任何你自己定义的 structure 类型。


void *：万能的指针“挂钩”

几乎所有讲授 C 语言课程的老师都会告诉你：“指针是整个 C 语言的精髓所在。”而你也一直敬畏着指针，又爱又恨地使用着它。许多教材都告诉你，int * 叫做指向整型的指针，而 char * 是指向字符型的指针，等等等等不一而足。然而这里有一个另类的指针家族成员—— void *。不要按照通常的命名方式叫它做指向 void 类型的指针，它的正式的名字叫做：可以指向任意类型的指针。你一定注意到了“任意类型”这四个字，没错，实现多态，我们靠的就是它。

下面来改造我们的链表代码，在 linkList.h 里：

1. typedef struct Node* linkList;
   
2. struct Node                                       // 链表节点
   
3. {
   
4.     void *data;                               // 存储的数据指针
   
5.     linkList next;                            // 指向下一个链表节点
   
6. };
   
7. 
   
8. linkList initialLinklist();                             // 初始化链表
   
9. void insertFirst(linkList h, void *data);         // 在已有链表的表头进行插入节点操作
   
10. void linkListOutput(linkList h);                         // 输出链表中数据到控制台

我们来看看现在这个链表和刚才那个只能存储整型数据的链表的区别。

当你把 Node 结构体里面的成员定义为一个整型数据，就好像把这个链表节点打造成了一个大小形状固定的盒子，你定义一个链表节点，程序进行编译的时候编译器就为你打造一个这样的盒子：装一个 int 类型的数据，然后装一个 linkList 类型的指针。如果你想强行在这个盒子里装别的东西，编译器会告诉你，对不起，盒子的大小形状并不合适。所以你必须为了装各种各样类型的数据打造出不同的生产盒子的流水线，想要装哪种类型数据的盒子，就开启对应的流水线来生产。

但是当你把结构体成员定义为 void *，一切都变得不同了。这时的链表节点不再像个大小形状固定的盒子，而更像一个挂钩，它可以挂上一个任意类型的数据。不管你需要存储什么类型的数据，你只要传递一个指针，把它存储到 Node 节点中去，就相当于把这个数据“挂”了上去，无论何时你都可以根据指针找到它。这时的链表仿佛变成了一排粘贴在墙上的衣帽钩，你可以挂一排大衣，可以挂一排帽子，可以挂一排围巾，甚至，你可以并排挂一件大衣一顶帽子一条围巾在墙上。void * 初露狰狞，多态离 C 语言并不遥远。

函数指针：知道我能做什么

在结构体里添加函数指针，目的在于告诉每一个使用这个结构体的人，这个结构体在设计的时候是为了支持哪些操作。当我们的链表定义变成如下这样的形式：

1. typedef struct Node* linkList;
   
2. struct Node                                         // 链表节点
   
3. {
   
4.     void *data;                                 // 存储的数据指针
   
5.     linkList next;                              // 指向下一个链表节点
   
6. 
   
7.     void (*insertFirst)(linkList, void *);      // 在已有链表的表头进行插入节点操作的函数指针
   
8.     void (*linkListOutput)(linkList);           // 输出链表中数据到控制台操作的函数指针
   
9. };

也许你的心里也在暗暗觉得，是的，真的很像一个 class 了。当然，即使是加入了函数指针，也并不能让这个结构体和一个 C++ 中的类等同起来。因为无论如何函数指针能够调用到的函数也必须在结构体外定义，并且要保证在使用结构体的时候这些函数可以被调用。所以实际上这些函数并不是我们的链表专用的一些方法，只要在有效范围内，使用了正确的参数，任何时候都可以调用这些函数。

观察上面的链表定义中的两个函数指针，其中用来插入节点的操作 insertFirst 对于任何类型的链表来说都是一样的，但是对于输出的操作 linkListOutput 则完全不是那么回事了。通常，对于不同类型的链表，它的输出操作当然也不同，这就需要程序员在使用的时候自己清楚在什么情况下需要传给链表结构体怎样的输出函数。在本例当中，我们在链表初始化的时候给它传入固定的插入函数和一个默认情况下的输出函数，这个输出函数的作用是在程序员未指定任何输出函数的时候提醒程序员，你还没有指定一个与你的链表匹配的输出函数。

在 linkList.h 当中，我给出了 4 种对于基本类型的输出函数，当然对于其它类型，也都可以指定相应的输出函数。


实现：你的多态你做主

当你真正开始着手做这个工作的时候，你会发现把数据放入链表中的操作和普通的存放 int 类型的链表的实现并没有什么大的区别，很方便。但是当你要把已经存进去的数据读取出来的时候，就有一点麻烦了。对于 void * 类型的指针，编译器只知道它里面存储了一个地址，但是关于这个地址里的数据类型，编译器是没有任何概念的。毕竟我们不能指望编译器什么都知道，什么都能替你做好，所以存进去的数据的类型，作为程序员的我们必须清楚的知道，并且在取出这个数据的时候，用这一类型的指针来对 void * 做强制类型转换。

为了方便的做到这一点，我采取的方法是在 Node 结构体中增加一个标识数据类型的域，并用一个枚举类型来存放这些数据类型。这时的 linkList.h 如下所示：

1. #ifndef LINKLIST_H
   
2. #define LINKLIST_H
   
3. 
   
4. typedef struct Node* linkList;
   
5. 
   
6. struct Node                                         // 链表节点
   
7. {
   
8.     void *data;                                 // 存储的数据指针
   
9.     linkList next;                              // 指向下一个链表节点
   
10. 
    
11.     void (*insertFirst)(linkList, void *);      // 在已有链表的表头进行插入节点操作的函数指针
    
12.     void (*linkListOutput)(linkList);           // 输出链表中数据到控制台操作的函数指针
    
13. };
    
14. 
    
15. linkList initialLinklist();                          // 初始化链表
    
16. void insertFirst(linkList h, void *data);            // 在已有链表的表头进行插入节点操作
    
17. void linkListOutput(linkList h);                     // 未指定输出类型时的默认输出函数
    
18. void stringLinkListOutput(linkList h);               // 输出字符串类型链表中数据到控制台
    
19. void intLinkListOutput(linkList h);                      // 输出整型链表中数据到控制台
    
20. void doubleLinkListOutput(linkList h);                      // 输出浮点型链表中数据到控制台
    
21. void charLinkListOutput(linkList h);                      // 输出字符型链表中数据到控制台
    
22. 
    
23. #endif

初始化链表，代码如下：

1. linkList initialLinklist()
   
2. {
   
3.     linkList link = (linkList*)malloc(sizeof(*link));
   
4.     link->data = NULL;
   
5.     link->next = NULL;
   
6. 
   
7.     link->insertFirst = insertFirst;
   
8.     link->linkListOutput = linkListOutput;
   
9. 
   
10.     return link;
    
11. }

在已有链表的表头进行插入节点操作 , 代码如下：

1. void insertFirst(linkList h, void *data)
   
2. {
   
3.     linkList link = initialLinklist();
   
4.     link->data = data;
   
5.     link->next = h->next;
   
6.     h->next = link;
   
7. }

输出链表中数据到控制台，代码如下：

1. void linkListOutput(linkList h)     
   
2. {
   
3.   printf("You should point which output function is wanted!\n");
   
4. }
   
5. 
   
6. void stringLinkListOutput(linkList h)   
   
7. {
   
8.   linkList p = h->next;
   
9.   while(p)
   
10.   {
    
11.     printf("%s\t", (char*)(p->data));
    
12.     p = p->next;
    
13.   }
    
14.   printf("\n");
    
15. }
    
16. 
    
17. void intLinkListOutput(linkList h)
    
18. {
    
19.   linkList p = h->next;
    
20.   while(p)
    
21.   {
    
22.     printf("%d\t", *(int*)(p->data));
    
23.     p = p->next;
    
24.   }
    
25.   printf("\n");
    
26. }
    
27. 
    
28. void doubleLinkListOutput(linkList h)
    
29. {
    
30.   linkList p = h->next;
    
31.   while(p)
    
32.   {
    
33.     printf("%f\t", *(double*)(p->data));
    
34.     p = p->next;
    
35.   }
    
36.   printf("\n");
    
37. }
    
38. 
    
39. void charLinkListOutput(linkList h)
    
40. {
    
41.    linkList p = h->next;
    
42.    while(p)
    
43.    {
    
44.      printf("%c\t", *(char*)(p->data));
    
45.      p = p->next;
    
46.    }
    
47.    printf("\n");
    
48. }

小结

通过上面这个链表的小例子，大家可能已经看到了 C 语言的灵活性。这段代码虽然短并且功能简单，但是已经实现了多态性。这篇文章的本意并不在于想要告诉大家用 C 实现多态的方法，而多态的含义也无疑是更加广泛的。这篇文章的初衷其实是基于这样一点认识：面向对象是一种程序设计思想，而 C 语言则是一种编程语言。也许它并不是专门为了面向对象编程而设计，但是这绝不意味着它不能实现面向对象的程序设计。当然以上所展示的这几个操作，如果是用别的编程语言，可能只要寥寥几行就可以完成，但是 C 语言想告诉我们的是：也许我不擅长，但是并不意味着我做不到。