模拟实现list类
文章目录
- 一.list简介
- 二.实现list类的准备工作
-
- 1.定义list节点
- 2.定义list迭代器
- 三.模拟实现list类
-
- 1.定义list类
- 2.构造函数&析构函数
- 3.迭代器相关函数
- 4.插入及删除相关操作
- 5.拷贝构造
- 6.赋值重载
- 四.源码
一.list简介
list是C++ STL中的一个容器，是一个双向链表，可以存储任意类型的元素。list中的元素可以通过指针在链表中进行高效的插入和删除操作，因此list通常被用于需要频繁进行插入和删除操作的场合。
二.实现list类的准备工作
1.定义list节点
为了区别于库中的list类，我们可以在自己的命名空间中定义list类。list的基本成员变量只有一个——list的头结点（head）并且头节点内不存储有效数据。
定义结点结构：
namespace dianxia
{
//定义结点结构
template<class T>
struct ListNode
{
struct ListNode<T>* _next; // 指向下一个结点
struct ListNode<T>* _prev; // 指向前一个结点
T _data; // 结点存储的数据
ListNode(const T& data = T()) // 构造函数 // 申请一个节点
:_next(nullptr),
_prev(nullptr),
_data(data)
{}
};
}
2.定义list迭代器
迭代器——作为list最精华的部分，有着及其重要的作用，且同样为list模拟实现中最难的一部分。通过本章的内容，我们对于迭代器的理解会更上一层楼!
在string与vector的学习中，我们经常使用下标+[]来访问容器的元素，非常方便。但是到了list以后的内容，[]访问元素的方法将不再适用，我们将使用迭代器。
前面的文章中曾经简单的提到过迭代器，简单来说它是一种泛型指针却又不单纯是指针，接下来我们就模拟实现list的迭代器。
迭代器本质就是对指针的封装模拟指针的行为，所以我们需要通过运算符重载来模拟实现指针的
++、--以及*、->等操作。
我们将迭代器可以实现的一系列操作封装成类：
// 三个参数的含义分别为:
//类型T
//类型T的引用
//类型T的指针
template<class T,class Ref,class Ptr>
struct _list_iterator
{
typedef ListNode<T> Node;
typedef _list_iterator<T, Ref, Ptr> self;
Node* _node; //迭代器的基本成员变量
_list_iterator(node* node)
:_node(node)
{}
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;
}
Ref& operator*()
{
return _node->_data;
}
Ptr& operator->()
{
return &(_node->_data);
}
bool operator==(const self& s)
{
return _node == s._node;
}
bool operator!=(const self& s)
{
return _node != s._node;
}
}
三.模拟实现list类
有了list的节点和list的迭代器，下面我们就来是实现list类本身的成员函数：
1.定义list类
template<class T>
class list
{
typedef ListNode<T> Node;
public:
// 类型重命名——普通迭代器
typedef _list_iterator<T,T&,T*> iterator;
// 类型重命名——const迭代器
typedef _list_iterator<T, const T&,const T*> const_iterator;
private:
Node _node;
}
2.构造函数&析构函数
//构造函数
list()
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
}
//析构函数
~list()
{
clean();
delete _head;
_head = nullptr;
}
3.迭代器相关函数
iterator begin()
{
return iterator(_head->_next);
}
iterator end()
{
return iterator(_head);
}
const_iterator begin() const
{
return const_iterator(_head->_next);
}
const_iterator end() const
{
return const_iterator(_head);
}
4.插入及删除相关操作
//插入操作
void insert(iterator pos,const T& data)
{
node* newNode = new Node(data);
Node* cur = pos._node;
Node* prev = cur->_prev;
newNode->_prev = prev;
prev->_next = newNode;
newNode->_next = cur;
cur->_prev=newNode;
}
//删除操作
iterator erase(iterator pos)
{
assert(pos != end());
Node* prev = pos._node->_prev;
Node * next = pos._node->_next;
prev->_next = next;
next->_prev = prev;
delete pos._node;
// 返回删除位置的下一个迭代器位置
return iterator(next);
}
//尾插
void push_back(const T& data)
{
insert(end(),data);
}
//尾删
void pop_back()
{
erase(--end());
}
//头插
void push_front(const T& data)
{
insert(begin(), data);
}
//头删
void pop_front()
{
erase(begin());
}
//清空list
void clean()
{
iterator it = begin();
while (it != end())
{
//it = erase(it);
erase(it++);
}
}
5.拷贝构造
void swap(list<T>& tmp)
{
std::swap(_head, tmp._head);
}
//拷贝构造
list(const list<T>& lt)
{
//初始化
_head = new node;
_head->_next = _head;
_head->_prev = _head;
//复用区间构造
list<T> tmp(lt.begin(), lt.end());
swap(tmp);
}
6.赋值重载
void swap(list<T>& tmp)
{
std::swap(_head, tmp._head);
}
//赋值重载
list<T>& operator=(list<T> lt)
{
swap(lt);
return *this;
}
四.源码
#include本文到此结束，码文不易，还请多多支持哦！！