实现的功能:迭代器、反向迭代器、以及list的各种接口
list.h
namespace myList
{
List的结点类
template<class T>
class ListNode
{
public:
ListNode(const T& val = T())
:_data(val)
, _next(nullptr)
, _prev(nullptr)
{}
T _data;
ListNode<T>* _next;
ListNode<T>* _prev;
};
//List的迭代器
template<class T, class Ref, class Ptr> //
class ListIterator
{
public:
typedef ListNode<T>* PNode;
typedef ListIterator<T, Ref, Ptr> Self;
PNode _node;
ListIterator(PNode node)
:_node(node)
{}
//*iterator
Ref operator*()
{
return _node->_data;
}
Ptr operator->()
{
return &(_node->_data);
}
//++iterator _node->_next
Self& operator++()
{
_node = _node->_next;
return *this;
}
Self operator++(int)
{
Self tmp(*this);
_node = _node->_next;
return tmp;
}
Self& operator--()
{
_node = _node->_prev;
return *this;
}
Self operator--(int)
{
Self tmp(*this);
_node = _node->_prev;
return tmp;
}
bool operator!=(const Self& lit)
{
return _node != lit._node;
}
bool operator==(const Self& lit)
{
return _node == lit._node;
}
};
//List的反向迭代器
template<class T, class Ref, class Ptr, class Iterator> //传参的时候根据模板推演参数类型
class ListReverseIterator
{
typedef ListReverseIterator<T, Ref, Ptr, Iterator> Self;
public:
ListReverseIterator(const Iterator& it)
:_it(it)
{}
ListReverseIterator(const Self& s)
:_it(s._it)
{}
Ref operator*()
{
Iterator tmp = _it;
return *(--tmp); //正向迭代器和反向迭代器是前后的。反向迭代器当前位置的下一个位置是正向迭代器的当前位置。
}
Ptr operator->()
{
return &operator*();
}
//前置++,反向迭代器的++就是正向迭代器的--
Self& operator++() //前置返回引用
{
--_it;
return *this;
}
Self operator++(int)
{
Iterator temp(_it); //调用正向迭代器的构造方法
--_it;
return temp;
}
Self& operator--()
{
++_it;
return *this;
}
Self operator--(int)
{
Iterator temp(_it);
++_it;
return temp;
}
bool operator==(const Self& s)
{
return _it == s._it;
}
bool operator!=(const Self& s)
{
return _it != s._it;
}
private:
Iterator _it; //封装正向迭代器,底层调用的是const和非const的正向迭代器
};
template<class T>
class List
{
public:
typedef ListNode<T> Node;
typedef Node* PNode;
typedef ListIterator<T, T&, T*> iterator;
typedef ListIterator<T, const T&, const T*> const_iterator;
typedef ListReverseIterator<T, const T&, const T*, iterator> reverse_iterator;
typedef ListReverseIterator<T, const T&, const T*, const_iterator> const_reverse_iterator;
List()
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
}
List(int n, const T& value = T())
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
for (int i = 0; i < n; ++i){
PushBack(value);
}
}
template<class Iterator>
List(Iterator first, Iterator last)
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
while (first != last){
PushBack(*first);
++first;
}
}
List(const List<T>& l)
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
List<T> temp(l.cbegin(), l.cend());
swap(_head, temp._head);
}
List<T>& operator=(List<T> l) //现代版写法,传值会调用构造,创建出临时变量,交换this的指针指向,
//临时变量出作用域会销毁
{
swap(_head, l._head);
return *this;
}
~List()
{
if (_head)
{
PNode cur = _head->_next;
while (cur != _head)
{
PNode next = cur->_next;
delete cur;
cur = next;
}
delete _head;
_head = nullptr;
}
}
//迭代器
iterator begin()
{
return iterator(_head->_next);
}
iterator end()
{
return iterator(_head);
}
const_iterator cbegin() const
{
return const_iterator(_head->_next);
}
const_iterator cend() const
{
return const_iterator(_head);
}
reverse_iterator rbegin()
{
return reverse_iterator(end()); //end()传入相当传入iterator(_head)然后调用反向迭代器的构造函数
}
reverse_iterator rend()
{
return reverse_iterator(begin());
}
const_reverse_iterator crbegin() const
{
return const_reverse_iterator(cend());
}
const_reverse_iterator crend() const
{
return const_reverse_iterator(cbegin());
}
///
//List Access
T& Front()
{
return _head->_next->_data;
}
const T& Front() const
{
return _head->_next->_data;
}
T& Back()
{
return _head->_prev->_data;
}
const T& Back() const
{
return _head->_prev->_data;
}
/
//List Modify
void PushBack(const T& val)
{
PNode newNode = new Node(val);
PNode prev = _head->_prev;
prev->_next = newNode;
newNode->_prev = prev;
newNode->_next = _head;
_head->_prev = newNode;
}
void PopBack()
{
//找到要删除的结点,也就是头结点的前一个就是最后一个结点
PNode del = _head->_prev;
//只有一个头结点不能删除
if (del != _head){
_head->_prev = del->_prev;
del->_prev->_next = _head;
delete del;
}
}
void PushFront(const T& val)
{
PNode newnode = new Node(val);
newnode->_prev = _head;
newnode->_next = _head->_next;
_head->_next->_prev = newnode;
_head->_next = newnode;
}
void PopFront()
{
PNode cur = _head->_next;
if (cur != _head){
_head->_next = cur->_next;
cur->_next->_prev = _head;
delete cur;
}
}
//在pos位置前插入值为val的结点
iterator Insert(iterator pos, const T& val)
{
PNode newnode = new Node(val);
//pos是迭代器,要取到pos位置的结点
PNode cur = pos._node;
newnode->_next = cur;
newnode->_prev = cur->_prev;
newnode->_prev->_next = newnode;
cur->_prev = newnode;
return iterator(newnode);
}
//删除pos位置的结点,返回该结点的下一个位置
iterator Erase(iterator pos)
{
//保存pos位置的结点以及pos位置结点的前一个结点和后一个结点
PNode del = pos._node;
PNode prev = del->_prev;
PNode next = del->_next;
//注意不能删除头结点
if (del != _head){
prev->_next = next;
next->_prev = prev;
delete del;
del = nullptr;
//更新迭代器
pos = iterator(next);
}
return pos;
}
void Clear()
{
PNode cur = _head->_next;
while (cur != _head){
PNode next = cur->_next;
delete cur;
cur = next;
}
_head->_next = _head;
_head->_prev = _head;
}
//
//List Capacity
size_t Size() const
{
size_t count = 0;
PNode cur = _head->_next;
while (cur != _head){
++count;
cur = cur->_next;
}
return count;
}
bool Empty() const
{
return _head->_next == _head;
}
void ReSize(size_t newSize, const T& val = T())
{
size_t oldSize = Size();
if (oldSize <= newSize){
for (size_t i = oldSize; i < newSize; ++i){
PushBack(val);
}
}
else{
for (size_t i = newSize; i < oldSize; ++i){
PopBack();
}
}
}
private:
PNode _head;
};
}
测试list
test.cpp
#include<iostream>
#include "list.h"
using namespace std;
//正向打印链表
template<class T>
void PrintList(myList::List<T>& l)
{
auto lit = l.begin();
while (lit != l.end()){
cout << *lit << " ";
++lit;
}
cout << endl;
}
//反向打印链表
template<class T>
void PrintListReverse(const myList::List<T>& l)
{
auto it = l.crbegin();
while (it != l.crend()){
cout << *it << " ";
++it;
}
cout << endl;
}
//测试List的构造
void Test1()
{
//myList::List<int> l1;
//l1.PushBack(1);
//l1.PushBack(2);
//l1.PushBack(3);
//l1.PushBack(4);
//myList::List<int> l2;
//l2 = l1;
//PrintList(l1);
//PrintList(l2);
myList::List<int> l1;
myList::List<int> l2(10, 5);
PrintList(l2);
int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
myList::List<int> l3(array, array + sizeof(array) / sizeof(array[0]));
PrintList(l3);
myList::List<int> l4(l3);
PrintList(l4);
l1 = l4;
PrintList(l1);
PrintListReverse(l1);
char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' };
myList::List<char> l5(arr, arr + sizeof(arr) / sizeof(arr[0]));
PrintList(l5);
}
//测试PushBack()/PopBack()/PushFront()/PopFront()
void Test2()
{
//PushBack()/PushFront()
myList::List<int> l;
l.PushBack(1);
l.PushBack(2);
l.PushBack(3);
PrintList(l);
l.PopBack();
l.PopBack();
PrintList(l);
l.PopBack();
cout << l.Size() << endl;
//PushFront()/PopFront()
l.PushFront(1);
l.PushFront(2);
l.PushFront(3);
PrintList(l);
l.PopFront();
l.PopFront();
PrintList(l);
l.PopFront();
cout << l.Size() << endl;
}
//Insert()/Erase()
void Test3()
{
int array[] = { 1, 2, 3, 4, 5 };
myList::List<int> l(array, array + sizeof(array) / sizeof(array[0]));
auto pos = l.begin();
l.Insert(pos, 0);
PrintList(l);
++pos;
l.Insert(pos, 7);
PrintList(l);
l.Erase(l.begin());
auto pos2 = l.Erase(pos);
PrintList(l);
//pos指向的结点已经被删除,pos迭代器失效
cout << *pos << endl;
cout << *pos2 << endl;
auto it = l.begin();
while (it != l.end()){
it = l.Erase(it);
}
cout << l.Size() << endl;
}
//ReSize()/Clear()
void Test4()
{
int array[] = { 1, 2, 3, 4, 5 };
myList::List<int> l(array, array + sizeof(array) / sizeof(array[0]));
cout << l.Size() << endl;
PrintList(l);
l.ReSize(10, 7);
cout << l.Size() << endl;
PrintList(l);
l.ReSize(4);
cout << l.Size() << endl;
PrintList(l);
l.ReSize(3, 0);
cout << l.Size() << endl;
PrintList(l);
l.Clear();
cout << l.Size() << endl;
PrintList(l);
}
int main()
{
//Test1();
//Test2();
//Test3();
Test4();
system("pause");
return 0;
}