Шаблон:Template:H
#ifndef SET_H
- define SET_H
- include "SetItem.h"
- pragma once
template <typename TYPE> class Set {
template <typename Ticket> friend class Race;
protected:
SetItem<TYPE> *_begin,
*_end;
int _size;
public:
class iterator;
/*Итераторы*/
Set<TYPE>();
/**/
Set<TYPE>(const Set<TYPE> &q);
/*Конструктор копий*/
bool operator<<(const TYPE &value);
/*Добавление нового элемента*/
bool operator=(const Set<TYPE> &q);
/*Присвоение*/
Set<TYPE> operator+(const Set<TYPE>& s1);
/*Объединение множеств*/
Set<TYPE> operator*(const Set<TYPE>& s1);
/*Пересечение множеств*/
void erase(iterator &target);
void erase(const iterator &first, const iterator &last);
/*Очищает с first по last*/
void clear();
/*Очищает полностью*/
int size();
/*Количество элементов*/
bool search(const TYPE &value);
/*TRUE если value есть во множестве*/
bool empty();
/*TRUE если множество пустое*/
SetItem<TYPE>* begin();
/*Возвращает ссылку на первый элемент*/
SetItem<TYPE>* end();
/*Возвращает ссылку на последний элемент*/
};
template <typename TYPE> int Set<TYPE>::size() {
return _size;
}
template <typename TYPE> Set<TYPE>::Set() {
_begin = 0;
_end = 0;
_size = 0;
}
template <typename TYPE> Set<TYPE>::Set(const Set<TYPE> &q) {
_begin = 0;
_end = 0;
_size = 0;
(*this) = q;
}
template <typename TYPE> bool Set<TYPE>::operator<<(const TYPE &value) {
SetItem<TYPE> *pt = new SetItem<TYPE>(value);
SetItem<TYPE> *cur = _end;
if (empty()) {
_begin = _end = pt;
cur = new SetItem<TYPE>(value);
_end->next = cur;
cur->prev = _end;
_end = cur;
_size++;
}
else if (!(search(value))) {
_end->prev->next = pt;
pt->prev = _end->prev;
pt->next = _end;
_end->prev = pt;
_size++;
}
return true;
}
template <typename TYPE> bool Set<TYPE>::operator=(const Set<TYPE> &q) {
this->clear();
iterator cur = q._begin;
while (cur != q._end) {
(*this) << (*cur);
++cur;
}
return true;
}
template <typename TYPE> Set<TYPE> Set<TYPE>::operator+(const Set<TYPE>& s1) {
Set<TYPE> tmp(*this);
for (iterator cur = s1._begin; cur != s1._end; cur++) {
tmp << cur.iter->item;
}
return tmp;
}
template <typename TYPE> Set<TYPE> Set<TYPE>::operator*(const Set<TYPE>& s1) {
Set<TYPE> tmp;
for (iterator cur = s1._begin; cur != s1._end; cur++) {
if (search(cur.iter->item)) {
tmp << cur.iter->item;
}
}
return tmp;
}
template <typename TYPE> bool Set<TYPE>::search(const TYPE &value) {
iterator current = _begin;
while (current != _end) {
if ((*current) == value) {
return true;
}
++current;
}
return false;
}
template <typename TYPE> void Set<TYPE>::erase(const iterator &_first, const iterator &_last) {
Set<TYPE> *tmp = new Set<TYPE>();
iterator first = _first,
last = _last;
while (first != _begin) {
--first;
(*tmp) << *first;
}
while (last != _end) {
(*tmp) << *last;
++last;
}
iterator it = this->_begin;
while (it != _end) {
iterator tmp = it;
++it;
delete tmp.iter;
}
_size = 0;
this->_begin = tmp->_begin;
this->_end = tmp->_end;
this->_size = tmp->_size;
}
template <typename TYPE> void Set<TYPE>::clear() {
iterator it1 = this->begin(),
it2 = this->end();
erase(it1, it2);
_size = 0;
}
template <typename TYPE> bool Set<TYPE>::empty() {
return (_size == 0);
}
template <typename TYPE> SetItem<TYPE>* Set<TYPE>::begin() {
return _begin;
}
template <typename TYPE> SetItem<TYPE>* Set<TYPE>::end() {
return _end;
}
template <typename TYPE> class Set<TYPE>::iterator {
friend class Set;
private:
SetItem<TYPE> *iter;
public:
iterator(SetItem<TYPE>* pt) {
iter = pt;
}
TYPE operator*() {
return iter->item;
}
virtual bool operator=(SetItem<TYPE>* pt) {
iter = pt;
return true;
}
bool operator++() {
SetItem<TYPE> *pt = iter;
iter = pt->next;
return true;
}
bool operator--() {
SetItem<TYPE> *pt = iter;
iter = pt->prev;
return true;
}
bool operator!=(const iterator &Q) {
return (iter != Q.iter);
}
bool operator==(const iterator &Q) {
return (iter == Q.iter);
}
bool operator==(const SetItem<TYPE>* Q) {
return (iter == Q);
}
};
- endif