c實現物件導向

標籤：

物件導向無非就是封裝繼承和多態

封裝：struct實現

繼承：指標實現，就是把父類包含在結構體中。

多態：可以用指標實現。

一般實現多態，父結構體必須是子結構體的第一個元素，這樣就可以通過強制轉換子類和父類隨意轉換。

結構如：

 

[cpp] view plaincopy 

1. struct parent{  
2.         int a;  
3. };  
4. struct child{  
5.        struct parent p;  
6.        int b;  
7. };  
8. //所以才有下面的轉換  
9. struct child *c=(struct child *)malloc(sizeof(struct child));  
10. c->p.a=10;  
11. struct child *c=(struct child *)&(c->p);  
12. //c語言中有很多這樣通過首地址來轉換類型的  

 

 

而linux kernel 的多態不是這樣實現的

一般用->和containof()和void *

->:用來得到父類

containof():用來從父類得到子類

void *：相當於java裡面的Object類可以把一個類轉化為void *，然後在其它地方在轉化回來。長用在函數的參數裡面。

如:

 

[cpp] view plaincopy 

1. #include <stdio.h>  
2.   
3. struct base{  
4.     int a;  
5.     char b;  
6. };  
7.   
8. struct subclass{  
9.     struct base *mybase;  
10.     int s_a;  
11.     char s_b;  
12. };  
13.   
14.   
15. void test(struct base *base)  
16. {  
17.     //強制把指向結構體struct base 的指標base轉換為指向struct subclass的指標sub  
18.     //這裡是向下轉型  
19.     //struct subclass *sub=(struct subclass *)base;  
20.     struct subclass *sub=base;  
21.     printf("a:%d\tb:%c\n",sub->mybase->a,sub->mybase->b);  
22.     /*some operations*/  
23. }  
24.   
25. void main(void)  
26. {  
27.     struct subclass *mysub=(struct subclass *)malloc(sizeof(mysub));  
28.     mysub->mybase=(struct base *)malloc(sizeof(struct base));  
29.     mysub->mybase->a=10;  
30.     mysub->mybase->b=‘A‘;  
31.     mysub->s_a=11;  
32.     mysub->s_b=‘B‘;  
33.     //這裡是向上轉型,  
34.         //這個不像java 和 c++那樣可以自動向上轉型，所有必須手動來,  
35.     //這說的自動不是說如果沒有用運算式進行轉化的話會出問題，  
36.     //因為我們這裡的類不是真正的類，在c++或java中會是有明顯的繼承如A ：base  
37.     struct base *mybase;  
38.     mybase=mysub;  
39.     test(mybase);  
40. }  

 

ps：一些其它文章

來自：http://blog.chinaunix.net/uid-26750235-id-3102371.htmlhttp://blog.chinaunix.net/uid-26750235-id-3102371.html

 

      在幾何中，所有的幾何類型都繼承父類“形狀（shape）”，父類“形狀”有兩處屬性s_type和s_name。其中s_type用於表示該形狀所屬的類型，s_name用於表於該形狀態的名稱。而且父類shape還有兩個虛介面，一個為shape_area用於返回該形狀的面積，一個為shape_perimeter用於返回該形狀的周長。所子繼承“形狀”的子類都必須實現這兩個介面。

1. struct shape;
2. struct shape_ops
3. {
4.     /*返回幾何體的面積*/
5.     float (*so_area)(struct shape*); 
6.     /*返回幾何體的周長*/
7.     int (*so_perimeter)(struct shape*);
8. };
9. struct shape
10. {
11.     int* s_type;
12.     char* s_name;
13.     struct shape_ops* s_ops; /*虛介面，所有子類必須實現*/
14. };
16. float shape_area(struct shape* s)  /*求形狀面積*/
17. {
18.     return s->s_ops->so_area(s);  
19. }
20. int shape_perimeter(struct shape* s) /*求周長*/
21. {
22.     return s->s_ops->so_perimeter(s);
23. }

        幾何體“三角形（triangle）”繼承父類“形狀”，並且實現了父類的兩個虛介面。“三角形”有三條邊，分別用t_side_a，t_side_b，t_side_c來表於三條邊的長度。

1. /*三角形*/
2. struct triangle
3. {
4.     struct shape t_base;
5.     int t_side_a;
6.     int t_side_b;
7.     int t_side_c;
8. };
10. float triangle_area(struct shape* s)  /*三角形面積，用海倫公式*/
11. {
12.     struct triangle* t=(struct triangle*)s;
13.     int a=t->t_side_a;
14.     int b=t->t_side_b;
15.     int c=t->t_side_c;
16.     float p=(a+b+c)/2;
17.     return sqrt(p*(p-a)*(p-b)*(p-c));
18. }
19. int triangle_perimeter(struct shape* s)  /*三角形周長*/
20. {
21.     struct triangle* t=(struct triangle*)s;
22.     int a=t->t_side_a;
23.     int b=t->t_side_b;
24.     int c=t->t_side_c;
25.     return a+b+c;
26. }
27. struct shape_ops triangle_ops=    /*對父類虛介面的實現*/
28. {
29.     triangle_area,
30.     triangle_perimeter,
31. };
32. struct triangle* triangle_create(int a,int b,int c)  /*建立三角形*/
33. {
34.     struct triangle* ret=(struct triangle*)malloc(sizeof (*ret));
35.     ret->t_base.s_name="triangle";
36.     ret->t_base.s_ops=&triangle_ops;
37.     ret->t_side_a=a;
38.     ret->t_side_b=b;
39.     ret->t_side_c=c;
40.     return ret;
41. }

        幾何體“矩形（rectangle）”繼承父類“形狀”，同樣也實現的父類的兩個虛介面。有兩個屬性r_width和r_height，分別表示矩形的長和寬。

