Двусвязные списка

Какой вариант лучше?

1

Код (Text):

1. #include "list.h"
2.  
3. template <typename T>
4. class TList {
5. public:
6.     LIST_ENTRY head;
7.     CRITICAL_SECTION lock;
8.    
9.     struct TListEntry {
10.         LIST_ENTRY list;
11.         T data;
12.     };
13.    
14.     TList() {
15.         INIT_LIST_HEAD(&head);
16.         InitializeCriticalSection(&lock);
17.     }
18.  
19.     ~TList() {
20.         list_for_each(pos,&head) {
21.             Remove(pos);
22.         }
23.         DeleteCriticalSection(&lock);
24.     }
25.    
26.     void Remove(LIST_ENTRY *list) {
27.         TListEntry *entry = (TListEntry *)list;
28.         UNLINK_ENTRY(&entry->list);
29.         delete entry;
30.     }
31.  
32.     void Clear() {
33.         list_for_each(pos,&head) {
34.             T data = Data(pos);
35.             delete data;
36.             Remove(pos);
37.         }
38.     }
39.  
40.     void Add(T data) {
41.         TListEntry *entry = new TListEntry;
42.         if (entry) {
43.             entry->data = data;
44.             ADD_ENTRY_TAIL(&head,&entry->list);
45.         }
46.     }
47.  
48.     inline T Data(LIST_ENTRY *list) {
49.         return ((TListEntry*)list)->data;
50.     }
51.  
52.     inline void Lock() {
53.         EnterCriticalSection(&lock);       
54.     }
55.  
56.     inline void Unlock() {
57.         LeaveCriticalSection(&lock);   
58.     }
59. };

list.h:

Код (Text):

1. #define INIT_LIST_HEAD(head) \
2.     (head)->Flink = (head); \
3.     (head)->Blink = (head)
4.  
5. #define UNLINK_ENTRY(entry) \
6.     (entry)->Blink->Flink = (entry)->Flink; \
7.     (entry)->Flink->Blink = (entry)->Blink
8.  
9. #define ADD_ENTRY(head,entry) \
10.     (entry)->Flink=(head)->Flink; \
11.     (entry)->Blink=(head); \
12.     (head)->Flink->Blink = (entry); \
13.     (head)->Flink = (entry)
14.  
15. #define ADD_ENTRY_TAIL(head,entry) \
16.     (head)->Blink->Flink = (entry); \
17.     (entry)->Blink = (head)->Blink; \
18.     (entry)->Flink = (head); \
19.     (head)->Blink = (entry)
20.  
21. #define get_list_entry(type,entry)  (type)(entry)
22.  
23. #define list_for_each(pos, head) \
24.     for (LIST_ENTRY *pos = (head)->Flink, *__safe_pos__ = pos->Flink; pos != (head);\
25.         pos = __safe_pos__, __safe_pos__ = (pos)->Flink)

2

Код (Text):

1. template <typename T>
2. class ZList {
3.     struct ZListEntry {
4.         ZListEntry *next;
5.         ZListEntry *prev;
6.         T data;
7.     };
8.     CRITICAL_SECTION ZListLock;
9. public:
10.     ZListEntry *first, *last;
11.  
12.     class iterator {
13.         friend class ZList;
14.         ZListEntry *pos_next, *pos_prev, *pos;
15.  
16.     public:
17.         iterator(ZListEntry *entry) {
18.             pos = entry;
19.             if (pos) {
20.                 pos_next = pos->next;
21.                 pos_prev = pos->prev;
22.             } else {
23.                 pos_next = pos_prev = 0;
24.             }
25.         }
26.  
27.         void operator ++(int) {
28.             pos = pos_next;
29.             if (pos) {
30.                 pos_next = pos->next;
31.             } else {
32.                 pos_next = 0;
33.             }
34.         }
35.  
36.         void operator --(int) {
37.             pos = pos_prev;
38.             if (pos) {
39.                 pos_prev = pos->prev;
40.             } else {
41.                 pos_prev = 0;
42.             }
43.         }
44.  
45.         ZListEntry* operator *(void) {
46.             return pos;
47.         }
48.  
49.     };
50.        
51.     ZList() {
52.         first = last = 0;
53.         InitializeCriticalSection(&ZListLock);
54.     }
55.  
56.     ~ZList() {
57.         //Clear();
58.         DeleteCriticalSection(&ZListLock);
59.     }
60.  
61.     void Clear() {
62.         T data;
63.         for (iterator i = iterator(first);*i;i++) {
64.             data = Data(i.pos);
65.             delete data;
66.             Unlink(i.pos);
67.         }
68.     }
69.  
70.     void Add(T data) {
71.         ZListEntry *entry = new ZListEntry;
72.         if (entry) {
73.             entry->data = data;
74.             if (last) {
75.                 last->next = entry;
76.                 entry->prev = last;
77.             }
78.             last = entry;
79.             if (!first) {
80.                 first = entry;
81.             }
82.         }
83.     }
84.  
85.     void Unlink(ZListEntry *entry) {
86.         if (entry->prev) {
87.             (entry->prev)->next = entry->next;
88.         } else {
89.             first = entry->next;
90.         }
91.         if (entry->next) {
92.             (entry->next)->prev = entry->prev;
93.         } else {
94.             last = entry->prev;
95.         }
96.         delete entry;
97.     }
98.  
99.     T Data(ZListEntry *entry) {
100.         T retval = (T)0;
101.         if (entry) {
102.             retval = entry->data;
103.         }
104.         return retval;
105.     }
106.  
107.     void Lock() {
108.         EnterCriticalSection(&ZListLock);
109.     }
110.  
111.     void Unlock() {
112.         LeaveCriticalSection(&ZListLock);
113.     }
114.  
115. };

Не тестилось особо, возможны ошибки.
Оба варианта гавно? Но тогада предложите свой, STL юзать нельзя

 

итераторы всегда прикольные.

 

Зачем лок, внешняя по смыслу сущность, инкапсулирован в списки? См scoped_lock в бусте.

Тебя обманули.