免费注册 查看新帖 |

Chinaunix

  平台 论坛 博客 文库
› 论坛 › 程序设计 › C/C++ › [转载]OO Programing in C
1234567下一页
最近访问板块 发新帖
查看: 19969 | 回复: 63
打印 上一主题 下一主题

[C] [转载]OO Programing in C [复制链接]

gawk

论坛徽章:
0
跳转到指定楼层
1楼 [收藏(0)] [报告]
发表于 2008-08-24 09:54 |只看该作者 |倒序浏览
最近看c版很多人讨论c的面向对象，前天突然在别的论坛看到这个帖子，又因为今天早上醒得早，就copy过来了
http://www.javaeye.com/topic/150575
http://www.javaeye.com/topic/150578
http://www.javaeye.com/topic/150581
作者:rubynroll
----------------------------------------------------------------------------------------------------------------
经常看到关于OO编程的讨论，C++, Java, C#...还有最近很流行的动态语言Python,Ruby等，但很少看到有C的份。


在我看来，OO编程的核心是OO的思想，用什么语言倒是其次。但是，不可否认，那些专门为OO编程设计的语言可以比较方便和自然地表达OO思想，有些语言甚至强制使用OO特性。


C，作为最贴近底层的高级语言，拥有简洁的语法和直接内存操作能力（指针），大量运用于系统级编程，如操作系统内核，驱动程序等。而在嵌入式系统中，由于资源有限等因素，更倾向于用C编程。

C虽然在语言特性上并没有体现OO特性，但是依然可以通过各种编程技巧来体现OO的思想。由于C的高度自由的特点，在OO编程方面还能体现有别于其他语言的特殊韵味。


