C语言的面向对象编程

http://www.ibm.com/developerworks/cn/linux/l-cn-cobject/
面向对象的语言更接近人的思维方式，而且在很大程度上降低了代码的复杂性，同时提高了代码的可读性和可维护性，传统的 C 代码同样可以设计出比较易读，易维护，复杂度较低的优美代码。
本文将通过一个实际的例子来说明这一点。

基础知识

结构体

除了提供基本数据类型外，C 语言还提供给用户自己定制数据类型的能力，那就是结构体，在 C 语言中，你可以用结构体来表示任何实体。结构体正是面向对象语言中的类的概念的雏形，比如：
typedef struct{
float x;
float y;
}Point;
定义了一个平面坐标系中的一个点，点中有两个域，x 坐标和 y 坐标。
结构体中的域称为结构体的成员。结构体中域的数据类型可以是简单数据类型，也可以是其他的结构体，甚至结构体本身还可以嵌套，嵌套使得可以做的事情更多，更具有想象力。比如，一个标准的链表结构可以进行如下定义：
typedef struct node{
void *data;// 数据指针
int dataLength;// 数据长度
struct node *next;// 指向下一个节点
}Node;
可以看到，结构体 node 中的 next 指针的类型又是 node 类型。数据类型可以自定义。结构体的行为通过函数指针来表达。函数指针，函数指针是结构体实现面向对象的定海神针，使得结构体具有行为特征。

指针

指针是 C 语言的灵魂，是 C 比其他语言更灵活，更强大的地方。所以学习 C 语言必须很好的掌握指针。函数指针，即指向函数在内存映射中的首地址的指针，通过函数指针，可以将函数作为参数传递给另一个函数，并在适当的时候调用，从而实现异步通信等功能。
比如， UNIX/Linux 系统中的信号注册函数，其原型如下：
void (*signal(int signo,void (*func)(int))) (int)
使用的时候，需要自己在外部定义一个信号处理函数 (signal handler), 然后使用 signal(sigNo, handler) 将处理程序注册在进程上，当信号发生时，进程就可以回调信号处理函数。
关于这个函数原型的理解有如下：

#include

void (*signal(int signo,void(*func)(int)))(int);

对于这个复杂函数的理解。
1、使用typedef拆解

typedef void(*sighandler_t)(int);
sighandler_t signal(int signum,sighandler_t handler);

2、使用函数指针理解
int (*p)();
明显知道：p指针指向的是一个不带任何参数，并且返回值为int的函数；
int (*fun())();
这个式子与上式区别在于用fun()代替p，即fun()返回值是一个函数指针，这个函数指针(可以看作p)，指向一个不带任何参数，并且返回值为int的函数；因此，对于

void (*signal(int signo,void(*func)(int)))(int);

可以看成是signal()函数，此函数带两个参数：一个为整型，一个为函数指针。而这个signal()函数的返回值也为一个函数指针，这个函数指针指向一个带一个整型参数，并且返回值为void的函数。

这个函数过于复杂，本身没有任何意义，通常都是使用typedef之后的简单信号处理函数。
但是返回一个函数指针有什么用呢？signal函数返回函数指针其实是指向以前的信号处理程序的函数指针。

将函数指针作为结构体的成员

正如前面提到的，结构体的成员可以是简单的数据结构，也可以是其他的结构体，当然，也可以是指针。当将函数指针作为结构体的成员，并且这些函数只用来操作本结构体中的数据时，就可以形成一个独立的实体，这个实体中既有数据，也有对数据的操作，这样自然就可以引出类(class)的概念。

面向对象语言的特性

一般而言，继承，封装和多态被认为是面向对象语言所必须支持的三种特征，也正是通过这三种特征才可以体现出面向对象在哪些方面优于面向过程。由于语言开发商的宣传或其他的各种原因，使的表面上面向对象的思想要通过语言为载体而得以实现，然而实际上，面向对象是一种软件设计思想，完全是可以与具体实现无关的。
虽然如此，但是不可否认，这些所谓的纯面向对象的语言，在其代码的可读性以及与人的自然思维的匹配方面，比面向过程的语言要好的多。
面向对象语言在语言层次的面向对象支持

我们一般要描述一个对象，一般需要描述这个对象的一些属性，比如盒子(box) 是一个实体，它有 6 个面，有颜色，重量，是否为空等属性，并且可以放东西进去，可以取东西出来。在面向对象的语言中，通常将这样的对象抽象成一个类 (class):

class Box{ 
    clolr color; 
    int weight; 
    boolean empty; 

    put(something); 
    something get(); 
 }

