如何用c寫出面向對像的程式

如何寫出優美的C代碼：物件導向的C

0推薦

http://www.bbs.topsage.com/thread-426058-1-1.html

物件導向的語言更接近人的思維方式，而且在很大程度上降低了代碼的複雜性，同時提高了代碼的可讀性和可維護性，傳統的 C 代碼同樣可以設計出比較易讀，易維護，複雜度較低的優美代碼，本文將通過一個實際的例子來說明這一點。

基礎知識

結構體

除了提供基礎資料型別 (Elementary Data Type)外，C 語言還提供給使用者自己定製資料類型的能力，那就是結構體，在 C 語言中，你可以用結構體來表示任何實體。結構體正是物件導向語言中的類的概念的雛形，比如：

1. typedef struct{
2.     float x;
3.     float y;
4. }Point;

複製代碼

定義了一個平面座標系統中的一個點，點中有兩個域，x 座標和 y 座標。

結構體中的域稱為結構體的成員。結構體中的資料類型可以是單一資料型別，也可以是其他的結構體，甚至結構體本身還可以嵌套，比如，一個標準的鏈表結構可以進行如下定義：

1. typedef struct node{
2.     void *data;// 資料指標
3.     int dataLength;// 資料長度
4.     struct node *next;// 指向下一個節點
5. }Node;

複製代碼

可以看到，結構體 node 中的 next 指標的類型又是 node 類型。

函數指標

指標是 C 語言的靈魂，是 C 比其他語言更靈活，更強大的地方。所以學習 C 語言必須很好的掌握指標。函數指標，即指向函數在記憶體映射中的首地址的指標，通過函數指標，可以將函數作為參數傳遞給另一個函數，並在適當的時候調用，從而實現非同步通訊等功能。

比如， UNIX/Linux 系統中的訊號註冊函數，其原型如下：

1. void (*signal(int signo,void (*func)(int))) (int)

複製代碼

使用的時候，需要自己在外部定義一個訊號處理函數 (signal handler), 然後使用 signal(sigNo, handler) 將處理常式註冊在進程上，當訊號發生時，進程就可以回調訊號處理函數。

將函數指標作為結構體的成員

正如前面提到的，結構體的成員可以是簡單的資料結構，也可以是其他的結構體，當然，也可以是指標。當將函數指標作為結構體的成員，並且這些函數只用來操作本結構體中的資料時，就可以形成一個獨立的實體，這個實體中既有資料，也有對資料的操作，這樣自然就可以引出類(class)的概念。

物件導向語言的特性

一般而言，繼承，封裝和多態被認為是物件導向語言所必須支援的三種特徵，也正是通過這三種特徵才可以體現出物件導向在哪些方面優於面向過程。由於語言開發商的宣傳或其他的各種原因，使的表面上物件導向的思想要通過語言為載體而得以實現，然而實際上，物件導向是一種軟體設計思想，完全是可以與具體實現無關的。

雖然如此，但是不可否認，這些所謂的純物件導向的語言，在其代碼的可讀性以及與人的自然思維的匹配方面，比面向過程的語言要好的多。

語言層次的物件導向

我們一般要描述一個對象，一般需要描述這個對象的一些屬性，比如盒子(box) 是一個實體，它有 6 個面，有顏色，重量，是否為空白等屬性，並且可以放東西進去，可以取東西出來。在物件導向的語言中，通常將這樣的對象抽象成一個類 (class):

1. class Box{
2.     clolr color;
3.     int weight;
4.     boolean empty;
5.    
6.     put(something);
7.     something get();
8. }

複製代碼

對盒子進行操作時，可以做一下動作：

1. Box.put(cake);
2. Box.get();// 取到某個東西，從盒子中。

複製代碼

而面向過程的語言中，通常是將實體傳遞給一個貫穿全域的函數來進行的，同樣以 Box 為例，對 Box 進行操作時，往往是這樣：

1. Put(Box, cake);// 將一個蛋糕放到盒子中
2. Get(Box);// 從盒子中取出某個東西來

複製代碼

而顯然，第一種代碼形式更符合常理，所以物件導向的語言大都提供這種語言層面的細節的支援，使得代碼的可讀性，可理解性大大增加。 C 語言，作為一個靈活而簡單的語言，我們完全可以通過 C 提供的簡單機制，實現這樣的比較優美的代碼形式。

C 語言的物件導向

如前所說，物件導向是一種軟體設計的思想，是語言無關的。在本節中，我舉一個鏈表(list)的例子來說明如何在 C 語言中的設計出有物件導向風格的代碼。

定義介面

介面是物件導向語言中的一個比較重要的概念，介面只對外部承諾實現該介面的實體可以完成什麼樣的功能，但是不暴露實現的方式。這樣的好處是，實現者可以在不接觸介面使用者的代碼的情況下，對實現進行調整。