OO思想在Unix世界中很早就有：UNIX把设备抽象成文件，这样就可以用一套相同的方法(open, read, write, close, ... )去访问不同的设备和文件——尽管设备之间的差异很大。用OO的观点来看，这些“设备”对象都实现了"文件操作接口"，可以想象有一个叫"文件"的基类，定义了"文件操作接口"，“设备”对象继承了“文件”对象....。在实现角度看，在内核里面，设备驱动提供了自己的read, write等实现，并用它们去填充文件操作结构体里面的函数指针....这和C++里面的虚函数运行时绑定的道理是一样的。( C++虚函数是其实是运行时静态绑定，而文件操作接口可以运行时动态绑定

Linux内核中则处处体现了OO的思想。2.6内核的Device Driver Modal是一套层次分明又错综复杂的机制，其中体现了许多OO设计理念。虽然可能设备驱动程序开发者觉察不到，但所有的设备驱动对象内部都隐藏了一个叫KObject的对象。内核把这些KObjects互相联系在一起，并通过KObject的相互关系构造了/sys文件系统。/sys就是内核中各种设备对象的映射图，如果把/sys全部展开，我们可以清楚地看到各种对象的关系。

实践证明，C也可以很好地用于OO编程，而且可以用于构造很复杂的系统，而且C在表达OO思想的时候并不会显得蹩脚，而是可以很简单，很自然。

[ 本帖最后由 gawk 于 2008-8-24 10:02 编辑 ]
gawk

论坛徽章:
0
2楼 [报告]
发表于 2008-08-24 09:55 |只看该作者
“class“是很多OO编程语言里的关键字，它来源于OO鼻祖Smalltalk。class（类），是对一群有相同特性的对象的抽象概括，对象称为类的实例。在class里面可以存放有状态(变量)，行为(函数/方法)....有关OO概念、方法的文章太多了，不再啰嗦。在C里面，唯一可以实现自定义类型的是struct，struct是C的OO编程最重要的工具。


一个最常见的技巧，就是用struct来"仿真"class: 在struct里面放入变量，函数指针，嵌入其他struct等。

以下例子摘自我最近刚开发完成的一个USB Firmware项目:


  2. struct usb_device;   
  3. struct usb_ctl;   
  4.   
  5. struct usb_iobuf {   
  6.   int len;              /* data length in the buffer */  
  7.     unsigned char buf[USBEPFIFO_SIZE];  /* data buffer itself */  
  8. };   
  9.   
  10. struct usb_endpoint {   int type;       /* endpoint type: BULKIN, BULKOUT, CTL, ISO ... */  
  11.     int qlen;       /* queue length */  
  12.   
  13.     xQueueHandle lock;  /* semaphore lock */  
  14.     xQueueHandle q;     /* data queue (pointer of bulk_buf) */  
  15.   
  16.     int idx;        /* endpoint index */  
  17.     int epx;        /* endpoint mark bit */  
  18.     int cfg;        /* endpoint configure */  
  19.     int bank;       /* current operation bank (for ping-pong mode) */  
  20.     int txCount;        /* used for ping-pong mode */   /* endpoint data process function */        void (*ep_process) (struct usb_device *dev,          struct usb_endpoint *ep,            xISRStatus *pxMessage);   
  21. };   
  22.   
  23. struct usb_descriptor {   
  24.     int type;       /* descriptor type: device, conf, string or endpoint */  
  25.     int idx;        /* descriptor index (for string descriptor) */  
  26.     int size;       /* descriptor size */  
  27.     void * data;        /* descriptor data */  
  28.     struct list_head list;  /* link list of descriptors */  
  29. };   
  30.   
  31. struct usb_deviceOps {   
  32.     int (*init)(struct usb_device *dev);        /* called when framework init usb device, add device descriptors, init private data ... etc. */  
  33.     int (*reset)(struct usb_device *dev);       /* called when reseted by host */  
  34.     int (*switch_in)(struct usb_device *dev);   /* called when switch in */  
  35.     int (*switch_out)(struct usb_device *dev);  /* called when swithc out */    /* called when HOST request class interface data */  
  36.     void (*class_interface_req)(struct usb_device *dev, xUSB_REQUEST *pxRequest);   /* called when HOST complete the data sending stage */      int (*ctl_data_comp)(struct usb_device *dev,                     xCONTROL_MESSAGE *pxMessage);   
  37. };   
  38.   
  39. struct usb_ctlOps {   
  40.     void (*ctl_transmit_null)(struct usb_ctl *ctl);   
  41.     void (*ctl_send_stall)(struct usb_ctl *ctl);   
  42.     void (*ctl_reset_ep0)(struct usb_ctl *ctl);   
  43.     void (*ctl_detach_usb)(struct usb_ctl *ctl);   
  44.     void (*ctl_attach_usb)(struct usb_ctl *ctl);   
  45.     void (*ctl_send_data)(struct usb_ctl *ctl, unsigned char *data,   
  46.             int req_len,   
  47.             int send_len,   
  48.             int is_des);   
  49. };   
  50.   
  51.   
  52. struct usb_ctl {   
  53.     int addr;           /* address alloced by host */  
  54.     int conf;           /* configuration set by host */  
  55.     eDRIVER_STATE state;        /* current status */  
  56.     xCONTROL_MESSAGE tx;        /* control transmit message */  
  57.     xCONTROL_MESSAGE rx;        /* control receive message */  
  58.     struct ubufm *bufmn;        /* 'usb_iobuf' buffer manager, shared by all usb devices */  
  59.     int prio;           /* the main task priority */  
  60.     xTaskHandle task_handle;    /* the main task handler */  
  61.     struct usb_ctlOps *ctlOps;  /* control endpoint operations */  
  62. };   
  63.   
  64. struct usb_device {   
  65.     char name[16];          /* device name, e.g. "usbser" */  
  66.     struct usb_deviceOps *ops;  /* usb device callback functions */  
  67.   
  68.     struct usb_ctl *ctl;        /* usb control enpoint, provided by framework */  
  69.     struct list_head desc_list; /* usb descriptors */  
  70.     struct usb_endpoint *ep[MAX_ENDPOINTS]; /* endpoints */  
  71.     int active;         /* whether the device is active */  
  72.     xQueueHandle ready;     /* notify this queue when usb device ready */  
  73.     void *private;          /* device private data */  
  74.     struct list_head list;      /* link list of usb device */  
  75. };  

  77. struct usb_device;
  78. struct usb_ctl;

  80. struct usb_iobuf {
  81.   int len;                                /* data length in the buffer */
  82.         unsigned char buf[USBEPFIFO_SIZE];        /* data buffer itself */
  83. };

  85. struct usb_endpoint {        int type;                /* endpoint type: BULKIN, BULKOUT, CTL, ISO ... */
  86.         int qlen;                /* queue length */

  88.         xQueueHandle lock;        /* semaphore lock */
  89.         xQueueHandle q;                /* data queue (pointer of bulk_buf) */

  91.         int idx;                /* endpoint index */
  92.         int epx;                /* endpoint mark bit */
  93.         int cfg;                /* endpoint configure */
  94.         int bank;                /* current operation bank (for ping-pong mode) */
  95.         int txCount;                /* used for ping-pong mode */        /* endpoint data process function */                void (*ep_process) (struct usb_device *dev,                         struct usb_endpoint *ep,                         xISRStatus *pxMessage);
  96. };

  98. struct usb_descriptor {
  99.         int type;                /* descriptor type: device, conf, string or endpoint */
  100.         int idx;                /* descriptor index (for string descriptor) */
  101.         int size;                /* descriptor size */
  102.         void * data;                /* descriptor data */
  103.         struct list_head list;        /* link list of descriptors */
  104. };

  106. struct usb_deviceOps {
  107.         int (*init)(struct usb_device *dev);                /* called when framework init usb device, add device descriptors, init private data ... etc. */
  108.         int (*reset)(struct usb_device *dev);                /* called when reseted by host */
  109.         int (*switch_in)(struct usb_device *dev);        /* called when switch in */
  110.         int (*switch_out)(struct usb_device *dev);        /* called when swithc out */        /* called when HOST request class interface data */
  111.         void (*class_interface_req)(struct usb_device *dev, xUSB_REQUEST *pxRequest);        /* called when HOST complete the data sending stage */                int (*ctl_data_comp)(struct usb_device *dev,                                         xCONTROL_MESSAGE *pxMessage);
  112. };

  114. struct usb_ctlOps {
  115.         void (*ctl_transmit_null)(struct usb_ctl *ctl);
  116.         void (*ctl_send_stall)(struct usb_ctl *ctl);
  117.         void (*ctl_reset_ep0)(struct usb_ctl *ctl);
  118.         void (*ctl_detach_usb)(struct usb_ctl *ctl);
  119.         void (*ctl_attach_usb)(struct usb_ctl *ctl);
  120.         void (*ctl_send_data)(struct usb_ctl *ctl, unsigned char *data,
  121.                         int req_len,
  122.                         int send_len,
  123.                         int is_des);
  124. };


  127. struct usb_ctl {
  128.         int addr;                        /* address alloced by host */
  129.         int conf;                        /* configuration set by host */
  130.         eDRIVER_STATE state;                /* current status */
  131.         xCONTROL_MESSAGE tx;                /* control transmit message */
  132.         xCONTROL_MESSAGE rx;                /* control receive message */
  133.         struct ubufm *bufmn;                /* 'usb_iobuf' buffer manager, shared by all usb devices */
  134.         int prio;                        /* the main task priority */
  135.         xTaskHandle task_handle;        /* the main task handler */
  136.         struct usb_ctlOps *ctlOps;        /* control endpoint operations */
  137. };

  139. struct usb_device {
  140.         char name[16];                        /* device name, e.g. "usbser" */
  141.         struct usb_deviceOps *ops;        /* usb device callback functions */

  143.         struct usb_ctl *ctl;                /* usb control enpoint, provided by framework */
  144.         struct list_head desc_list;        /* usb descriptors */
  145.         struct usb_endpoint *ep[MAX_ENDPOINTS];        /* endpoints */
  146.         int active;                        /* whether the device is active */
  147.         xQueueHandle ready;                /* notify this queue when usb device ready */
  148.         void *private;                        /* device private data */
  149.         struct list_head list;                /* link list of usb device */
  150. };
复制代码

在这个例子，我用struct分别描述了USB设备，USB控制通道，USB端点，USB描述符和USB缓冲区对象。USB设备对象包含了若干个USB端点，一个USB控制通道指针，一个USB描述符表的表头(指向若干个USB描述符)，和一个USB缓冲区管理对象。而且，USB设备对象还包含了name属性，一个由USB Framework调用的回调函数集，还有一个用于连接其他USB设备的链表节点。

值得一提的是，USB设备对象中有一个void *private 成员，可以指向任何数据。实际上在我的程序里，我实现了usb-serial和usb-mass-storage两个USB设备，对于usb-serial对象，private我弃之不用，而在usb-mass-storage对象中，private指向一个Mass storage对象，usb-mass-storage正是通过这个Mass storage对象访问外部大容量存储的（在我的程序里，Mass storage对象和一个MMC Card对象绑定，外部存储是SD/MMC卡）。由于对于每一种设备的具体实现来说，它知道private指向的是何种类型的设备，因此不会引起混乱。而外部程序根据需要在初始化USB设备对象前赋予private有意义的值——运行时动态绑定。

这一系列struct基本上如实地反映了USB DEVICE硬件逻辑和规范要求: "一个USB设备包含若干个端点，其中有一个固定的控制端点(端点0)。在枚举阶段USB设备要根据HOST的请求应答相应的描述符..."

现在回到OO的话题，这个例子中体现了"组合类"：USB设备对象包含了USB端点对象，USB描述符对象...。还有动态绑定 (private成员)。从严格的OO意义上来看，好像有点"怪"，不过我认为这恰恰是C的特点——简洁，直接。不信你用C++表达试试？也许会更漂亮，很OO，但是不一定会如此清爽！

P.S. : 熟悉USB Firmware开发的人可能对struct usb_endpoint中的epx,cfg,bank和txCount四个成员有异议，因为这些成员是和特定的硬件相关，并不是所有的USB硬件都支持ping-pong mode，所以bank和txCount不一定用得上，epx, cfg也可能因硬件的不同而不同。没错！更理想的设计是把与硬件相关的部分分离出来，用void *private指向各自的与硬件相关的配置——就像struct usb_device所采用方法，所以更好的版本应该是：


  2. struct usb_endpoint {   
  3.   int type;     /* endpoint type: BULKIN, BULKOUT, CTL, ISO ... */  
  4.   int qlen;     /* queue length */  
  5.   xQueueHandle lock;    /* semaphore lock */  
  6.   xQueueHandle q;   /* data queue (pointer of bulk_buf) */  
  7.   int idx;      /* endpoint index */  
  8.      
  9.   /* endpoint data process function */  
  10.   void (*ep_process)(struct usb_device *dev,    struct usb_endpoint *ep, xISRStatus *pxMessage);   
  11.   void *private;    /* endpoint private data (hardware relevant) */  
  12. };  

  14. struct usb_endpoint {
  15.   int type;                /* endpoint type: BULKIN, BULKOUT, CTL, ISO ... */
  16.   int qlen;                /* queue length */
  17.   xQueueHandle lock;        /* semaphore lock */
  18.   xQueueHandle q;        /* data queue (pointer of bulk_buf) */
  19.   int idx;                /* endpoint index */
  20.   
  21.   /* endpoint data process function */
  22.   void (*ep_process)(struct usb_device *dev,        struct usb_endpoint *ep, xISRStatus *pxMessage);
  23.   void *private;        /* endpoint private data (hardware relevant) */
  24. };
复制代码

tips: 用C表达的一个关键处就是要很好地应用struct来描述模型。

[ 本帖最后由 gawk 于 2008-8-24 09:58 编辑 ]
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
gawk

论坛徽章:
0
3楼 [报告]
发表于 2008-08-24 09:56 |只看该作者
OO的一个亮点是类的"继承"，通过"继承"，可以重用许多代码。而且"继承"也是现实生活中非常自然的一种关系。但是很不幸，C没有class，更没有提供"继承"的表达方式。既然能用C的struct来仿真class, 那能不能继续来仿真"继承"呢？答案是:possible。就像<<Inside the C++ Object Modal>>书中所叙述的那样——你可以用C来达到所有C++能做到的事。但这种仿真显然毫无实际应用价值。

"继承"是一种表达方式，代码重用才是目的。

为了重用代码，C++可以用"继承"的方式来巧妙的达到目的，但是也必须付出代价：你必须非常仔细地设计你的类族谱，要有前瞻性，要有可扩展性，要决定分多少个层次....这些都不是容易做到的事。

C别无选择，模块化设计，函数，宏....只能通过巧妙的设计才能达到代码可重用的目的。还是举个例子来说明C是如何做到"殊途同归"的吧。

"链表"是一个非常常用的数据结构，常用于管理无序的数据(对象)集合。链表操作，特别是双向链表操作很容易出错。重用一套通用操作链表的代码可以为我们省不少事。在C++中，我们可以用经典的STL中的list类。为了适应各种数据类型，list类用模板来实现。list类实现的很巧妙，功能很强，但是，不得不说，很少人用。其实不仅list类很少用，STL都很少人用。（希望这是我的一家之言，反正我所熟悉的C++程序员都不怎么用STL :-）当然在C++中你还有另外一个选择：实现一个List基类完成链表操作，要放入链表的类从List类继承而来，就拥有了一套操作list的方法。

Linux内核中用C提供了一套非常巧妙的方法操作链表，位于.../linux/include/linux/list.h，只用一些宏和inline函数来实现双向链表。摘抄一部分出来：


  2. ....   
  3. struct list_head {   
  4.     struct list_head *next, *prev;   
  5. };   
  6.   
  7.   
  8. #define LIST_HEAD_INIT(name) { &(name), &(name) }   
  9.   
  10. #define LIST_HEAD(name) \   
  11.     struct list_head name = LIST_HEAD_INIT(name)   
  12.   
  13. #define INIT_LIST_HEAD(ptr) do { \   
  14.     (ptr)->next = (ptr); (ptr)->prev = (ptr); \   
  15. } while (0)   
  16.   
  17. /*  
  18. * Insert a new entry between two known consecutive entries.  
  19. *  
  20. * This is only for internal list manipulation where we know  
  21. * the prev/next entries already!  
  22. */  
  23. static inline void __list_add(struct list_head *new,   
  24.                   struct list_head *prev,   
  25.                   struct list_head *next)   
  26. {   
  27.     next->prev = new;   
  28.     new->next = next;   
  29.     new->prev = prev;   
  30.     prev->next = new;   
  31. }   
  32.   
  33. /**  
  34. * list_add - add a new entry  
  35. * @new: new entry to be added  
  36. * @head: list head to add it after  
  37. *  
  38. * Insert a new entry after the specified head.  
  39. * This is good for implementing stacks.  
  40. */  
  41. static inline void list_add(struct list_head *new, struct list_head *head)   
  42. {   
  43.     __list_add(new, head, head->next);   
  44. }   
  45.   
  46. .....   
  47.   
  48. /**  
  49. * list_entry - get the struct for this entry  
  50. * @ptr:    the &struct list_head pointer.  
  51. * @type:    the type of the struct this is embedded in.  
  52. * @member:    the name of the list_struct within the struct.  
  53. */  
  54. #define list_entry(ptr, type, member) \   
  55.     container_of(ptr, type, member)   
  56.   
  57. /**  
  58. * list_for_each    -    iterate over a list  
  59. * @pos:    the &struct list_head to use as a loop counter.  
  60. * @head:    the head for your list.  
  61. */  
  62. #define list_for_each(pos, head) \   
  63.     for (pos = (head)->next; prefetch(pos->next), pos != (head); \   
  64.             pos = pos->next)   
  65.   
  66. ......  

  68. ....
  69. struct list_head {
  70.     struct list_head *next, *prev;
  71. };


  74. #define LIST_HEAD_INIT(name) { &(name), &(name) }

  76. #define LIST_HEAD(name) \
  77.     struct list_head name = LIST_HEAD_INIT(name)

  79. #define INIT_LIST_HEAD(ptr) do { \
  80.     (ptr)->next = (ptr); (ptr)->prev = (ptr); \
  81. } while (0)

  83. /*
  84. * Insert a new entry between two known consecutive entries.
  85. *
  86. * This is only for internal list manipulation where we know
  87. * the prev/next entries already!
  88. */
  89. static inline void __list_add(struct list_head *new,
  90.                   struct list_head *prev,
  91.                   struct list_head *next)
  92. {
  93.     next->prev = new;
  94.     new->next = next;
  95.     new->prev = prev;
  96.     prev->next = new;
  97. }

  99. /**
  100. * list_add - add a new entry
  101. * @new: new entry to be added
  102. * @head: list head to add it after
  103. *
  104. * Insert a new entry after the specified head.
  105. * This is good for implementing stacks.
  106. */
  107. static inline void list_add(struct list_head *new, struct list_head *head)
  108. {
  109.     __list_add(new, head, head->next);
  110. }

  112. .....

  114. /**
  115. * list_entry - get the struct for this entry
  116. * @ptr:    the &struct list_head pointer.
  117. * @type:    the type of the struct this is embedded in.
  118. * @member:    the name of the list_struct within the struct.
  119. */
  120. #define list_entry(ptr, type, member) \
  121.     container_of(ptr, type, member)

  123. /**
  124. * list_for_each    -    iterate over a list
  125. * @pos:    the &struct list_head to use as a loop counter.
  126. * @head:    the head for your list.
  127. */
  128. #define list_for_each(pos, head) \
  129.     for (pos = (head)->next; prefetch(pos->next), pos != (head); \
  130.             pos = pos->next)

  132. ......