1. /*矩形*/
2. struct rectangle
3. {
4.     struct shape r_base;
5.     int r_width;
6.     int r_height;
7. };
9. float rectangle_area(struct shape* s)  /*矩形面積*/
10. {
11.     struct rectangle* r=(struct rectangle*)s;
12.     return r->r_width*r->r_height;
13. }
14. int rectangle_perimeter(struct shape* s)/*矩形周長*/
15. {
16.     struct rectangle* r=(struct rectangle*)s;
17.     return (r->r_width+r->r_height)*2;
18. }
19. struct shape_ops rectangle_ops=      /*對父類虛介面的實現*/
20. {
21.     rectangle_area,
22.     rectangle_perimeter,
23. };
25. struct rectangle* rectangle_create(int width, int height)  /*建立矩形*/
26. {
27.     struct rectangle* ret=(struct rectangle*)malloc(sizeof(*ret));
28.     ret->r_base.s_name="rectangle";
29.     ret->r_base.s_ops=&rectangle_ops;
30.     ret->r_height=height;
31.     ret->r_width=width;
32.     return ret;
33. }

測試代碼：

1. int main()
2. {
3.     struct shape* s[4];
4.     s[0]=triangle_create(5,5,4);
5.     s[1]=triangle_create(3,4,5);
6.     s[2]=rectangle_create(10,12);
7.     s[3]=rectangle_create(5,8);
9.     int i=0;
10.     for(i=0;i<4;i++)
11.     {
12.         float area=shape_area(s[i]);    
13.         int perimeter=shape_perimeter(s[i]);
14.         char* name=s[i]->s_name;
16.         printf("name:%s ,area:%.2f ,perimeter:%d\n",name,area,perimeter);
17.     }
18.     return 0;
19. }

 運行結果：

1. name:triangle ,area:9.17 ,perimeter:14
2. name:triangle ,area:6.00 ,perimeter:12
3. name:rectangle ,area:120.00 ,perimeter:44
4. name:rectangle ,area:40.00 ,perimeter:26

 

 

來自：http://blog.csdn.net/kennyrose/article/details/7564105

 

最近百度面試過程中有同學被問到這樣一個問題：如何用C語言實現物件導向？我們都知道物件導向的三大基本特徵：封裝、繼承和多態，C++語言和編譯器都對這些特徵有著強有力的支援，但是對於C這樣的函數式語言，如何?物件導向？引用一句話：物件導向從來都是思想，而不是語言! 理解物件導向的編程思想，我們使用C語言這樣的較低級的語言也同樣可以實現OOP，裡面具體用到的有C語言中的宏，結構體，函數指標, 彙總組合等知識。

 

強烈推薦參閱以下連結

http://blog.codingnow.com/2010/03/object_oriented_programming_in_c.html

http://c.group.iteye.com/group/wiki/1291-object-oriented-programming-language-c

http://blog.chinaunix.net/uid-26750235-id-3102371.html

http://blog.chinaunix.net/uid-9104650-id-2009591.html

http://liujian.is-programmer.com/posts/268.html

http://blog.csdn.net/yuyin86/article/details/7107671#

 

 

 

推薦兩本書：

《   Inside the C++ Object Model  》

《 Object-oriented Programming with ANSI-C 》

 

這裡是csdn上前幾章的中文翻譯

http://blog.csdn.net/besidemyself/article/details/6376405

 

wiki上有全部的中英文互譯

http://wiki.chinaunix.net/OOC:%e5%86%85%e5%ae%b9

 

不過建議對照英文原著閱讀

http://www.planetpdf.com/codecuts/pdfs/ooc.pdf

 

這裡有Object-oriented   Programming   with   ANSI-C的一些例子

http://www.bolthole.com/OO-C-programming.html

http://barracudaserver.com/WP/DeviceControl/OOIntro.html

http://www.eventhelix.com/realtimemantra/basics/object_oriented_programming_in_c.htm

 

 

這裡是一些OOP設計思想和原則的文章

http://www.eventhelix.com/realtimemantra/Object_Oriented/

 

下面這篇給出了C++和對應的C代碼，用C來實現C++中的繼承和虛函數特性，推薦@ ^ @

http://www.eventhelix.com/realtimemantra/basics/ComparingCPPAndCPerformance2.htm

 

下面是一個輕量級的物件導向C編程架構LW——OOPC（Light Weight Object-oriented Programming with C）

http://sourceforge.net/projects/lwoopc/

 

下面是優酷上面的一個視頻教程（我還沒看）

http://v.youku.com/v_show/id_XMTM4MzkyMTI4.html

 

不小心搜到了一個《 C語言也能幹大事 》

http://www.rupeng.com/forum/forum-52-1.html

 

有興趣的話也可以學習一下 Objective-C，它是加入物件導向思想的C語言母集

http://zh.wikipedia.org/wiki/Objective-C

http://www.apple.com.cn/developer/mac/library/documentation/Cocoa/Conceptual/OOP_ObjC/Introduction/chapter_1_section_1.html#//apple_ref/doc/uid/TP40005149-CH1-SW2

• • C語言物件導向編程（一）：封裝與繼承
  • C語言物件導向編程（二）：繼承詳解
  • C語言物件導向編程（三）：虛函數與多態
  • C語言物件導向編程（四）：面向介面編程
  • C語言物件導向編程（五）：單鏈表實現
  • C語言物件導向編程（六）：設定檔解析

c實現物件導向（轉）