Liste doublement chaînée et itérateurs
Bonsoir à tous,
En plein apprentissage du c++ (sur le livre ppp de stroustrup) j'en arrive au chapitre sur les conteneurs et itérateurs. On désire créer notre propre classe pour définir une liste doublement chaînée. Voici la définition proposée :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
| #include <iostream>
using namespace std;
//------------------------------------------------------------------------------
template<class Elem> struct Link {
Link* prev; // previous link
Link* succ; // successor (next) link
Elem val; // the value
Link(const Elem& v = Elem(), Link* p = 0, Link* s = 0) : val(v), prev(p), succ(s) {}
};
//------------------------------------------------------------------------------
template<class Elem> class list {
// representation and implementation details
public:
class iterator; // member type: iterator
list() : first(new Link<Elem>()), last(first) {}
iterator begin(); // iterator to first element
iterator end(); // iterator to one beyond last element
iterator insert(iterator p, const Elem& v); // insert v into list after p
iterator erase(iterator p); // remove p from the list
void push_back(const Elem& v); // insert v at end
void push_front(const Elem& v); // insert v at front
void pop_front(); // remove the first element
void pop_back(); // remove the last element
Elem& front(); // the first element
Elem& back(); // the last element
Link<Elem>* first;
Link<Elem>* last; // one-beyond-the-last link
};
//------------------------------------------------------------------------------
template<class Elem> class list<Elem>::iterator {
Link<Elem>* curr; // current node
public:
iterator(Link<Elem>* p) :curr(p) { }
iterator& operator++() {curr = curr->succ; return *this; } // forward
iterator& operator--() {curr = curr->prev; return *this; } // backwards
Elem& operator*() { return curr->val; } // get value (dereference)
bool operator==(const iterator& a, const iterator& b)
{
return a.curr==b.curr;
}
bool operator!=(const iterator& a, const iterator& b)
{
return a.curr!=b.curr;
}
}; |
Je voudrais savoir si template<class Elem> class list et template<class Elem> class list<Elem>::iterator sont liées (la réponse devrait être oui) et si oui, comment le sont-ils ? Pourquoi avoir surcharger les opérateurs en définissant une classe à part ?
Merci d'avance