我們來看看鏈表的介面定義：

清單 1. 鏈表的介面定義

1. #ifndef _ILIST_H
2. #define          _ILIST_H
4. // 定義鏈表中的節點結構
5. typedef struct node{
6.     void *data;
7.     struct node *next;
8. }Node;
10. // 定義鏈表結構
11. typedef struct list{
12.     struct list *_this;
13.     Node *head;
14.     int size;
15.     void (*insert)(void *node);// 函數指標
16.     void (*drop)(void *node);
17.     void (*clear)();
18.     int (*getSize)();
19.     void* (*get)(int index);
20.     void (*print)();
21. }List;
23. void insert(void *node);
24. void drop(void *node);
25. void clear();
26. int getSize();
27. void* get(int index);
28. void print();
30. #endif          /* _ILIST_H */

複製代碼

IList 介面中，可以清晰的看到，對於一個 list 實體 ( 也就是對象 ) 來說，可以在其上進行 insert, drop, clear, getSize, get(index) 以及 print 等操作。

介面的實現

清單 2. 構造方法

1. Node *node = NULL;
2. List *list = NULL;
4. void insert(void *node);
5. void drop(void *node);
6. void clear();
7. int getSize();
8. void print();
9. void* get(int index);
11. List *ListConstruction(){
12.     list = (List*)malloc(sizeof(List));
13.     node = (Node*)malloc(sizeof(Node));
14.     list->head = node;
15.     list->insert = insert;// 將 insert 函數實現註冊在 list 實體上
16.     list->drop = drop;
17.     list->clear = clear;
18.     list->size = 0;
19.     list->getSize = getSize;
20.     list->get = get;
21.     list->print = print;
22.     list->_this = list;// 用 _this 指標將 list 本身儲存起來
24.     return (List*)list;
25. }

複製代碼

需要注意的是此處的 _this 指標，_this 指標可以保證外部對 list 的操作映射到對 _this 的操作上，從而使得代碼得到簡化。

清單 3. 插入及刪除

1. // 將一個 node 插入到一個 list 對象上
2. void insert(void *node){
3.     Node *current = (Node*)malloc(sizeof(Node));
4.    
5.     current->data = node;
6.     current->next = list->_this->head->next;
7.     list->_this->head->next = current;
8.     (list->_this->size)++;
9. }
11. // 刪除一個指定的節點 node
12. void drop(void *node){
13.     Node *t = list->_this->head;
14.     Node *d = NULL;
15.     int i = 0;
16.     for(i;i < list->_this->size;i++){
17.         d = list->_this->head->next;
18.         if(d->data == ((Node*)node)->data){
19.             list->_this->head->next = d->next;
20.             free(d);
21.             (list->_this->size)--;
22.             break;
23.         }else{
24.             list->_this->head = list->_this->head->next;
25.         }
26.     }
27.     list->_this->head = t;
28. }

複製代碼

其他的實現代碼可以參看下載部分，這裡限於篇幅就不再意義列舉出來。

測試

測試代碼

好了，前面做的一切工作都是為了保證我們的暴露給使用者的 API 可以盡量的簡潔，優美，現在到測試的時候了：

清單 4. 測試代碼

1. int main(int argc, char** argv) {
2.     List *list = (List*)ListConstruction();// 構造一個新的鏈表
3.    
4. // 插入一些值做測試
5.     list->insert("Apple");
6.     list->insert("Borland");
7.     list->insert("Cisco");
8.     list->insert("Dell");
9.     list->insert("Electrolux");
10.     list->insert("FireFox");
11.     list->insert("Google");
12.    
13.     list->print();// 列印整個列表
14.             
15.     printf("list size = %d/n",list->getSize());
16.    
17.     Node node;
18.     node.data = "Electrolux";
19.     node.next = NULL;  
20.     list->drop(&node);// 刪除一個節點
21.    
22.     node.data = "Cisco";
23.     node.next = NULL;
24.     list->drop(&node);// 刪除另一個節點
25.    
26.     list->print();// 再次列印
27.     printf("list size = %d/n",list->getSize());
28.     list->clear();// 清空列表
30.     return 0;
31. }

複製代碼

圖 1. 運行結果

結束語

C 語言所誕生的UNIX平台提倡這樣一種設計哲學：盡量進行簡單的設計，讓使用者如同搭積木一樣的將這些簡單的工具串連成強大的，完整的應用。 應該說，C 比較好的繼承了這一點，C 語言非常簡潔，非常強大，而由於 C 語言誕生的比較早，當時的物件導向的思想還不成熟，所以出現了大量的過程式的 C 應用，從而給人們一種 C 語言是面向過程的語言的錯覺，其實 C 只是提供了一些簡單，強大而通用的能力，至於你想將其搭成什麼樣的積木，則全靠你自己了。