给出一个我用c语言简单实现的类似c++的泛型和迭代器

ztz0223

纯属无聊，在加班刷数据的时候写的，给出一个我用c语言简单实现的类似c++的泛型和迭代器，希望大家批评指正。

先说明一下，只是简单的实现了一个链表,用long和double作为链表的元素类型.
没有实现内存释放,累了不想写了.

如果大家觉得可以的话，以后把迭代器和list分离，写的有点深度点，也可以用rb－tree来实现一个set。

编译选项：

gcc  -std=c99 -o iterator  iterator.c

贴代码：

1. /*
   
2. *This program is a simple implement of c++ general prg
   
3. *and iterator design pattern.
   
4. *author: zhoutianzuo
   
5. */
   
6. #include <stdio.h>
   
7. #include <stdlib.h>
   
8. #include <malloc.h>
   
9. 
   
10. typedef struct List_Head List_Head, *p_List_Head;   
    
11. #define HEAD_LIST()                                     \
    
12.         struct List_Head {                                  \
    
13.                 struct List_Head *prev;                         \
    
14.                 struct List_Head *next;                         \
    
15.                 p_List_Head (*get_next)(p_List_Head);           \
    
16.                 p_List_Head (*get_prev)(p_List_Head);           \
    
17.         };                                                  \
    
18.     p_List_Head get_next_List_Head(p_List_Head vp_inList_Head) { \
    
19.             return vp_inList_Head->next;                                     \
    
20.     }                                                            \
    
21.                                                                  \
    
22.     p_List_Head get_prev_List_Head(p_List_Head vp_inList_Head) { \
    
23.             return vp_inList_Head->prev;                             \
    
24.     }
    
25. 
    
26. 
    
27. #define CLASS_DEFINE(CLASS_NAME, HEAD, TY)              \
    
28.         typedef struct  CLASS_NAME CLASS_NAME;              \
    
29.         typedef CLASS_NAME* iterator_##CLASS_NAME ;                    \
    
30.     struct CLASS_NAME{                                  \
    
31.                 HEAD         head_node;                         \
    
32.                 TY           value;                             \
    
33.         void         (*initial)(CLASS_NAME *);          \
    
34.         CLASS_NAME*  (*get_next)(CLASS_NAME *);         \
    
35.         CLASS_NAME*  (*get_prev)(CLASS_NAME *);         \
    
36.         CLASS_NAME*  (*end)(CLASS_NAME *);              \
    
37.         CLASS_NAME*  (*begin)(CLASS_NAME *);            \
    
38.         CLASS_NAME*  (*insert)(CLASS_NAME *, TY);       \
    
39.         CLASS_NAME*  (*delete)(CLASS_NAME *, TY);       \
    
40.         };                                                  \
    
41.     CLASS_NAME*  get_next_##CLASS_NAME(CLASS_NAME *vp_in) {                     \
    
42.                 return   (CLASS_NAME *)(vp_in->head_node.get_next(&vp_in->head_node));  \
    
43.     }                                                                           \
    
44.     CLASS_NAME*  get_prev_##CLASS_NAME(CLASS_NAME *vp_in) {                     \
    
45.                 return   (CLASS_NAME *)(vp_in->head_node.get_prev(&vp_in->head_node));  \
    
46.     }                                                                           \
    
47.     CLASS_NAME*  begin##CLASS_NAME(CLASS_NAME *vp_in) {                         \
    
48.                 return (CLASS_NAME *)(vp_in->head_node.next);                           \
    
49.     }                                                                           \
    
50.     CLASS_NAME*  end##CLASS_NAME(CLASS_NAME *vp_in) {                           \
    
51.                 return (CLASS_NAME *)(&(vp_in->head_node) );                            \
    
52.     }                                                                           \
    
53.         extern void initial_##CLASS_NAME(CLASS_NAME *);                             \
    
54.     CLASS_NAME*  insert_##CLASS_NAME(CLASS_NAME *vp_in, TY v_inValue) {         \
    
55.                 CLASS_NAME *new_node  = (CLASS_NAME *)malloc(sizeof(CLASS_NAME));       \
    
56.                 new_node->initial     = initial_##CLASS_NAME;                           \
    
