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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
| #ifndef __LISTE__
#define __LISTE__
#include <iostream>
/*la classe Noeud contient la valeur stocké dans la liste et le pointeur vers l'element suivant*/
template<typename T>
class Noeud
{
/*pour utiliser dans la classe Iterator la classe noeud sans passer par les getteurs et setteurs*/
friend class Iterator;
friend class IteratorW;
private:
T val;
Noeud *suivant;
public:
Noeud(const Noeud &n)
{
Noeud no(n);
std::swap(this->val, no.val);
std::swap(this->suivant, no.suivant);
}
Noeud(T val, Noeud *n = NULL) : val(val), suivant(n)
{
}
T getVal()const
{
return this->val;
}
Noeud* getSuivant()const
{
return this->suivant;
}
void setVal(const T &val)
{
this->val = val;
}
void setSuivant(Noeud *n)
{
this->suivant = n;
}
Noeud& operator=(const Noeud &n)
{
Noeud tmp = n;
std::swap(this->val, tmp.val);
std::swap(this->suivant, tmp.suivant);
return *this;
}
};
/*classe qui contient un élément de tete et quelques fonctions sur les listes comme l'empilage et le depilage*/
/*ici les méthodes n'ont pas a etre inline*/
template<typename T>
class Liste
{
/*idem que la classe Noeud*/
friend class Iterator;
private:
Noeud<T> *tete;
public:
Liste();
Liste(const Liste<T> &l);
~Liste();
void Empiler(T val);
T Depiler();
void Enfiler(T val);
T Defiler();
friend std::ostream& operator<<(std::ostream &o, const Liste<T> &l);
Liste<T>& operator=(const Liste<T> &l);
};
/*classe qui permet de se déplacer librement dans la liste sans avoir a toucher à la tete de liste de la classe Liste*/
template<typename T>
class Iterator
{
protected:
Noeud<T> **courant;
Liste<T> *liste;
public:
Iterator(const Iterator<T> &i) : courant(i.courant), liste(i.liste)
{
}
Iterator(const Liste<T> &l)
{
liste = const_cast<Liste<T>*> (&l);
Liste<T> *laux = const_cast<Liste<T>*> (&l);
this->courant = &(laux->tete);
}
/*verifie que l'element suivant existe : si le pointeur courant == null => pas d'element suivant*/
bool hasNext()const
{
return ((*courant) == NULL) ? false : true;
}
/*obtenir l'element suivant*/
void getNext()
{
courant = &((*courant)->suivant);
}
/*retourne l'entier stocke dans le noeud courant de la liste*/
T getCurrent()const
{
return (*courant)->val;
}
/*retourne au debut de la liste*/
void rewind()
{
courant = &(liste->tete);
}
/*incrementation => raccourcis de getNext()*/
Iterator& operator++()
{
this->getNext();
return *this;
}
};
/*classe qui permet de faire des modifications sur la liste a partir d'un iterateur*/
template<typename T>
class IteratorW : public Iterator<T>
{
public:
IteratorW(const IteratorW &i) : Iterator<T>(i)
{
}
IteratorW(const Liste<T> &l) : Iterator<T>(l)
{
}
void Inserer(T val)
{
*this->courant = new Noeud<T>(val, (*this->courant));
}
void Supprimer()
{
Noeud<T> *aux = *this->courant;
*this->courant = (*this->courant)->suivant;
delete aux;
}
};
#endif |
