04.05.2019, 14:56. Показов 4947. Ответов 0
У меня было задание:создать класс двусвязного списка с возможностью добавления элементов,их редактирования и удаления.При этом список содержит разные типы данных(float,int,char).Для изменения списка нужен итератор.В нём должна быть перегрузка операторов +,++,+= и т.д.,как я понял.Я понял,что примерно должны они делать,но я не могу это реализовать.
Вот то,что я написал:
List.h
| C++ |
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
| #ifndef LIST_H
#define LIST_H
using namespace std;
template <typename TYPE>
class Iterator;
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
struct Elements
{
TYPE data; // Тип данных характеристик объекта
Elements * next, // Следующий элемент списка
* prev; // Предыдущий элемент списка
};
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
class List
{
//----------------------------------------------------------------------------------------------------------------------------------------
public:
friend class Iterator<TYPE>;
List(); // Конструктор
List(const List&); // Конструктор копирования
~List(); // Деструктор
int GetCount(); // Получить количество элементов
void ClearList(); // Удалить весь список
void Delete(int pos = 0); // Удаление элемента списка
void Insert(int pos = 0); // Вставка элемента на выбранную позицию
void AddHead(Elements<TYPE> n); // Добавление в начало списка
void AddTail(Elements<TYPE> n); // Добавление в конец списка
void Print(int pos); // Печать определенного элемента
void Print(); // Печать списка
Elements<TYPE>* GetElem(int); // Получить элемент списка
class Iterator
{
public:
friend class List<TYPE>;
Elements<TYPE> operator ++ (); // Перемещает итератор на следующее значение и возвращает итератор на новое значение
Elements<TYPE> operator + (int i) const; // Перемещает итератор на i значений вперед
Elements<TYPE> operator ++ (int); // Перемещает итератор на следующее значение и возвращает итератор на прошлое значение
Elements<TYPE>& operator+=(int i); // Перемещает итератор на i значений дальше и возвращает его
Elements<TYPE> operator - (int i) const; // Перещает итератор на i значений назад
Elements<TYPE> operator -- (); // Перемещает итератор на прошлое значение и вовзращает итератор на новое значение
Elements<TYPE> operator -- (int); // Перемещает итератор на прошлое значение и возвращает итератор на прошлое значение
Elements<TYPE> &operator * () const; // Возвращает ссылку на указываемое значение
Elements<TYPE>* operator->() const; // Возвращает указатель на указываемое значение
Elements<TYPE>& operator-=(int i); // Перемещает итератор на i значений назад и возвращает его
protected:
private:
};
//----------------------------------------------------------------------------------------------------------------------------------------
protected:
//----------------------------------------------------------------------------------------------------------------------------------------
private:
Elements<TYPE> * Head, // Голова списка
* Tail; // Хвост списка
int Count; // Количество элементов в списке
Elements<TYPE> data;
//----------------------------------------------------------------------------------------------------------------------------------------
};
#endif // LIST_H |
|
List.cpp
| C++ |
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
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
| #include "List.h"
#include <iostream>
#include <cstddef>
using namespace std;
//----------------------------------------------------------------------------------------------------------------------------------------
// Конструктор
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
List<TYPE>::List()
{
Head = Tail = NULL; // Изначально список пуст
Count = NULL;
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Деструктор
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
List<TYPE>::~List()
{
ClearList(); // Удалить все элементы списка
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Конструктор копирования
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
List<TYPE>::List(const List & L)
{
Head = Tail = NULL;
Count = NULL;
Elements<TYPE> * temp = L.Head; // Голова списка, из которого копируем
while(temp != NULL) // Пока не конец списка
{
AddTail(temp->data); // Передираем данные
temp = temp->next;
}
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Добавление в начало списка
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
void List<TYPE>::AddHead(Elements<TYPE> n)
{
Elements<TYPE> * temp = new Elements<TYPE>; // Новый элемент
temp->prev = NULL; // Предыдущего нет
temp->data = n; // Заполняем данные
temp->next = Head; // Следующий - бывшая голова
if(Head != NULL) // Если элементы есть
Head->prev = temp;
if(Count == 0) // Если элемент первый, то он одновременно и голова и хвост
Head = Tail = temp;
else // Иначе новый элемент - головной
Head = temp;
Count++;
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Добавление в конец списка
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
void List<TYPE>::AddTail(Elements<TYPE> n)
{
Elements<TYPE> * temp = new Elements<TYPE>; // Создаем новый элемент
temp->next = NULL; // Следующего нет
temp->data = n; // Заполняем данные
temp->prev = Tail; // Предыдущий - бывший хвост
if(Tail != NULL) // Если элементы есть
Tail->next = temp;
if(Count == 0) // Если элемент первый, то он одновременно и голова и хвост
Head = Tail = temp;
else // Иначе новый элемент - хвостовой
Tail = temp;
Count++;
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Вставка элемента на выбранную позицию
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
void List<TYPE>::Insert(int pos)
{
if(pos == 0) // Если параметр отсутствует или равен 0, то запрашиваем его
{
cout << "Введите позицию: ";
cin >> pos;
}
if(pos < 1 || pos > Count + 1) // Позиция от 1 до Count
{
cout << "Неверная позиция!\n";
return;
}
if(pos == Count + 1) // Если вставка в конец списка
{
Elements<TYPE> data; // Вставляемые данные
cout << "Введите новый номер: ";
cin >> data;
AddTail(data); // Добавление в конец списка
return;
}
else if(pos == 1)
{
Elements<TYPE> data; // Вставляемые данные
cout << "Введите новый номер: ";
cin >> data;
AddHead(data); // Добавление в начало списка
return;
}
int i = 1; // Счетчик
Elements<TYPE> * Ins = Head; // Отсчитываем от головы n - 1 элементов
while(i < pos)
{
Ins = Ins->next; // Доходим до элемента,перед которым вставляем
i++;
}
Elements<TYPE> * PrevIns = Ins->prev; // Доходим до элемента,который предшествует
Elements<TYPE> * temp = new Elements<TYPE>; // Создаем новый элемент
cout << "Введите новый элемент: "; // Вводим данные
cin >> temp->data;
if(PrevIns != NULL && Count != 1) // Настройка связей
PrevIns->next = temp;
temp->next = Ins;
temp->prev = PrevIns;
Ins->prev = temp;
Count++;
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Удаление элемента списка
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
void List<TYPE>::Delete(int pos)
{
if(pos == 0) // Если параметр отсутствует или равен 0, то запрашиваем его
{
cout << "Введите позицию: ";
cin >> pos;
}
if(pos < 1 || pos > Count) // Позиция от 1 до Count
{
cout << "Неверная позиция!\n";
return;
}
int i = 1; // Счетчик
Elements<TYPE> * Del = Head;
while(i < pos)
{
Del = Del->next; // Доходим до элемента,который удаляется
i++;
}
Elements<TYPE> * PrevDel = Del->prev; // Доходим до элемента,который предшествует удаляемому
Elements<TYPE> * AfterDel = Del->next; // Доходим до элемента, который следует за удаляемым
if(PrevDel != NULL && Count != 1) // Если удаляем не голову
PrevDel->next = AfterDel;
if(AfterDel != NULL && Count != 1) // Если удаляем не хвост
AfterDel->prev = PrevDel;
if(pos == 1) // Удаляются крайние
Head = AfterDel;
if(pos == Count)
Tail = PrevDel;
delete Del; // Удаление элемента
Count--;
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Печать определенного элемента
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
void List<TYPE>::Print(int pos)
{
if(pos < 1 || pos > Count) // Позиция от 1 до Count
{
cout << "Неверная позиция!\n";
return;
}
Elements<TYPE> * temp;
if(pos <= Count / 2) // Определяем с какой стороны быстрее двигаться
{
temp = Head; // Отсчет с головы
int i = 1;
while(i < pos)
{
temp = temp->next; // Двигаемся до нужного элемента
i++;
}
}
else
{
temp = Tail; // Отсчет с хвоста
int i = 1;
while(i <= Count - pos)
{
temp = temp->prev; // Двигаемся до нужного элемента
i++;
}
}
cout << pos << " Элемент: "; // Вывод элемента
cout << temp->data << endl;
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Печать списка
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
void List<TYPE>::Print()
{
if(Count != 0) // Если в списке присутствуют элементы, то пробегаем по нему и печатаем элементы, начиная с головного
{
Elements<TYPE> * temp = Head;
cout << "( ";
while(temp->next != NULL)
{
cout << temp->data << ", ";
temp = temp->next;
}
cout << temp->data << " )\n";
}
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Удалить весь список
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
void List<TYPE>::ClearList()
{
while(Count != 0) // Пока остаются элементы, удаляем по одному с головы
Delete(1);
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Вставка элемента на выбранную позицию
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
int List<TYPE>::GetCount()
{
return Count;
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Получить элемент списка
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
Elements<TYPE> * List<TYPE>::GetElem(int pos)
{
Elements<TYPE> *temp = Head;
if(pos < 1 || pos > Count) // Позиция от 1 до Count
{
cout << "Неверная позиция!\n";
return 0;
}
int i = 1;
while(i < pos && temp != NULL) // Ищем нужный нам элемент
{
temp = temp->next;
i++;
}
if(temp == NULL)
return 0;
else
return temp;
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Перемещает итератор на следующее значение и возвращает итератор на новое значение
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
Elements<TYPE> List<TYPE>::Iterator::operator ++()
{
data = data->next;
return *data;
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Перемещает итератор на i значений вперед
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
Elements<TYPE> List<TYPE>::Iterator::operator + (int i) const
{
for (int start = 0; i >= start; start++)
data = data->next;
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Перемещает итератор на следующее значение и возвращает итератор на прошлое значение
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
Elements<TYPE> List<TYPE>::Iterator::operator ++ (int)
{
Elements<TYPE> *temp = data->next;
data = data->next;
return *temp;
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Перемещает итератор на i значений дальше и возвращает его
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
Elements<TYPE>& List<TYPE>::Iterator::operator+=(int i)
{
for (int start = 0; i >= start; start++)
data = data->next;
return *data;
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Перещает итератор на i значений назад
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
Elements<TYPE> List<TYPE>::Iterator::operator - (int i) const
{
for (int start = 0; i >= start; start++)
data->prev;
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Перемещает итератор на прошлое значение и вовзращает итератор на новое значение
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
Elements<TYPE> List<TYPE>::Iterator::operator -- ()
{
Elements<TYPE> *temp = data->prev;
data = data->prev;
return *temp;
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Перемещает итератор на прошлое значение и возвращает итератор на прошлое значение
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
Elements<TYPE> List<TYPE>::Iterator::operator -- (int)
{
data = data->prev;
Elements<TYPE> *temp = data->prev;
return *temp;
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Возвращает ссылку на указываемое значение
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
Elements<TYPE>& List<TYPE>::Iterator::operator * () const
{
return data;
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Возвращает указатель на указываемое значение
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
Elements<TYPE>* List<TYPE>::Iterator::operator->() const
{
return *data;
}
//----------------------------------------------------------------------------------------------------------------------------------------
// Перемещает итератор на i значений назад и возвращает его
//----------------------------------------------------------------------------------------------------------------------------------------
template <typename TYPE>
Elements<TYPE>& List<TYPE>::Iterator::operator-=(int i)
{
for (int start = 0; i >= start; start++)
data = data->prev;
return *data;
} |
|
Возможно,что я не все операторы перегружаю.Я хотел для начала разобраться с этой частью,а затем смотреть,чего не хватает.
не могу понять,как правильно перегрузить операторы в данной ситуации.Я только начал изучать списки,поэтому код взял готовый,но переделал его под мой случай.Прошу помощи!
(
