insertion d'objets dans une liste chainee

lorsqu'on insere un objet dans une liste chainee, il copie l'objet entierement ou il met une reference vers cet objet?

hello

ça ça dépend de la liste utilisée. c'est une classe perso où STL ?

une liste perso

implémentée comme suit:

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
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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
 
#include "ListPieces.h"
using namespace std;
 
PNode::~PNode(){
      if(elem){delete elem;cout<<"elem"<<endl;}
      if(next){delete next;cout<<"next"<<endl;}
}
 
ListPieces::ListPieces(){
         numelts = 0;
         header = new PieceNode;
         tailer = new PieceNode;
         header->next = tailer;
         header->prev = NULL;
         tailer->prev = header;
         tailer->next = NULL;
}
ListPieces::ListPieces(Piece *elem){
         numelts = 1;
         header = new PieceNode;
         tailer = new PieceNode;
         PieceNode *newnode = new PieceNode;
         newnode->elem = elem;
         header->next = newnode;
         tailer->prev = newnode;
         newnode->next = tailer;
         newnode->prev = header;
         header->prev = NULL;
         tailer->next = NULL;
}
 
ListPieces::~ListPieces(){
          delete header;
}
 
 
///////////////////////////////////////////////////////////////
//METHODES D'INFORMATION
 
/*
@pre : -
@post : renvoie la taille de la liste
*/
int const ListPieces::size() {
     return numelts;
}
 
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : renvoie un booleen true si la liste est vide false sinon
*/
bool const ListPieces::isEmpty() {
     if(numelts==0)
          return true;
     else
          return false;
}
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : renvoie un booleen true si la liste est vide false sinon
*/
Piece* ListPieces::getElement(PieceNode *node){
       return node->elem;
 
}
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
 
//METHODES D'ACCES
 
/*
@pre : -
@post : renvoie le premier noeud de la liste
*/
PieceNode* ListPieces::first() {
            return header->next;
}
 
 
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : renvoie le dernier noeud de la liste
*/
PieceNode* ListPieces::last() {
            return tailer->prev;
}
 
 
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : renvoie le noeud suivant celui donné
*/
PieceNode* ListPieces::next(PieceNode *node) {
            return node->next;
}
 
 
 
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : renvoie le noeud précédant celui donné
*/
PieceNode* ListPieces::prev(PieceNode *node) {
            return node->prev;
}
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
//METHODES DE MISE A JOUR
 
 
/*
@pre : -
@post : insère et renvoie un noeud en début de liste
*/
PieceNode* ListPieces::insertFirst(Piece *elem) {
            numelts=numelts+1;
            PieceNode *newnode = new PieceNode;
            newnode->elem=elem;
            newnode->next=header->next;
            newnode->prev=header;
            header->next->prev=newnode;
            header->next=newnode;
            return newnode;
}
 
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : insère et renvoie un noeud en fin de liste
*/
PieceNode* ListPieces::insertLast(Piece *elem) {
            numelts=numelts+1;
            PieceNode *newnode = new PieceNode;
            newnode->elem=elem;
            newnode->next=tailer;
            newnode->prev=tailer->prev;
            tailer->prev->next=newnode;
            tailer->prev=newnode;
            return newnode;
}
 
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : insère et renvoie un noeud après le noeud donné
*/
PieceNode* ListPieces::insertAfter(Piece *elem, PieceNode *pos) {
           numelts=numelts+1;
           PieceNode *newnode = new PieceNode;
           newnode->elem=elem;
           newnode->next=pos->next;
           newnode->prev=pos;
           pos->next=newnode;
           newnode->next->prev=newnode;
           return newnode;
}
 
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : insère et renvoie un noeud avant le noeud donné
*/
PieceNode* ListPieces::insertBefore(Piece *elem, PieceNode *pos) {
           numelts=numelts+1;
           PieceNode *newnode = new PieceNode;
           newnode->elem=elem;
           newnode->next=pos;
           newnode->prev=pos->prev;
           pos->prev=newnode;
           newnode->prev->next=newnode;
           return newnode;
}
 
 
///////////////////////////////////////////////////////////////

avec la structure suivante dans le header

Code:

1
2
3
4
5
6
7
8
 
typedef struct PNode{
        Piece *elem;
        struct PNode *next;
        struct PNode *prev;
 
        ~PNode();
}PieceNode;

Citation:

Envoyé par mathher

lorsqu'on insere un objet dans une liste chainee, il copie l'objet entierement ou il met une reference vers cet objet?

Citation:

Envoyé par mathher

une liste perso

En gros tu nous demandes de t'expliquer un comportement que tu as codé toi-même ? ... :koi:

A priori, vu le code d'insertion, tu stockes une copie du pointeur passé en paramètre. Donc si ce que tu appelles objet est le pointeur alors la réponse est oui (c'est une copie), s'il s'agit de l'objet pointé alors la réponse est non (le noeud va pointer sur le même objet).

En général ce que l'on fait c'est qu'on stocke des copies d'objets, à charge à l'utilisateur de faire une liste de pointeurs si ses objets ne doivent pas être copiés.

en gros je suis pas un informaticien tres performant
il m'arrive bien souvent d'implementer des trucs sans savoir ce que je fais vraiment
ce que je voulais savoir c'est si l'objet passe en argument d'une methode est une copie de l'objet ou pas
donc si j'ai bien compris lorsque l'on passe un pointeur en argument il passe une copie du pointeur
donc si je veux qu'il passe une copie de l'objet pointé je devrais plutot passer la valeur du pointeur que le pointeur lui-même c'est bien ca?

Citation:

Envoyé par mathher

donc si je veux qu'il passe une copie de l'objet pointé je devrais plutot passer la valeur du pointeur

passer l'objet pointé plutôt que le pointeur
la valeur du pointeur c'est un nombre entier (adresse mémoire de l'objet)

oui je me suis mal exprime

en gros c'est passe *pointeur plutot que pointeur