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

kenson · 发表于 2016-6-19 22:35

本帖最后由 kenson 于 2016-6-19 22:36 编辑

多态 (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 文件里定义：

typedef struct Node* linkList;
struct Node                                     // 链表节点
{
int data;                               // 存储的整型数据
linkList next;                         // 指向下一个链表节点
};
链表有了，下面就是你想要实现的一些链表的功能，当然是定义成函数。我们只举几个常用功能：

linkList initialLinklist();                            // 初始化链表
link newLinkList (int data);                      // 建立新节点
void insertFirst(linkList h,int data);             // 在已有链表的表头进行插入节点操作
void linkListOutput(linkList h);                         // 输出链表中数据到控制台
这些都是再自然不过的 C 语言的编程过程，然后我们就可以在 linkList.c 文件中实现上述两个函数，继而在 main.c 中调用它们了。

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

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

回页首

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

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

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

typedef struct Node* linkList;
struct Node                                     // 链表节点
{
void *data;                            // 存储的数据指针
linkList next;                         // 指向下一个链表节点
};

linkList initialLinklist();                            // 初始化链表
link newLinkList (void *data);                   // 建立新节点
void insertFirst(linkList h, void *data);       // 在已有链表的表头进行插入节点操作
void linkListOutput(linkList h);                      // 输出链表中数据到控制台
我们来看看现在这个链表和刚才那个只能存储整型数据的链表的区别。

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

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

回页首

实现：你的多态你做主

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

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

#ifndef LINKLIST_H
#define LINKLIST_H

typedef struct Node* linkList;

enum dataType
{
INT,
DOUBLE,
CHAR,
STRING
};

struct Node                                              // 链表节点
{
void *data;                                     // 存储的数据指针
int dataType;                                  // 存储数据类型
linkList next;                                  // 指向下一个链表节点
};

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

#endif
初始化链表，代码如下：

linkList initialLinklist()
{
linkList link = (linkList*)malloc(sizeof(*link));
link->data = NULL;
link->dataType = -1;
link->next = NULL;

return link;
}
建立新节点，代码如下：

linkList newLinkList (void *data, int dataType)
{
linkList link = (linkList*)malloc(sizeof(*link));
link->data = data;
link->dataType = dataType;
link->next = NULL;

return link;
}
在已有链表的表头进行插入节点操作，代码如下：

void insertFirst(linkList h, void *data, int dataType)
{
linkList l = newLinkList(data, dataType);
l->next = h->next;
h->next = l;
}
输出链表中数据到控制台，代码如下：

void linkListOutput(linkList h)
{
linkList p = h;

p = p->next;
while(p != NULL)
{
   switch(p->dataType)
{
   case 0:
   {
      printf("%4d", *(int*)(p->data));
      break;
   }
   case 1:
   {
      printf("%4f", *(double*)(p->data));
      break;
   }
   case 2:
   {
      printf("%4c", *(char*)(p->data));
      break;
   }
   case 3:
   {
      printf("%s ", (char*)(p->data));
      break;
   }
}
p = p->next;
  }
printf("/n");
}
回页首

小结

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

zhixiaoyuhong · 发表于 2016-6-20 16:49

C语言也就因为有这灵活性，所以才可以开发linux内核这种大型项目吧。。。

kenson · 发表于 2016-6-22 12:05

补充一下多态的应用方法

多态，对象根据所接收的消息而做出动作。同一消息为不同的对象接受时可产生完全不同的行动，这种现象称为多态性。利用多态性用户可发送一个通用的信息，而将所有的实现细节都留给接受消息的对象自行决定，如是，同一消息即可调用不同的方法。例如：RT-Thread系统中的设备：抽象设备具备接口统一的读写接口。串口是设备的一种，也应支持设备的读写。但串口的读写操作是串口所特有的，不应和其他设备操作完全相同，例如操作串口的操作不应应用于SD卡设备中。多态性的实现受到继承性的支持，利用类继承的层次关系，把具有通用功能的协议存放在类层次中尽可能高的地方，而将实现这一功能的不同方法置于较低层次，这样，在这些低层次上生成的对象就能给通用消息以不同的响应。RT-Thread对象模型采用结构封装中使用函数指针的形式达到面向对象中多态的效果。具体代码片段如下:
#include <stdio.h>
#include <stdlib.h>
//抽象父类
struct parent_class
{
      int a;
      void (*vfunc)(struct parent_class *,int a);
};
//抽象父类的方法
void parent_class_vfunc(struct parent_class *parent_self_ptr,int a)
{
      //调用对象自己本身的虚拟函数
      printf("parent_class_vfunc\n");
      parent_self_ptr->vfunc(parent_self_ptr,a);
}
//子类继承parent_class
struct child_class1
{
      struct parent_class parent;
      int b;
};
//子类虚拟函数实现
void child1_class_vfunc(struct child_class1 *child1_self_ptr,int a)
{
      printf("child1_class_vfunc\n");
      child1_self_ptr->b = a + 10;
}
//子类构造函数
void child1_class_init(struct child_class1 *child1_self_ptr)
{
      struct parent_class *parent;
      //获取子类的父类指针
      parent = (struct parent_class *)child1_self_ptr;
      //设置子类的虚函数
      parent->vfunc = child1_class_vfunc;
}
//子类继承parent_class
struct child_class2
{
      struct parent_class parent;
      int b;
};
//子类虚拟函数实现
void child2_class_vfunc(struct child_class2 *child2_self_ptr,int a)
{

      printf("child2_class_vfunc\n");
      child2_self_ptr->b = a + 10;
}
//子类构造函数
void child2_class_init(struct child_class2 *child2_self_ptr)
{
      struct parent_class *parent;
      //获取子类的父类指针
      parent = (struct parent_class *)child2_self_ptr;
      //设置子类的虚函数
      parent->vfunc = child2_class_vfunc;
}
int main()
{
      struct child_class1 child1,*child1_ptr;
      struct child_class2 child2,*child2_ptr;
      struct parent_class *parent_ptr;
      //child1初始化
      child1_ptr = &child1;
      parent_ptr = (struct parent_class *)child1_ptr;
      child1_ptr->b = 10;
      child1_class_init(child1_ptr);
      parent_ptr->vfunc((struct parent_class *)child1_ptr,20);

      //child2初始化
   child2_ptr = &child2;
   parent_ptr = (struct parent_class *)child2_ptr;
   child2_ptr->b = 20;
   child2_class_init(child2_ptr);
   parent_ptr->vfunc((struct parent_class *)child2_ptr, 20);
   return 0;
}
执行结果:
child1_class_vfunc
child2_class_vfunc

kenson · 发表于 2016-6-22 12:11

zhixiaoyuhong 发表于 2016-6-20 16:49
2 t5 h, `; [$ wC语言也就因为有这灵活性，所以才可以开发linux内核这种大型项目吧。。。

C语言的确有它的灵活性，搞中小系统相当的不错，但不足就是它只是一个过程语言这就是它的缺点，所以想尽所有的办法来将这个缺点补上，所以就有现在这种BT的方法。

		自动登录	找回密码
密码			请使用微信账号登录和注册会员