程式師世界 >> 編程語言 >> C語言 >> 關於C語言 >> C語言的面向對象編程

C語言的面向對象編程

編輯：關於C語言

C語言的面向對象編程

面向對象的語言更接近人的思維方式，而且在很大程度上降低了代碼的復雜性，同時提高了代碼的可讀性和可維護性，傳統的 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_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_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; isizeOfList;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;
}