复制代码


其中 container_of 宏如下：


  2. /**  
  3. * container_of - cast a member of a structure out to the containing structure  
  4. * @ptr:    the pointer to the member.  
  5. * @type:    the type of the container struct this is embedded in.  
  6. * @member:    the name of the member within the struct.  
  7. *  
  8. */  
  9. #define container_of(ptr, type, member) ({            \   
  10.         const typeof( ((type *)0)->member ) *__mptr = (ptr);    \   
  11.         (type *)( (char *)__mptr - offsetof(type,member) );})  

  13. /**
  14. * container_of - cast a member of a structure out to the containing structure
  15. * @ptr:    the pointer to the member.
  16. * @type:    the type of the container struct this is embedded in.
  17. * @member:    the name of the member within the struct.
  18. *
  19. */
  20. #define container_of(ptr, type, member) ({            \
  21.         const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
  22.         (type *)( (char *)__mptr - offsetof(type,member) );})

复制代码


这里使用了GCC特有的 "typeof" 关键字，如果想用其他编译器也想编译通过的话，可以修改成：


  2. #define container_of(ptr, type, member) (            \   
  3.         (type *)( (char *)ptr - offsetof(type,member) ) )  

  5. #define container_of(ptr, type, member) (            \
  6.         (type *)( (char *)ptr - offsetof(type,member) ) )