对盒子进行操作时，可以做一下动作：

 Box.put(cake); 
 Box.get();// 取到某个东西，从盒子中。

而面向过程的语言中，通常是将实体传递给一个贯穿全局的函数来进行的，同样以 Box 为例，对 Box 进行操作时，往往是这样：

 Put(Box, cake);// 将一个蛋糕放到盒子中
 Get(Box);// 从盒子中取出某个东西来

而显然，第一种代码形式更符合常理，所以面向对象的语言大都提供这种语言层面的细节的支持，使得代码的可读性，可理解性大大增加。 C 语言，作为一个灵活而简单的语言，我们完全可以通过 C 提供的简单机制，实现这样的比较优美的代码形式。

C 语言的面向对象

如前所说，面向对象是一种软件设计的思想，是语言无关的。在本节中，我举一个链表(list)的例子来说明如何在 C 语言中的设计出有面向对象风格的代码。
定义接口

接口是面向对象语言中的一个比较重要的概念，接口只对外部承诺实现该接口的实体可以完成什么样的功能，但是不暴露实现的方式。这样的好处是，实现者可以在不接触接口使用者的代码的情况下，对实现进行调整。
我们来看看链表的接口定义：

#ifndef LIST_H_INCLUDED
#define LIST_H_INCLUDED

/**
*@author PENGRONG
*@date 2016/01/17
*/

#ifdef __cplusplus
extern "C" {
#endif // __cplusplus

//定义数据域
typedef struct data{
    int year;
    char *name;

}Data;
 // 定义链表中的节点结构
 typedef struct node{
    void *data;
    struct node *next;
 }Node;

 // 链表结构申明,含有指向该链表的
 typedef struct List{
    struct List *_this;
    Node *head;
    int sizeOfList;

    void (*insertOfElement)(void *node,struct List *list);// 函数指针
    void (*drop)(void *node,struct List *list);
    void (*clearList)(struct List **list);
    int (*getSize)(struct List *list);
    void* (*get)(int index, struct List *list);
    void (*print)(struct List *list);
 }List;

//构建一个空链表
  extern List *ListConstruction();

#ifdef __cplusplus
}
#endif // __cplusplus
#endif // LIST_H_INCLUDED

List 接口中，可以清晰的看到，对于一个 list 实体 ( 也就是对象 ) 来说，可以在其上进行 insertOfElement, drop, clearList, getSize, get(index) 以及 print 等操作。

接口的实现

一、空链表的构造

/**
*   @author pengrong
*   @date
*   @   功能初始化一个链表
*/
List *ListConstruction(){
    //链表节点
    Node *node = NULL;
    //链表结构
    List *list = NULL;
    list = (List*)malloc(sizeof(List));
    node = (Node*)malloc(sizeof(Node));
    list->head = node;
    node->data=NULL;
    node->next=NULL;
    list->insertOfElement = insertOfElement;// 将 insert 函数实现注册在 list 实体上
    list->drop = drop;
    list->clearList = clearList;
    list->sizeOfList = 0;
    list->getSize = getSize;
    list->get = get;
    list->print = print;
    list->_this = list;// 用 _this 指针将 list 本身保存起来
    printf("construction successful\n");
    return (List*)list;
 }

二、往链表插入一个数据

/**
*   @author pengrong
*   @date 2016/01/19
*在链表前面插入元素
*/
 void insertOfElement(void *data, List *list)
 {
    if(data==NULL || list==NULL)
        return;
    Node *current = (Node*)malloc(sizeof(Node));
    //填充数据
    current->data = (Data *)data;
    current->next = list->_this->head->next;
    list->_this->head->next = current;
    (list->_this->sizeOfList)++;
    printf("insert sucessful\n");

 }

三、从链表删除一个元素

/**
*   @author pengrong 
*   @date 2016/01/19
*   删除一个节点
*/
 void drop(void *data, List *list)
 {
     if(data==NULL || list ==NULL)
     {
         printf("data empty or list empty");
         return;
     }
     //头结点
     Node *t=list->_this->head;
     //遍历节点
     Node *n=NULL;
     //删除数据
     Data *d1=(Data *)data;
     int i=0;
     for(i=0;i<list->_this->sizeOfList;i++)
     {
        //遍历节点指针,头结点的下一个节点就是首节点
        n=list->_this->head->next;
        if( (d1->year==((Data *)n->data)->year) &&
            (strcmp(d1->name,((Data *)n->data)->name)==0))
        {
            //如果内容一样
            list->_this->head->next=n->next;
            free(n);
            free(d1);
            (list->_this->sizeOfList)--;
            printf("drop successful\n");
            break;
        }
        else
        {
            list->_this->head=list->_this->head->next;
        }
     }
    if(i>=list->_this->sizeOfList)
    {
        printf("drop failure\n");
    }
    list->_this->head=t;

 }

