iterator 问题

catbert

原帖由 converse 于 2006-3-31 13:57 发表
你的mylist是模板类?那你就只能这么写了:friend class mylist<mynode>::iterator;

不是，当都是模版的时候没有问题。

wolf0403

mylist 的完整定义贴一下。

catbert

原帖由 wolf0403 于 2006-4-1 05:46 发表
mylist 的完整定义贴一下。

1. 
   
2. #ifndef _MYLIST_H
   
3. #define _MYLIST_H
   
4. #include <iostream>
   
5. #include "mynode.h"
   
6. using namespace std;
   
7. 
   
8. class mylist::iterator;
   
9. class mylist {
   
10. public:
    
11.   class iterator;
    
12.   friend class iterator;
    
13.   mylist();
    
14.   mylist(int n, const int & item = 0);
    
15.   mylist(int *first, int *last);
    
16.   mylist(const mylist &obj);
    
17.   mylist &operator=(const mylist &rhs);
    
18.   int &back() {return header->prev->nodeValue;};
    
19.   bool empty() const {return listSize==0;};
    
20.   int &front() {return header->next->nodeValue;};
    
21.   void push_back(const int &item);
    
22.   void pop_back();
    
23.   void push_front(const int &item);
    
24.   void pop_front();
    
25.   int size() {return listSize;};
    
26.   iterator begin() {return iterator(header->next);};
    
27.   iterator end() {return iterator(header);};
    
28.   virtual ~mylist();
    
29.   class iterator {
    
30.   public:
    
31.     iterator():nodePtr(header) {};
    
32.     iterator(mynode *p):nodePtr(p){};
    
33.     bool operator==(const iterator &rhs) const {
    
34.       return (nodePtr == rhs.nodePtr);
    
35.     }
    
36.     bool operator!=(const iterator &rhs) const {
    
37.       return (nodePtr != rhs.nodePtr);
    
38.     }
    
39.     int &operator * () {
    
40.       return nodePtr->nodeValue;
    
41.     }
    
42.     iterator operator++() {
    
43.       nodePtr = nodePtr->next;
    
44.       iterator itertmp = *this;
    
45.       return itertmp;
    
46.     }
    
47.     iterator operator++(int) {
    
48.       iterator itertmp = *this;
    
49.       nodePtr = nodePtr->next;
    
50.       return itertmp;
    
51.     }
    
52.     iterator operator--() {
    
53.       nodePtr = nodePtr->prev;
    
54.       iterator itertmp = *this;
    
55.       return itertmp;
    
56.     }
    
57.     iterator operator--(int) {
    
58.       iterator itertmp = *this;
    
59.       nodePtr = nodePtr->prev;
    
60.       return itertmp;
    
61.     }
    
62.   private:
    
63.     mynode *nodePtr;
    
64.   };
    
65. private:
    
66.   mynode *header;
    
67.   int listSize;
    
68.   mynode *getnode(const int &item);
    
69.   mynode *dinsert(mynode *curr, const int &item);
    
70.   void derase(mynode *curr);
    
71. };
    
72. 
    
73. mylist::mylist():listSize(0) {
    
74.   header = new mynode;
    
75. 
    
76.   header->nodeValue = 0;
    
77.   header->next = header;
    
78.   header->prev = header;
    
79. }
    
80. mylist::mylist(int n, const int &item):listSize(n) {
    
81.   int i;
    
82.   header = new mynode;
    
83.   for (i=0; i<n; i++) {
    
84.     dinsert(header->next, item);
    
85.   }
    
86. }
    
87. 
    
88. mylist::mylist(const mylist &obj):listSize(obj.listSize) {
    
89.   mynode *curr=obj.header->next, *end=obj.header;
    
90. 
    
91.   header = new mynode;
    
92.   while (curr != end) {
    
93.     dinsert(header, curr->nodeValue);
    
94.     curr = curr->next;
    
95.   }
    
96. }
    
97. 
    
98. mylist &mylist::operator=(const mylist & rhs) {
    
99.   mynode *curr;
    
100.   if (header != rhs.header) {
     
101.     while (header->next != header) {
     
102.       curr = header->next;
     
103.       curr = curr->next;
     
104.       derase(curr->prev);
     
105.     }
     
106.     mynode *rptr;
     
107.     if (rhs.listSize != 0) {
     
108.       rptr = rhs.header;
     
109.       while (rptr->next != rhs.header) {
     
110.         push_back(rptr->next->nodeValue);
     
111.         rptr = rptr->next;
     
112.       }
     
113.     }
     
114.   }
     
115.   return *this;
     
116. }
     
117. 
     
118. void mylist::push_front(const int &item) {
     
119.   dinsert(header->next, item);
     
120.   listSize++;
     
121. }
     
122. 
     
123. void mylist::push_back(const int &item) {
     
124.   dinsert(header, item);
     
125.   listSize++;
     
126. }
     
127. 
     
128. void mylist::pop_front() {
     
129.   derase(header->next);
     
130.   listSize--;
     
131. }
     
132. 
     
133. void mylist::pop_back() {
     
134.   derase(header->prev);
     
135.   listSize--;
     
136. }
     
137. 
     
138. mylist::~mylist() {
     
139.   mynode *curr;
     
140. 
     
141.   while (header->next != header) {
     
142.     curr = header->next;
     
143.     curr = curr->next;
     
144.     derase(curr->prev);
     
145.   }
     
146. }
     
147. 
     
148. mynode* mylist::getnode(const int &item){
     
149.   mynode *curr;
     
150.   curr = new mynode;
     
151.   curr->nodeValue = item;
     
152.   return curr;
     
153. }
     
154. 
     
155. mynode* mylist::dinsert(mynode *curr, const int &item) {
     
156.   mynode *tmptr;
     
157. 
     
158.   tmptr = getnode(item);
     
159.   tmptr->prev = curr->prev;
     
160.   curr->prev->next = tmptr;
     
161.   tmptr->next = curr;
     
162.   curr->prev = tmptr;
     
163.   return tmptr;
     
164. }
     
165. 
     
166. void mylist::derase(mynode *curr) {
     
167.   curr->prev->next = curr->next;
     
168.   curr->next->prev = curr->prev;
     
169.   delete curr;
     
170. }
     
171. 
     
172. #endif
     

复制代码

[ 本帖最后由 catbert 于 2006-4-3 08:37 编辑 ]