Discussion :

[oswalidos]

j'ai écrit une classe implémentant une liste doublement chainée circulaire,le destructeur ne fonctionne pas , je travaille sous xp avec code::blocks .
merci d'avance

le code :

Code c++ :

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
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
/*Expression.h*/
#include <iostream>
 
using namespace std;
 
class Expression{
    public:
    Expression();
    bool insertion_dans_liste_vide (int donnee);
    bool ins_fin_liste (int donnee);
    void affiche();
    ~Expression();
 
    struct ElementListe {
        int  donnee;
        ElementListe *suivant;
        ElementListe *precedent;
    };
 
 
    private:
    int taille;
    ElementListe *debut;
    ElementListe *fin;
};
 
 
/*Expression.cpp*/
 
#include "Expression.h"
 
Expression::Expression(){
    debut = NULL;
    fin = NULL;
    taille = 0;
}
 
Expression::~Expression(){
    ElementListe *courant = this->fin->precedent;
    while (courant!=(this->debut)){
        delete courant->suivant;
        cout << "deleted !" << endl;
        courant=courant->precedent;
    }
    cout << "everything is deleted !" << endl;
}
 
bool Expression::insertion_dans_liste_vide (int donnee){
  ElementListe *nouveau_element;
  if (!(nouveau_element = new ElementListe))
    return false;
  nouveau_element->donnee = donnee;
  nouveau_element->precedent = nouveau_element;
  nouveau_element->suivant = nouveau_element;
  this->debut = nouveau_element;
  this->fin = nouveau_element;
  this->taille++;
  return true;
}
 
bool Expression::ins_fin_liste (int donnee){
  ElementListe *nouveau_element;
  if (!(nouveau_element = new ElementListe))
    return false;
  nouveau_element->donnee = donnee;
  nouveau_element->suivant = this->debut;
  nouveau_element->precedent = this->fin;
  this->fin->suivant = nouveau_element;
  this->fin = nouveau_element;
  this->fin->suivant = this->debut;
  this->taille++;
  return true;
}
 
void Expression::affiche(){
  ElementListe *courant;
  courant = this->debut;
  printf("[ ");
  int i=0;
  while(i<(this->taille)){
    printf("%d ",courant->donnee);
    courant = courant->suivant;
	i++;
  }
  printf("]\n");
}

[Captain_JS]

Qu'est-ce que tu entends par "ne fonctionne pas" ?

Pointeur non initialisé ? genre pas d'élément dans ta liste et this->fin à NULL ?

