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
| class ElementList
{
/* par facilité, déclarons la liste amie de la classe ElementList */
friend class List;
public:
/* construction */
ElementList(Type const & t):value_(t),next_(NULL)
/* éventuellement , previous_(NULL) */
{
}
/* copie */
ElementList(ElementList const & rhs):value_(rhs.value_),next_(NULL)
/* éventuellement , previous_(NULL) */
{
}
/* assignation */
ElementList & operator=(ElementList const & rhs)
{
/* comme nous voulons que l'opérateur = nous fournisse une copie
* de l'élément qui arrive après, nous utilisons l'idiome copy and
* swap
*/
ElementList temp(rhs); // appelle le constructeur par copie
std::swap(value_,temp.value_); /* interverti les valeurs*/
std::swap(next_,temp.next_); /* interverti les références vers
* l'élément suivant
*/
/* éventuellement
std::swap(previous_, temp.previous_); /* interverti les références
* vers l'élément précédent
*/
return *this;
}
/* destruction */
~ElementList()
{
/* il n'y a pas de gestion dynamique de la mémoire dans ElementList
* Le destructeur n'a donc rien à faire
*
* (nous aurions même pu garder son comportement par défaut)
*/
}
private:
Type value_;
ElementList * next_;
/* éventuellement
ElementList * previous_;
};
class List
{
public:
/* construction (d'une liste vide) */
Liste():first_(NULL), /*éventuellement , last_(NULL), size_(0) */
{
}
/* copie */
List(List const & rhs)
{
/* la copie devra insérer une copie de chaque élément de la liste
* d'origine
*/
for(ElementList * it=rhs->first_;it!=rhs->last_;++i)
push_back((*it));
}
/* affectation */
List & operator = (List const & rhs)
{
/* lorsque l'on affecte une liste à une liste autre, il faut:
* - affecter une copie de la liste de "destination" à la liste
* "source"
* - veiller à ce que le contenu d'origine de la liste soit
* correctement détruit
*
* l'idiome copy and swap nous y aide :D
*/
List temp(rhs);
std::swap(first_,temp.first_);
/* éventuellement
std::swap(last_,temp.last_);
std::swap(size_,temp.last_);
*/
return *this;
}
/* destruction */
~List()
{
/* lorsqu'une liste est détruite, il faut veiller à détruire l'ensemble
* de ses éléments
*/
ElementList* temp;
while(first_)
{
temp= first_->next;
delete first_;
first = temp;
}
last_=NULL;
size=0;
}
private:
ElementList * first_;
/* éventuellement */
ElementList * last_;
/* et, éventuellement, pour pouvoir savoir le nombre
* d'éléments contenus dans la liste en temps constant
*/
size_t size_;
}; |
Partager