文章目录
- 📍前言
- 🌈STL之list的模拟实现
- 🎈list_node节点的定义
- 🎈iterator迭代器
- 🕯️构造函数
- 🕯️*it
- 🕯️->
- 🕯️it++/++it
- 🕯️it--/--it
- 🕯️!= / ==
- 🎈list类
- 🕯️begin()/end()
- 🕯️const_begin()/const_end()
- 🕯️构造函数
- 🕯️insert函数
- 🕯️erase函数
- 🕯️push_back函数
- 🕯️push_front函数
- 🕯️pop_back函数
- 🕯️pop_front函数
- 🎈源码
- 📍后记
📍前言
本篇将学习 list 的模拟实现，它的主要难点在与迭代器的模拟。
🕺作者： 迷茫的启明星
专栏：《C++初阶》
😘欢迎关注：👍点赞🙌收藏✍️留言🏇码字不易，你的👍点赞🙌收藏❤️关注对我真的很重要，有问题可在评论区提出，感谢阅读！！！
持续更新中~
🌈STL之list的模拟实现
🎈list_node节点的定义
- 这里需要使用结构体
- 在这里需要使用模板，因为数据类型是不确定的
- 双向链表的结构包括：两个指针和数据
- 我们在定义节点时还需要初始化
template<class T>
struct list_node
{
T _data;
list_node<T>* _next;
list_node<T>* _prev;
//初始化
list_node(const T& val = T())
//为什么传引用？
//传引用减少拷贝
//初始化的值是T的默认构造函数，不能传0
//T可能是string类型或其他类型
:_data(val)
,_next(nullptr)
,_prev(nullptr)
{}
};
🎈iterator迭代器
迭代器可以理解成指针，但是它比指针复杂多了，指针无外乎地址，而迭代器则是不是指针，却要让它实现指针的功能：++、–、*等操作
🕯️构造函数
我们构造好了一个_node，但是没有给他赋值，就等着外面传过来一个node，把node给给里面的_node即可。
__list_iterator(Node* node)
:_node(node)
{}
🕯️*it
我们把迭代器比作指针，方便理解，这个函数就是对“指针”解引用，拿到它的值。注意结果返回引用，减少拷贝
Ref operator*()
{
return _node->_data;
}
🕯️->
拿到节点的值的地址，因为返回的是一个地址，所以要用指针接收。结果返回一个指针。
Ptr operator->()
{
return &(operator*());
}
🕯️it++/++it
为了实现类似指针的效果，迭代器前置++和后置++分别就要返回没改变的值和改变了的值。
++it
迭代器向后走一步，返回加过的值(还是一个迭代器)
it++
迭代器向后走一步，返回没加过的值(还是一个迭代器)
//++it
iterator& operator++()
{
_node = _node->_next;
return *this;
}
// it++
iterator operator++(int)
{
iterator tmp(*this);//保存原来的值
_node = _node->_next;
return tmp;
}
🕯️it–/–it
原因与上同
// --it
iterator& operator--()
{
_node = _node->_prev;
return *this;
}
// it--
iterator operator--(int)
{
iterator tmp(*this);
_node = _node->_prev;
return tmp;
}
🕯️!= / ==
仅需判断里面的this是否一样即可
bool operator!=(const iterator& it) const
{
return _node != it._node;
}
bool operator==(const iterator& it) const
{
return _node == it._node;
}
🎈list类
🕯️begin()/end()
iterator begin()
{
return iterator(_head->_next);
}
iterator end()
{
return iterator(_head);
}
🕯️const_begin()/const_end()
const_iterator begin() const
{
return const_iterator(_head->_next);
}
const_iterator end() const
{
return const_iterator(_head);
}
🕯️构造函数
list()
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
}
🕯️insert函数
双向链表的插入，是不是非常简单呢？只需要将新的节点的指针与插入位置前后指针相连即可。
iterator insert(iterator pos, const T& x)
{
Node* cur = pos._node;
Node* prev = cur->_prev;
Node* newnode = new Node(x);
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
return iterator(newnode);
}
🕯️erase函数
与Insert函数一样，把需要删除的节点的前后节点绑在一起就完成了。
iterator erase(iterator pos)
{
assert(pos != end());
Node* cur = pos._node;
Node* prev = cur->_prev;
Node* next = cur->_next;
prev->_next = next;
next->_prev = prev;
delete cur;
return iterator(next);
}
🕯️push_back函数
它有两种方式，既可以自己来实现每一步，也可以直接复用insert函数在末尾插入
void push_back(const T& x)
{
//Node* tail = _head->_prev;
//Node* newnode = new Node(x);
_head tail newnode
//tail->_next = newnode;
//newnode->_prev = tail;
//newnode->_next = _head;
//_head->_prev = newnode;
insert(end(), x);
}
🕯️push_front函数
它和上面push_back函数讲的一样，不过这是在开头插入
void push_front(const T& x)
{
insert(begin(), x);
}
🕯️pop_back函数
复用erase函数
void pop_back()
{
erase(--end());
}
🕯️pop_front函数
复用erase函数
void pop_front()
{
erase(begin());
}
🎈源码
namespace hxq
{
template<class T>
struct list_node
{
T _data;
list_node<T>* _next;
list_node<T>* _prev;
list_node(const T& x = T())
:_data(x)
, _next(nullptr)
, _prev(nullptr)
{}
};
template<class T, class Ref, class Ptr>
struct __list_iterator
{
typedef list_node<T> Node;
typedef __list_iterator<T, Ref, Ptr> iterator;
typedef bidirectional_iterator_tag iterator_category;
typedef T value_type;
typedef Ptr pointer;
typedef Ref reference;
typedef ptrdiff_t difference_type;
Node* _node;
__list_iterator(Node* node)
:_node(node)
{}
bool operator!=(const iterator& it) const
{
return _node != it._node;
}
bool operator==(const iterator& it) const
{
return _node == it._node;
}
Ref operator*()
{
return _node->_data;
}
//T* operator->()
Ptr operator->()
{
return &(operator*());
}
// ++it
iterator& operator++()
{
_node = _node->_next;
return *this;
}
// it++
iterator operator++(int)
{
iterator tmp(*this);
_node = _node->_next;
return tmp;
}
// --it
iterator& operator--()
{
_node = _node->_prev;
return *this;
}
// it--
iterator operator--(int)
{
iterator tmp(*this);
_node = _node->_prev;
return tmp;
}
};
template<class T>
class list
{
typedef list_node<T> Node;
public:
typedef __list_iterator<T, T&, T*> iterator;
typedef __list_iterator<T, const T&, const T*> const_iterator;
const_iterator begin() const
{
return const_iterator(_head->_next);
}
const_iterator end() const
{
return const_iterator(_head);
}
iterator begin()
{
return iterator(_head->_next);
}
iterator end()
{
return iterator(_head);
}
list()
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
}
void push_back(const T& x)
{
//Node* tail = _head->_prev;
//Node* newnode = new Node(x);
_head tail newnode
//tail->_next = newnode;
//newnode->_prev = tail;
//newnode->_next = _head;
//_head->_prev = newnode;
insert(end(), x);
}
void push_front(const T& x)
{
insert(begin(), x);
}
iterator insert(iterator pos, const T& x)
{
Node* cur = pos._node;
Node* prev = cur->_prev;
Node* newnode = new Node(x);
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
return iterator(newnode);
}
void pop_back()
{
erase(--end());
}
void pop_front()
{
erase(begin());
}
iterator erase(iterator pos)
{
assert(pos != end());
Node* cur = pos._node;
Node* prev = cur->_prev;
Node* next = cur->_next;
prev->_next = next;
next->_prev = prev;
delete cur;
return iterator(next);
}
private:
Node* _head;
};
}
📍后记
本文主要介绍了STL中双向链表list的模拟实现。
✨通过结构体定义list_node节点，通过模板实现数据类型的不确定性，并对节点进行初始化。
✨利用迭代器iterator实现指针的功能，包括构造函数、解引用、*it、->、前后置++/–、!=和==等操作。
✨在list类中，通过双向链表实现了begin()/end()、const_begin()/const_end()、insert、erase、push_back、push_front、pop_back和pop_front等函数。
✨其中，push_back和push_front函数可以复用insert函数，在末尾和开头插入元素。
✨pop_back和pop_front函数可以复用erase函数，删除末尾和开头的元素。
感谢大家支持！！！
respect！
下篇见！
