list类的基本实现和常用的接口

#include
using namespace std;
template
class ListNode {
public:
ListNode(const T& val = T())
:_val(val), _next(nullptr), _prev(nullptr)
{}
T _val;
ListNode* _next;
ListNode* _prev;
};
//迭代器类
template<class T, class Ref, class Ptr>
class ListIterator {
public:
typedef ListNode Node;
typedef ListIterator<T, Ref, Ptr> Self;
ListIterator(Node* node = nullptr)
:_node(node)
{}
Ref operator * ()
{
return _node->_val;
}
Ptr operator -> ()
{
return &(_node->_val);
}
Self& operator ++()
{
_node = _node->_next;
return this;
}
Self operator ++(int)
{
Self tmp(_node);
_node = _node->_next;
return tmp;
}
Self& operator --()
{
_node = _node->_prev;
return this;
}
Self operator – (int)
{
Self tmp(_node);
_node = _node->_prev;
return tmp;
}
bool operator == (const Self& l) const
{
return _node == l._node;
}
bool operator != (const Self& l) const
{
return _node!=l._node;
}
Node _node;
};
//List类
template
struct List {
public:
typedef ListNode Node;
typedef ListIterator<T, T&, T> iterator;
typedef ListIterator<T, const T&, const T*> const_iterator;
//构造函数
List()
:_header(new Node)
{
_header->_next = _header->_prev = _header;
}
List(int n, const T& val)
:_header(new Node)
{
_header->_prev = _header->_next = _header;
for (int i = 0; i < n; i++)
{
push_back(val);
}
}
template
List(Iterator begin, Iterator end)
:_header(new Node)
{
_header->_next = _header->_prev = _header;
while (begin != end)
{
push_back(begin);
begin++;
}
}
void Swap(List& tmp)
{
swap(_header, tmp._header);
}
List(const List& l)
:_header(new Node)
{
_header->_next = _header->_prev = _header;
List tmp(l.begin(), l.end());
Swap(tmp);
}
List& operator = (const List l)
{
Swap(l);
return this;
}
//iterator 迭代器
iterator begin() const
{
return iterator(_header->_next);
}
iterator end() const
{
return iterator(_header);
}
const_iterator cbegin() const
{
return const_iterator(_header->_next);
}
const_iterator cend() const
{
return const_iterator(_header);
}
//链表长度
size_t size()
{
size_t size=0;
for (const auto& e : this)
size++;
return size;
}
bool empty()
{
return size() == 0;
}
//插入删除操作
void insert(iterator pos, const T& val)
{
Node cur = new Node(val);
cur->_prev = pos._node->_prev;
cur->_next = pos._node;
pos._node->_prev->_next = cur;
pos._node->_prev = cur;
}
iterator erase(iterator pos)
{
if (pos != end())
{
iterator tmp(pos._node->_next);
pos._node->_prev->_next = pos._node->_next;
pos._node->_next->_prev = pos._node->_prev;
delete pos._node;
return tmp;
}
else
exit(-1);
}
void push_back(const T& val)
{
insert(end(), val);
}
void pop_back()
{
erase(–end());
}
void push_front(const T& val)
{
insert(begin(), val);
}
void pop_front()
{
erase(begin());
}
//析构,清空
void clear()
{
Node p = _header->_next;
while (p != _header)
{
Node next = p->_next;
delete[] p;
p = next;
}
_header->_next = _header->_prev = _header;
}
~List()
{
clear();
delete _header;
}
private:
Node* _header;
};
void test()
{
Listlst;
Listlst1(3, 1);
}
void test1()
{
Listlst;
lst.push_back(1);
lst.push_back(2);
lst.push_back(3);
lst.push_back(4);
lst.push_back(5);
Listlst1(lst.begin(), lst.end());
Listlst2(lst1);
Listlst3 = lst2;
}
void test3()
{
Listlst;
lst.push_back(1);
lst.push_back(2);
lst.push_back(3);
lst.push_back(4);
lst.push_back(5);
//List::iterator p = lst.begin();
//while (p != lst.end())
//{
// cout << *p << " ";
// *p = 10;
// p++;
//}
//cout << endl;
//p = lst.begin();
//while (p != lst.end())
//{
// cout << *p << " ";
// p++;
//}
List::const_iterator p = lst.cbegin();
while (p != lst.cend())
{
cout << *p << " ";
p++;
}
cout << endl;
cout << lst.size();
}
void test4()
{
Listlst;
lst.push_back(1);
lst.push_back(2);
lst.push_back(3);
lst.push_back(4);
lst.push_back(5);
lst.push_back(6);
lst.push_front(1);
lst.push_front(2);
lst.push_front(3);
lst.push_front(4);
lst.push_front(5);
lst.push_front(6);
for (auto e : lst)
cout << e << " ";
}
int main()
{
test4();
}