Discussion :

[godskitchen]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[oodini]

Les itérateurs (tels que spécialisés ici) permettent de se balader sur les éléments d'une liste.

Quant aux opérateurs, il n'y a aps vraiment de surcharge : par défaut, une classe quelconque n'a pas d'opérateurs +, -, etc.

[godskitchen]

Merci de ta réponse.