#pragma once
#include <iostream>
using namespace std;
template<class T>
struct ListNode
{
ListNode(const T& x = T())
: _prev(0)
, _next(0)
, _value(x)
{}
ListNode<T>* _prev;
ListNode<T>* _next;
T _value;
};
template<class T, class Ref, class Ptr>
struct __ListIterator__
{
typedef __ListIterator__<T, T&, T*> Iterator;
typedef __ListIterator__<const T, const T&, const T*> ConstItrator;
typedef __ListIterator__<T, Ref, Ptr> Self;
typedef T ValueType;
typedef Ref Reference;
typedef Ptr Pointer;
typedef ListNode<T>* LinkType;
typedef size_t SizeType;
LinkType _node;
__ListIterator__(LinkType x)
:_node(x)
{}
__ListIterator__()
:_node(0)
{}
__ListIterator__(const Iterator& x)
{
_node=x._node;
}
bool operator==(const Iterator& x)
{
return _node==x._node;
}
bool operator!=(const Iterator& x)
{
return _node!=x._node;
}
Reference operator*()
{
return (*_node)._value;
}
Pointer operator->()
{
return &((*_node)._value);
}
Self& operator++()
{
_node=_node->_next;
return *this;
}
Self operator++(int)
{
Iterator tmp=*this;
_node=_node->_next;
return tmp;
}
Self& operator--()
{
_node=_node->_prev;
return *this;
}
Self operator--(int)
{
Iterator tmp=*this;
_node=_node->_prev;
return tmp;
}
};
template<class T>
class List
{
public:
typedef ListNode<T> Node;
typedef T ValueType;
typedef ValueType* Pointer;
typedef const ValueType* ConstPointer;
typedef ValueType& Reference;
typedef const ValueType& ConstReference;
typedef Node* LinkType;
typedef size_t SizeType;
typedef __ListIterator__<T, T&, T*> Iterator;
typedef __ListIterator__<const T, const T& ,const T*> ConstIterator;
List()
{
_node=new Node;
_node->_next=_node;
_node->_prev=_node;
}
Iterator Begin()
{
Iterator it;
it._node=_node->_next;
return it;
}
ConstIterator Begin()const
{
Iterator it;
it._node=_node->_next;
return it;
}
Iterator End()
{
Iterator it;
it._node=_node;
return it;
}
ConstIterator End()const
{
Iterator it;
it._node=_node;
return it;
}
bool Empty()const
{
return _node->_next==_node;
}
SizeType Size()const
{
Iterator it=Begin();
SizeType count=0;
while(it!=End())
{
it++;
count++;
}
return count;
}
Reference Front()
{
return *Begin();
}
ConstReference Front()const
{
return *Begin();
}
Reference Back()
{
return *(--End());
}
ConstReference Back()const
{
return *(--End());
}
Iterator Insert(Iterator pos, const T& x)
{
LinkType pnode=new Node(x);
pnode->_next=pos._node;
pnode->_prev=pos._node->_prev;
pos._node->_prev->_next=pnode;
pos._node->_prev=pnode;
return pos;
}
void PushFront(const T& x)
{
Insert(Begin(),x);
}
void PushBack(const T& x)
{
Insert(End(),x);
}
Iterator Erase(Iterator pos)
{
pos._node->_prev->_next=pos._node->_next;
pos._node->_next->_prev=pos._node->_prev;
Iterator it=pos;
it++;
delete pos._node;
return it;
}
void PopFront()
{
if(Empty())
return ;
Erase(Begin());
}
void PopBack()
{
if(Empty())
return ;
Erase(--End());
}
void Clear()
{
Iterator it=Begin();
while(it!=End())
{
Iterator tmp=it;
it++;
delete tmp._node;
}
it._node->_next=it._node;
it._node->_prev=it._node;
}
List(const List<T>& l)
{
_node=new Node;
_node->_next=_node;
_node->_prev=_node;
Iterator it=l.Begin();
while(it!=l.End())
{
PushBack(it._node->_value);
it++;
}
}
List& operator=(const List& l)
{
if(this!=&l)
{
Clear();
Iterator it=l.Begin();
while(it!=l.End())
{
PushBack(it._node->_value);
it++;
}
}
}
~List()
{
Iterator it=Begin();
while(it!=End())
{
Iterator tmp=it;
it++;
delete tmp._node;
}
delete it._node;
}
protected:
LinkType _node;
};
以模板模拟实现List容器
最新推荐文章于 2023-10-26 12:04:58 发布