复制代码

为了便于说明，prefetch定义成：

  2. static inline void prefetch(const void *x) {;}  

  4. static inline void prefetch(const void *x) {;}
复制代码

offsetof的一个简单版本：

  2. #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)  

  4. #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
复制代码

好了，让我们看看怎么用：

  2. struct my_data {   
  3.     int x;   
  4.     int y;   
  5.     struct list_head list;   
  6. }   
  7.   
  8. /* 链表头 */  
  9. LIST_HEAD(my_listhead);   
  10.   
  11. void my_function()   
  12. {   
  13.     ...   
  14.     /* 节点对象 */  
  15.     struct my_data *node_1 = (struct my_data *) malloc(sizeof(struct my_data));   
  16.     struct my_data *node_2 = (struct my_data *) malloc(sizeof(struct my_data));   
  17.     ...   
  18.     /* 加入链表 */  
  19.     list_add (node_1->list, &my_listhead);   
  20.     list_add (node_2->list, &my_listhead);   
  21.     ...   
  22.     /* 遍历链表 */  
  23.     struct my_data * node;   
  24.     struct list_head *pos;   
  25.     list_for_each (pos, &my_listhead) {   
  26.        node = list_entry (pos, struct my_data, list);   
  27.        ...   
  28.     }  

  30. struct my_data {
  31.     int x;
  32.     int y;
  33.     struct list_head list;
  34. }

  36. /* 链表头 */
  37. LIST_HEAD(my_listhead);

  39. void my_function()
  40. {
  41.     ...
  42.     /* 节点对象 */
  43.     struct my_data *node_1 = (struct my_data *) malloc(sizeof(struct my_data));
  44.     struct my_data *node_2 = (struct my_data *) malloc(sizeof(struct my_data));
  45.     ...
  46.     /* 加入链表 */
  47.     list_add (node_1->list, &my_listhead);
  48.     list_add (node_2->list, &my_listhead);
  49.     ...
  50.     /* 遍历链表 */
  51.     struct my_data * node;
  52.     struct list_head *pos;
  53.     list_for_each (pos, &my_listhead) {
  54.        node = list_entry (pos, struct my_data, list);
  55.        ...
  56.     }
复制代码


其中最精彩的部分是遍历链表的表达方式：
list_for_each (...) {
...
}
这种表达方式另我想起了Ruby，C++ STL中的到处出现的iterator，和VB中的for each...in...next语句。

从内部结构角度来看，Linux的list实现方式有点类似C++中的"组合类"——在需要放入链表的对象内部放入list类（struct list_head）。但是从遍历链表的时候，可以根据list指针得到包含list节点的对象指针来看，又有点超出了"组合类"的范畴。能否把 struct my_data看成继承了struct list_head呢？从内存映像来看倒有点像（C++子类对象的内存映像是父类对象的超级）。当然，这种强行联系完全没有必要，C就是C，何必去往C+ +套呢？C自有C的表达方式

--THE END--

注：这几篇是我原来在MSN SPACE的老blog，实在受不了MSN SPACE的速度，于是搬到了javaeye。写这些东西，只是想和使用C的同志分享自己的体验，也想告诉新学习C的同志，C语言也是很有魅力的

[ 本帖最后由 gawk 于 2008-8-24 10:00 编辑 ]
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
ygvth

论坛徽章:
0
4楼 [报告]
发表于 2008-08-24 09:58 |只看该作者
先进高级OO思想的C实现将会使软件界发生一次天翻地覆的大革命。
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
ytl

论坛徽章:
0
5楼 [报告]
发表于 2008-08-24 10:04 |只看该作者
用函数指针模拟C++成员函数会有不必要的内存开销和性能损失
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
reiase

论坛徽章:
0
6楼 [报告]
发表于 2008-08-24 10:34 |只看该作者

回复 #5 ytl 的帖子

多了一次地址的计算？
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
converse

论坛徽章:
0
7楼 [报告]
发表于 2008-08-24 10:40 |只看该作者
我靠,说真的,我现在一看到什么用C实现OO就头疼,你们发这些帖子不是明摆着把OIOIC招来吗


[ 本帖最后由 converse 于 2008-8-24 10:41 编辑 ]
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
jamesr

论坛徽章:
0
8楼 [报告]
发表于 2008-08-24 11:08 |只看该作者
提示: 作者被禁止或删除 内容自动屏蔽
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
ebwwbe

论坛徽章:
0
9楼 [报告]
发表于 2008-08-24 11:10 |只看该作者
ooc是什么？
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
IOIOC

论坛徽章:
0
10楼 [报告]
发表于 2008-08-24 11:22 |只看该作者
OIOIC 惹谁了？
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
1234567下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

  

北京盛拓优讯信息技术有限公司. 版权所有 京ICP备16024965号-6 北京市公安局海淀分局网监中心备案编号：11010802020122 niuxiaotong@pcpop.com 17352615567
未成年举报专区
中国互联网协会会员  联系我们：huangweiwei@itpub.net
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP