C language-container implementation.

* Please refer to this document for reference from blog.csdn.net/wtz1985

I believe everyone is familiar with the container, especially Java or C #. It is just an intermediate interface, that is, a pure virtual class. Its implementation can be achieved through a linked list or array structure. Its appearance is to allow other function bodies to freely choose their own implementation structure. For example, hash tables, stacks, and other structures can be implemented by using linked lists or dynamic arrays. If there is no intermediate interface and you want to implement it separately, this is a waste of time and space.

1. interface definition.

1. /* ----- Container. h -------*/
3. # Ifndef _ container_h
4. # DEFINE _ container_h
6. Struct _ container;
7. Typedef struct _ container;
8. Yptedef void (* foreachfunc) (void * data, void * CTX );
10. Typedef void * (* containerappendfunc) (container * thiz, void * data );
11. Typedef void * (* containerinsertfunc) (container * thiz, void * data, size * index );
12. Typedef void * (* containerdeletefunc) (container * thiz, size_t index );
13. Typedef void (* containerdestroyfunc) (container * thiz );
14. Typedef void (* containerforeachfunc) (container * thiz, foreachfunc print, void * CTX );
16. Struct _ container
17. {
18. Containerappendfunc container_append;
19. Containerinsertfunc container_insert;
20. Containerdeletefunc container_delete;
21. Containerdestroyfunc container_func;
22. Containrforeachfunc container_foreach;
24. Char priv [0];
25. };
27. Static inline void * container_append (container * thiz, void * Data)
28. {
29. Assert (thiz! = NULL & thiz-> container_append! = NULL );
31. Return thiz-> container_append (thiz, data );
32. }
34. Static inline void * container_insert (container * thiz, void * data, size_t index)
35. {
36. Assert (thiz! = NULL & thiz-> container_insert! = NULL );
38. Return thiz-> container_insert (thiz, Data, index );
39. }
41. Static inline void * container_delete (container * thiz, size_t index)
42. {
43. Assert (thiz! = NULL & thiz-> container_delete! = NULL );
45. Return thiz-> container_delete (thiz, index );
46. }
48. Static inline void container_destroy (container * thiz)
49. {
50. Assert (thiz! = NULL & thiz-> container_destroy! = NULL );
52. Return thiz-> container_destroy (thiz );
53. }
55. Static inline void container_foreach (container * thiz, foreachfunc print, void * CTX)
56. {
57. Assert (thiz! = NULL & thiz-> container_foreach! = NULL );
59. Return thiz-> container_foreach (thiz, print, CTX );
60. }
62. # Endif/_ container_h/

2. Different interface implementations:

Linked List:

1. /* ------- Container_list.h ---------*/
3. # Include "container. H"
4. # Include "Dlist. H"
6. # Ifndef _ container_list_h
7. # DEFINE _ container_list_h
9. Container * container_list_create (Dlist * List );
11. # Endif/* _ container_h */

Dynamic Array:

1. /* --------- Container_vector.h -----------*/
3. # Include "vector. H"
4. # Include "container. H"
6. # Ifndef _ container_vector_h
7. # DEFINE _ container_vector_h
9. Container * container_vector_create (vector * thiz );
11. # Endif/* container_vector_h */

With these interfaces, you don't have to write any more for specific implementation. I believe everyone should know about them. If there is something bad to write, please advise.

 

~~ End ~~