57.                 new_node->initial(new_node);                                            \
    
58.                 new_node->value       = v_inValue;                                      \
    
59.                 new_node->head_node.next = vp_in->head_node.next;                       \
    
60.                 vp_in->head_node.next    = &(new_node->head_node);                      \
    
61.                 printf("Do insert successful!\n");                                      \
    
62.     }                                                                           \
    
63.     CLASS_NAME*  delete_##CLASS_NAME(CLASS_NAME *vp_in, TY v_inValue) {         \
    
64.     }                                                                           \
    
65.     void  initial_##CLASS_NAME(CLASS_NAME *vp_in) {                             \
    
66.                 vp_in->head_node.get_prev = get_prev_List_Head;                         \
    
67.                 vp_in->head_node.get_next = get_next_List_Head;                         \
    
68.                 vp_in->head_node.next = &(vp_in->head_node);                            \
    
69.                 vp_in->head_node.prev = &(vp_in->head_node);                            \
    
70.                 vp_in->get_next       = get_next_##CLASS_NAME;                          \
    
71.             vp_in->get_prev       = get_prev_##CLASS_NAME;                          \
    
72.             vp_in->insert         = insert_##CLASS_NAME;                            \
    
73.             vp_in->delete         = delete_##CLASS_NAME;                            \
    
74.             vp_in->begin          = begin##CLASS_NAME;                              \
    
75.             vp_in->end            = end##CLASS_NAME;                                \
    
76.     }
    
77. 
    
78. /*give the struct definition here.*/
    
79. HEAD_LIST()
    
80. CLASS_DEFINE(List_long, List_Head, long)
    
81. CLASS_DEFINE(List_double, List_Head, double)
    
82.        
    
83. /*ADD CALL BACK FUNCTION*/
    
84. /*must define the function here, for ......*/
    
85. 
    
86. int main()
    
87. {
    
88.         List_long * my_list = (List_long*)malloc(sizeof(List_long) );
    
89.         my_list->initial    = initial_List_long;
    
90.         my_list->initial(my_list);
    
91.        
    
92.         for(int i = 0; i < 20; i++)
    
93.             my_list->insert(my_list, 100 - 5*i);
    
94.        
    
95.         iterator_List_long my_iter =  my_list->begin(my_list);
    
96.         while(my_iter != my_list->end(my_list) ) {
    
97.                 printf("Now, the value of the iterator is %ld\n", my_iter->value);
    
98.                 my_iter = my_iter->get_next(my_iter);
    
99.     }
    
100.        
     
101.         List_double * my_list_1 = (List_double*)malloc(sizeof(List_double) );
     
102.         my_list_1->initial      = initial_List_double;
     
103.         my_list_1->initial(my_list_1);
     
104.        
     
105.         for(int i = 0; i < 20; i++)
     
106.             my_list_1->insert(my_list_1, 100.0 - 5.0*i);
     
107.        
     
108.         iterator_List_double my_iter_1 =  my_list_1->begin(my_list_1);
     
109.         while(my_iter_1 != my_list_1->end(my_list_1) ) {
     
110.                 printf("Now, the value of the iterator is %lf\n", my_iter_1->value);
     
111.                 my_iter_1 = my_iter_1->get_next(my_iter_1);
     
112.     }
     
113. 
     
114.         return 0;
     
115. }
     

复制代码

ztz0223

自己顶一个吧。

masonzhang

帮你顶吧！

souldemo

有点像C与C++搞出来的杂种。

LZ,不是说你不好。
只是感觉这样不符合C的风格。
意义不大，而且也不高效，反而低效占内存。
更不能称泛型。
但是还是支持楼主。

ztz0223

有点像C与C++搞出来的杂种。

LZ,不是说你不好。
只是感觉这样不符合C的风格。
意义不大，而且也不高效 ...
souldemo 发表于 2010-04-02 17:17

可能，用c实现c++本来就有点不伦不类，但是思想上还是向c++看齐，呵呵。

这里感觉就完全是一个c的底盘，而且，还是很偏激的c的底盘。

个人感觉，不要太过偏执。

UnixStudier

man queue
man tree