Курсовая по ООП / classes / machines

#ifndef _MACHINES_H_
#define _MACHINES_H_

#ifndef NULL
#define NULL 0
#endif
template <class ListType> class List;

template <class ListType> 
class ListItem {
	friend class List<ListType>;
private:
	ListItem() {};
	ListItem *next,*prev;
public:
	ListType value;
	ListItem (ListItem<ListType> *,ListItem<ListType> *);
	~ListItem();
};

template <class ListType> 
class List{
private:
	ListItem<ListType> *head,*tail;
	unsigned counter;
	ListItem<ListType> *iterator;
	List(List &) {};
public:
	List();
	~List();
	ListItem<ListType> *Add(ListType const &);
	void	  Del(ListItem<ListType> *);
	ListItem<ListType> &operator [] (unsigned);
	unsigned GetCount(void);
};

/*
+============================================================================+
|                            IMPLEMENTATION                                  |
+============================================================================+
*/
template <class ListType>
ListItem<ListType>::ListItem(ListItem<ListType> *n, ListItem<ListType> *p){
	next=n;
	prev=p;
	value=NULL;
}

template <class ListType>
ListItem<ListType>::~ListItem() {
	next=NULL;
	prev=NULL;
	value=NULL;
} 


template <class ListType>
List<ListType>::List(){
	head=tail=NULL;
	iterator=head;
	counter=0;
}

template <class ListType>
List<ListType>::~List(){
	for(unsigned i=0;i<counter;i++)
		this->Del(head);
}

template <class ListType>
ListItem<ListType> * List<ListType>::Add(ListType const &val){
	counter++;
	if(!head){
		//if List is empty
		head=tail=new ListItem<ListType>(NULL,NULL);
		(*head).value=val;
		return head;
	} else {
		//if List isn't empty
		(*tail).next=new ListItem<ListType>(NULL,tail);
		tail=(*tail).next;
		(*tail).value=val;
		return tail;
	}
	return NULL;
}

template <class ListType>
void List<ListType>::Del(ListItem<ListType> *d){
	if(d==head) {
		//if deleting element is head
		head=(*head).next;
		delete d;
	} else {
		//if deleting element isn't head
		if((*d).next)
			(*(*d).next).prev=(*d).prev;
		(*(*d).prev).next=(*d).next;
		delete d;
	}
	counter--;
}

template <class ListType>
ListItem<ListType> &List<ListType>::operator [](unsigned index){
	if((index<=counter)&&(index>0)){
		iterator=head;
		for(unsigned i=1;i<index;i++)
			iterator=iterator->next;
		return *iterator;
	} else {
		return *head;
	}
}

template <class ListType>
unsigned List<ListType>::GetCount(void){
	return counter;
}
#endif