以下的List的模拟实现:
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <assert.h>
#include <stdlib.h>
using namespace std;
//模拟实现list
//STL中的list是带头的、双向循环链表
//链表中的迭代器是被封装起来的指向结点的指针类,
//并且这个指针重载了自己的一些运算符,使得在链表中
//的++,*等操作挥应自如。//在实现普通迭代器、const迭代器过程中,
//我们像库中所做的一样,并没有分开实现两个类,而在再模板参数中做了手脚
//使得我们传参时自动实例化迭代器的类型(const与非const的普通类型)。
//链表结点结构(注意模板针对的是结点中元素的类型)
template<class T>
struct _ListNode
{
T _data;
_ListNode<T>* _prev;
_ListNode<T>* _next;
//构造函数(构造一个节点)
_ListNode(const T& x)
:_data(x)
, _prev(nullptr)
, _next(nullptr)
{}
};
//迭代器结构(类)
//第一个模板参数是链表结点数据类型
//第二个模板参数是链表结点数据类型的引用(const与非const)
//第三个模板参数是指向链表结点的指针(const与非const)
template<class T, class Ref, class Ptr>
struct _ListIterator
{
//链表结点类型重定义
typedef _ListNode<T> Node;
//迭代器类型重定义
typedef _ListIterator<T, Ref, Ptr> self;
//迭代器的成员变量就是一个结点指针
Node* _node;
//构造函数(用一个结点的指针构造一个迭代器)
_ListIterator(Node* node)
:_node(node)
{}
//重载前置加加
self& operator++()
{
_node = _node->_next;
return *this;
}
//重载后置加加
self operator++(int)
{
_ListIterator tmp(*this);
_node = _node->_next;
return tmp;
}
//重载前置减减
self& operator--()
{
_node = _node->_prev;
return *this;
}
//重载后置减减
self operator--(int)
{
_ListIterator tmp(*this);
_node = _node->_prev;
return tmp;
}
//重载!=
bool operator!=(const self& s)
{
return _node != s._node;
}
//重载==
bool operator!=(const self& s)
{
return _node == s._node;
}
//重载*
Ref operator*()
{
return _node->_data;
}
//重载->
Ptr operator->()
{
return &(operator*());
}
//不用自己实现拷贝构造、赋值运算符重载,因为
//库里的是"浅拷贝",而这里我们需要的迭代器的
//拷贝就是要浅拷贝
//析构函数我们也不需要自己实现,因为迭代器指向的
//是链表的结点,而链表的结点生命周期应该随链表
//迭代器只是遍历一下,不管释放工作
};
//List正式开始
template<class T>
class List
{
public:
typedef _ListNode<T> Node;//结点结构重命名
//普通迭代器,const迭代器重命名
typedef _ListIterator<T, T*, T&> iterator;
typedef _ListIterator<T, const T*, const T&> const_iterator;
//begin()、end()
iterator begin()
{
//用第一个结点的指针构造指向第一个结点的迭代器
return iterator(_head->_next);
}
iterator end()
{
return iterator(_head);
}
//const_begin()、const_end()
const_iterator begin()const
{
//用第一个结点的指针构造指向第一个结点的迭代器
return iterator(_head->_next);
}
const_iterator end()const
{
return iterator(_head);
}
//构造函数
List()
{
//创建头结点
_head = new Node;
}
//清理有效数据结点
void clear()
{
Node* cur = _head->_next;
while (cur != _head)
{
Node* next = cur->_next;
delete cur;
cur = next;
}
//重置头结点
_head->_next = _head;
_head->_prev = _head;
}
//析构函数
~List()
{
//先清理有效数据结点
clear();
//再清理头结点
delete _head;
_head = nullptr;
}
size_t size()
{
size_t size = 0;
for (const auto& e : *this)
{
++size;
}
return size;
}
bool empty()
{
return _head->_next == _head;
}
//拷贝构造函数
List(List<T>& list)
{
//先创建头结点
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
//再尾插有效数据结点
const_iterator it = list.begin();
while (it != list.end())
{
push_back(*it);
++it;
}
}
//赋值运算符重载
List<T>& operator=(List<T> list)
{
swap(_head, list._head);
return *this;
}
//在pos位置前插入一个数据(pos传的是指针)
void insert(iterator pos, const T& x)
{
Node* cur = pos._node;//先拿到pos的指针(pos是迭代器)
Node* prev = cur->_prev;
Node* newnode = new Node(x);
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
}
//尾插
void push_back(const T& x)
{
//复用insert
insert(end(), x);
}
//头插
void push_front(const T& x)
{
//复用insert
insert(begin(), x);
}
//删除pos位置结点(pos传迭代器)
//返回下一个结点的迭代器
iterator erase(iterator pos)
{
Node* cur = pos._node;
Node* prev = cur->_prev;
Node* next = cur->_next;
prev->_next = next;
next->_prev = prev;
delete cur;
return iterator(next);
}
//尾删
void pop_back()
{
//复用erase
erase(--end());
}
//头删
void pop_front()
{
//复用erase
erase(begin());
}
private:
Node * _head;
};