Шаблон:Template:H

#ifndef SET_H

1. define SET_H

1. include "SetItem.h"
2. 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);
       }

};

1. endif