模拟实现list
要模拟实现list,必须要熟悉list的底层结构以及其接口的含义,通过上面的学习,这些内容已基本掌握,现在我们来模拟实现list。
#pragma once
#include<iostream>
#include<assert.h>
#include<algorithm>
using std::cout;
using std::endl;
namespace bit
{
template<class T>
struct ListNode
{
ListNode* _next;
ListNode* _prev;
T _data;
ListNode(const T& x=T())
:_next(nullptr)
,_prev(nullptr)
,_data(x)
{}
};
//法二:增加两个模板参数(编译器实例化生成了两个类)
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)
{}
// *it
//T& operator*()
Ref operator*()
{
return _node->_data;
}
//T* operator->()
Ptr operator->()
{
return &(_node->_data);
}
// ++it
Self& operator ++()
{
_node = _node->_next;
return *this;
}
// it++
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& it)
{
return _node != it._node;
}
bool operator ==(const Self& it)
{
return _node == it._node;
}
};
//法一:写两个类
//template<class T>
//struct ListConstIterator
//{
// typedef ListNode<T> Node;
// typedef ListConstIterator<T> Self;
// Node* _node;
// ListConstIterator(Node* node)
// :_node(node)
// {}
// // *it
// const T& operator*()
// {
// return _node->_data;
// }
// const T* operator->()
// {
// return &(_node->_data);
// }
// // ++it
// Self& operator ++()
// {
// _node = _node->_next;
// return *this;
// }
// // it++
// 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& it)
// {
// return _node != it._node;
// }
// bool operator ==(const Self& it)
// {
// return _node == it._node;
// }
//};
template<class T>
class list
{
typedef ListNode<T> Node;
public:
//法一的typedef
//typedef ListIterator<T> iterator;
//typedef ListConstIterator<T> const_iterator;
//法二的typedef
typedef ListIterator<T,T&,T*> iterator;
typedef ListIterator<T,const T&,const T*> const_iterator;
iterator begin()
{
return iterator(_head->_next);
//可以直接写return _head->_next;
//单参数构造函数可以隐式类型转换
}
iterator end()
{
return iterator(_head);
}
const_iterator begin()const
{
return const_iterator(_head->_next);
}
const_iterator end()const
{
return const_iterator(_head);
}
void empty_init()
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
_size = 0;
}
list()
{
empty_init();
}
list(const list<T>& lt)
{
empty_init();
for (auto& e : lt)
{
push_back(e);
}
}
void swap(list<T>& lt)
{
std::swap(_head, lt._head);
std::swap(_size, lt._size);
}
list<T>& operator=(list<T> lt)
{
swap(lt);
return *this;
}
void clear()
{
iterator it = begin();
while (it != end())
{
it = erase(it);
it++;
}
}
~list()
{
clear();
delete _head;
_head = nullptr;
}
/*void push_back(const T& x)
{
Node* newnode = new Node;
Node* tail = _head->_prev;
newnode->_data = x;
tail->_next = newnode;
newnode->_prev = tail;
newnode->_next = _head;
_head->_prev = newnode;
}*/
void push_back(const T& x)
{
insert(end(), x);
}
void push_front(const T& x)
{
insert(begin(), x);
}
void pop_back()
{
erase(--end());
}
void pop_front()
{
erase(begin());
}
void insert(iterator pos,const T& val)
{
Node* cur = pos._node;
Node* newnode = new Node(val);
Node* prev = cur->_prev;
//prev newnode cur
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
_size++;
}
iterator erase(iterator pos)
{
Node* cur = pos._node;
Node* prev = cur->_prev;
Node* next = cur->_next;
prev->_next = next;
next->_prev = prev;
delete cur;
_size--;
return iterator(next);
}
size_t size()const
{
return _size;
}
bool empty()const
{
return _size==0;
}
private:
Node* _head;
size_t _size=0;
};
}