四、清除链表所有元素

/**
 *  @author pengrong
 *  @date 2016/01/19
 *  @param list
 *  @return void
 *  @function 删除列表的所有元素节点。
 *  处理逻辑是，链表有一个head成员，他只想链表的第一个元素，
 *  只要他的next属性为NULL说明链表为空
 */
 void clearList(List **plist)
 {
    if(*plist ==NULL)
    {
        printf("list empty");
        return;
    }
    List *list=*plist;
    //指向待删除元素节点
    Node *n=NULL;
    for(;list->_this->head->next!=NULL;)
    {
        //取出删除节点n,头结点的下一个是首节点
        n=list->_this->head->next;
        //把头指针指向下一个元素
        list->_this->head->next=list->_this->head->next->next;
        //删除节点n
        //先删除数据节点空间,后删除节点空间
        free(n->data);
        free(n);
        (list->_this->sizeOfList)--;
    }
    //删除头结点
    //free(list->_this->head);
    //删除链表结构
    //free(list);
    //*plist=NULL;

 }

五、获得链表长度

/**
*   @author pengrong 
*   @date 2016/01/19
*   //获得链表元素长度
*/

 int getSize(List *list)
 {
    if(list==NULL)
    {
        printf("list empty");
        return;
    }
    return list->sizeOfList;
 }

六、获取index处的元素

/**
*   @author pengrong 
*   @date 2016/01/19
*   //获得链表元素长度
*/
void *get(int index, List *list)
 {
    if(index<0 || list==NULL)
      {
        printf("list empty or index <0;");
        return NULL;
      }
    Data *indexData=NULL;
    //t是指向链表首节点的
    Node *t=list->_this->head->next;
    int i=0;
    for(i=0; i<list->_this->sizeOfList;i++)
    {
        if(i==index)
            {
                indexData=(Data *)t->data;
                break;
            }
        t=t->next;
    }
    if(i>=list->_this->sizeOfList)
    {
        printf("yue jie");
    }
    return indexData;
 }

七、遍历链表所有元素

/**
*   @author pengrong 
*   @date 2016/01/19
*  //这个打印之前必须确保链表指针指向确定的一块链表内存块。
*//不然执行这个函数程序会崩溃的。
*/

 void print(List *list)
 {
    if(list==NULL)
    {
        printf("list empty");
        return;
    }
    int i=0;
    Node *tem=list->_this->head;
    Data *data=NULL;
    for(i=0; i<list->sizeOfList;i++)
    {
        data=(Data *)list->_this->head->next->data;
        printf("name=%s,\tyear=%d\n",data->name,data->year);
        list->_this->head=list->_this->head->next;
    }
    list->_this->head=tem;

 }

测试代码

int main(int argc,char **argv)
{
    List *plist;
    Data d1;
    plist=ListConstruction();
    //申请一个存储数据的空间
    Data *pxiao=malloc(sizeof(Data));
    pxiao->name="xiaoming";
    pxiao->year=19;
    plist->insertOfElement(pxiao,plist);

    //插入第二个数据
    pxiao=malloc(sizeof(Data));
    pxiao->name="xiaoling";
    pxiao->year=29;
    plist->insertOfElement(pxiao,plist);

     //插入第三个数据
    pxiao=malloc(sizeof(Data));
    pxiao->name="JBV";
    pxiao->year=69;
    plist->insertOfElement(pxiao,plist);

    //插入第四个数据
    pxiao=malloc(sizeof(Data));
    pxiao->name="XXX";
    pxiao->year=89;
    plist->insertOfElement(pxiao,plist);
    //输出
    printf("getSize\t%d\n",plist->getSize(plist));
    printf("delete previous\n");
    plist->print(plist);

    //删除一个数据
    d1.name="xiaoling";
    d1.year=29;
    printf("delete after\n");
    plist->drop(&d1,plist);
    plist->print(plist);

    //获得一个元素
    printf("get a element\n");
    pxiao=plist->get(2,plist);
    if(pxiao!=NULL)
    {
        printf("name=%s,\tyear=%d\n",pxiao->name,pxiao->year);
    }
    else
    {
        printf("element no exist\n");
    }

    //删除链表
    plist->clearList(&plist);

    printf("clear hou\n");
    if(plist !=NULL)
    {
        plist->print(plist);
        printf("%d",plist->getSize(plist));

    }
    else
    {
        printf("lian biao kong");
    }
    return 0;
}

运行结果如下

：