(pour info debut n'est pas détruit ...)

[koala01]

Salut,

Je me pose une question existentielle...

Pourquoi diantre partir de fin->precedent et parcourrir la liste "à l'envers" alors que tu pourrais partir de debut ("tout court") et parcourrir les éléments jusqu'à arriver à fin (compris), mais "à l'endroit"

De la même manière, j'avouerai avoir du mal à comprendre pourquoi tu fais le distingo entre l'insertion dans une liste vide et l'insertion en fin de liste...

Après tout, la seule différence qui existe, c'est que le premier élément et le dernier se confondent lorsque la liste est vide

En gros, tu pourrais donc simplifier ton interface (et éviter qu'un imbécile distrait n'essaye de rajouter un élément dans la liste vide alors que... la liste n'est pas vide) en modifiant l'algorithme d'insertion en conséquence, sous une forme proche de

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
/* plutot que de renvoyer une valeur booléenne, renvoyons une référence
 * sur la liste, afin de pouvoir enchaîner les appels
 */
Expression& Expression::insert(int val)
{
    /* création de l'élément à rajouter */
    ElementList *toadd = new ElementList;
    /*initialisation des membres */
    toadd->donnee = val;
    /* l'élément qui le précède est de toutes manière le dernier de la liste 
     */
    toadd->precedent = fin;
    /* et celui qui le suit, étant donné que nous sommes dans une 
     * liste circulaire est de toutes manières le premier de la liste 
     */
    toadd->suivant = debut;
    /* il est temps d'insérer l'élément dans la liste */
    /* S'il existe un dernier élément dans la liste, nous faisons pointer sa 
     * référence "suivant" vers le nouvel élément
     */
    if(fin)
        fin->suivant = toadd;
    /* S'il existe un premier élément dans la liste, nous faisons pointer sa 
     * référence "precedent sur le nouvel element
     */
    if(debut)
        debut->precedent = toadd;
    else
    {
        /* par contre, si la liste est vide, le nouvel élément devient le
         * premier de la liste, et ses deux références pointent vers
         * lui-même
         */
        debut = toadd;
        toadd->precedent = toadd;
        toadd->suivant = toadd;
    }
    /* quoi qu'il en soit, l'élément ajouté devient le dernier élément de
     * la liste et nous mettons le nombre d'éléments à jour
     */
    fin = toadd;
    taille++;
    /* nous pouvons maintenant renvoyer une référence sur notre liste
     * circulaire
     */
    return  *this;
}

De la même manière, il n'y a pas lieu de faire compliqué lorsque l'on peut faire simple, et le destructeur devrait ressembler à ceci:

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
Expression::~Expression
{
    /* si la liste est vide, il n'y a rien à faire
     * il n'y a que si elle ne l'est pas qu'il faudra tout libérer
     */
    if(debut!=0)
    {
        /* il va nous falloir deux pointeurs "temporaires":
         * le premier pour représenter l'élément à supprimer,
         * le second pour représenter l'élément qui suit celui que l'on
         * s'apprête à supprimer
         *
         * Le premier élément que nous supprimerons sera... le premier
         * de la liste
         * et, fatalement, son suivant sera celui qui le suit 
         */
        ElementList *todel = debut;
        ElementList *suivant = todel->suivant;
        /* nous allons maintenant travailler jusqu'à ce que l'élément qui 
         * suit celui qu'on a supprimé (ou qu'on est sur le point de
         * supprimer) ne nous ramène sur le premier
        */
        do
        {
            /* pour etre propre, mettons les liens à NULL */
            todel->precedent = NULL;
            todel->suivant = NULL;
            /* et effacons l'élément */
            delete todel;
            /* l'élément suivant devient celui qui devra etre supprimé
             */
            todel = suivant;
            /* et l'élément qui le suit devient l'élément... qui suit celui
             * qui doit être supprimé
             */
            suivant = todel->suivant;
        } while( suivant==debut );
    } // fin de la vérification de liste vide
    /* pour etre propre, mettons debut et fin à NULL */
    debut = NULL;
    fin = NULL;
}

NOTA: j'ai mis énormément de commentaires, lis les, ils te permettront de comprendre l'idée que j'ai mise en oeuvre

[oswalidos]

merci pour ce réponse extrèmement claire

[Goten]

Je rajouterais que tu n'es pas obligé d'accéder aux données membres de cette façon :
this->

Enfin ça n'affecte pas les performances (ça mérite confirmation par les 'pros') mais ça te simplifierait l'écriture!

[oswalidos]

desolé ! mais je n'ai pas pas compris cette derniere remarque, alors si je n'accede pas avec this au fonctions et variables membre(de l'objet courant),avec quoi je peux y acceder ?
et c'est bien ou mauvais coté compilateur ?

[ram-0000]

Je rajouterais que tu n'es pas obligé d'accéder aux données membres de cette façon : this->

si je n'accede pas avec this au fonctions et variables membre(de l'objet courant),avec quoi je peux y acceder ?

Dans ton code, quand tu écris :

Code :

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

while (courant!=(this->debut)){

tu peux aussi écrire :

Code :

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

while (courant!=debut){

Comme tu est dans une fonction de la classe, celle ci peut manipuler tous les membres de la classe sans avoir à redire "this->".

et c'est bien ou mauvais coté compilateur ?

Quant à savoir si l'exécution avec ou sans "this->" est plus rapide, je suppose qu'au moins en mode release, l'optimiseur de code fait son travail et qu'il n'y a aucune différence de temps d'exécution.

[Goten]

En effet c'est bien ce qu'il me semblait : c'est traité pareil du côté compilateur.

C'est surtout que sa simplifie largement la vie... car ce taper this-> à chaque fois c'est long!

[oswalidos]

vous avez raison , merci encore !