hello，各位小伙伴，本篇文章跟大家一起学习《C++：list模拟实现》，感谢大家对我上一篇的支持，如有什么问题，还请多多指教 ！
如果本篇文章对你有帮助，还请各位点点赞！！！
话不多说，开始进入正题
🍁list的逻辑结构以及节点代码
是一个双指针带头链表，所以我选择用一个结构体ListNode来维护节点，如下：
// List的节点类
template<class T>
struct ListNode
{
ListNode(const T& val = T())
:_val(val)
,_pPre(nullptr)
,_pNext(nullptr)
{}
ListNode<T>* _pPre;// 指向前一个结点
ListNode<T>* _pNext;// 指向后一个节点
T _val;// 该结点的值
};
我对ListNode<T>改一个名字：Node：
typedef ListNode<T> Node;
typedef Node* PNode;
🍁list类
🍃私有成员变量_pHead和私有成员函数CreateHead()
private:
void CreateHead()// 创建头节点并且初始化
{
_pHead = new Node();
_pHead->_pNext = _pHead;
_pHead->_pPre = _pHead;
}
PNode _pHead;
🍃尾插函数和插入函数
尾插只是插入的其中一种方式，所以实现了插入函数，就能够实现尾插函数。
插入思路图解：在pos位置前插入值为val的节点
创建新节点值为value后；
使prev节点的_pNext指针指向newnode，newnode的节点的_pPre指向prev；
使cur节点的_pPre指针指向newnode，newnode的节点的_pNext指向cur；
最后返回iterator(newnode);
itearator为迭代器，后面会实现
- 插入
// 在pos位置前插入值为val的节点
iterator insert(iterator pos, const T& val)
{
Node* cur = pos._pNode;
Node* newnode = new Node(val);
Node* prev = cur->_pPre;
// prev newnode cur
prev->_pNext = newnode;
newnode->_pPre = prev;
newnode->_pNext = cur;
cur->_pPre = newnode;
return iterator(newnode);
}
- 尾插
void push_back(const T& val)
{
insert(end(), val);
}
🍃构造函数
- 无参构造
list(const PNode& pHead = nullptr)
{
CreateHead();
/*_pHead = new Node();
_pHead->_pNext = _pHead;
_pHead->_pPre = _pHead;*/
}
- 带参构造（数值）
list(int n, const T& value = T())
{
CreateHead();
for (int i = 0; i < n; ++i)
push_back(value);
}
- 带参构造（迭代器）
template <class Iterator>
list(Iterator first, Iterator last)
{
CreateHead();
while (first != last)
{
push_back(*first);
++first;
}
}
- 拷贝构造
list(const list<T>& l)
{
CreateHead();
// 复用带参构造（迭代器）
list<T> temp(l.cbegin(), l.cend());
// 与*this的头节点pHead交换指向
swap(temp);
}
🍃析构函数
clear()为其中的成员函数，功能：清理list中的数据
~list()
{
clear();
delete _pHead;
_pHead = nullptr;
/*Node* cur = _pHead->_pNext;
Node* tmp = cur->_pNext;
while (cur != _pHead)
{
delete cur;
cur = tmp;
tmp = tmp->_pNext;
}
tmp = cur = nullptr;
_pHead->_pNext = _pHead;
_pHead->_pPre = _pHead;*/
}
🍃迭代器模拟
逻辑上并不难，也许难理解于模板
//List的迭代器结构体
template<class T, class Ref, class Ptr>
struct ListIterator
{
typedef ListNode<T>* PNode;
typedef ListIterator<T, Ref, Ptr> Self;
ListIterator(PNode pNode = nullptr)
:_pNode(pNode)
{}
ListIterator(const Self& l)
{
_pNode = l._pNode;
}
T& operator*()
{
assert(_pNode != _pNode->_pNext);
return _pNode->_val;
}
T* operator->()
{
return &(*this);
}
Self& operator++()
{
_pNode = _pNode->_pNext;
return *this;
}
Self operator++(int)
{
PNode* tmp = _pNode;
_pNode = _pNode->_pNext;
return tmp;
}
Self& operator--()
{
_pNode = _pNode->_pPre;
return *this;
}
Self& operator--(int)
{
PNode* tmp = _pNode;
_pNode = _pNode->_pPre;
return tmp;
}
bool operator!=(const Self& l)
{
return _pNode != l._pNode;
}
bool operator==(const Self& l)
{
return !(*this != l);
}
PNode _pNode;
};
这段代码定义了一个模板结构 ListIterator，用于表示List类的迭代器。让我们来解释模板声明部分：
template<class T, class Ref, class Ptr>;
这一行是模板声明，定义了一个模板类 ListIterator，它有三个模板参数：T、Ref 和 Ptr。让我们逐个解释这些参数的作用：
1.T: 这是一个模板参数，表示迭代器指向的元素类型。在使用 ListIterator 时，你需要提供实际的类型作为 T 的值。
2.Ref: 这也是一个模板参数，表示迭代器的引用类型。通常情况下，当你通过迭代器解引用（使用 * 运算符）时，你希望得到的是元素的引用类型。所以 Ref 通常被设定为 T&，表示引用类型为 T 的元素。
3.Ptr: 这是迭代器的指针类型。与 Ref 类似，当你通过迭代器解引用（使用 -> 运算符）时，你希望得到的是元素的指针类型。因此，通常情况下 Ptr 被设定为 T*，表示指针类型为 T 的元素。
通过将这些参数设定为模板参数，ListIterator 类可以适用于不同类型的元素，同时也可以提供不同的引用和指针类型。这样做使得 ListIterator 类更加灵活，能够适用于不同的使用场景。
- 封装的意义
将迭代器的实现从 List 类中分离出来，有几个重要的意义和优势：
- 模块化设计：通过将迭代器封装为单独的类，可以实现更模块化的设计。这意味着 List 类的实现与迭代器的实现可以分开，每个类都专注于自己的职责。这样的设计使得代码更易于理解、维护和测试。
- 可重用性：通过将迭代器设计为独立的类，可以在不同的容器类中重复使用相同的迭代器实现。例如，如果你有另一个类似于 List 的容器类，也需要迭代器来遍历其中的元素，你可以直接重用相同的迭代器实现，而无需重新编写。
- 灵活性：将迭代器设计为独立的类使得它们的实现更加灵活。你可以在迭代器类中添加额外的功能或改变迭代器的行为，而不会影响到容器类的实现。这样的设计使得容器和迭代器的职责分离，每个类可以独立地演化和改进。
- 通用性：独立的迭代器类可以设计成通用的，适用于多种容器类型。这意味着你可以为不同的容器类实现相同的迭代器接口，使得用户在使用不同的容器时无需学习不同的迭代器接口，提高了代码的一致性和可用性。
总的来说，将迭代器封装为独立的类使得代码更加模块化、可重用、灵活和通用，提高了代码的可维护性、可扩展性和可读性。
🍃list类中迭代器的使用
public:
typedef ListIterator<T, T&, T*> iterator;
typedef ListIterator<T, const T&, const T&> const_iterator;
- begin()和end()
// List Iterator
iterator begin()
{
return _pHead->_pNext;
}
iterator end()
{
return _pHead;
}
const_iterator begin() const
{
return _pHead->_pNext;
}
const_iterator end() const
{
return _pHead;
}
- erase
删除pos位置的节点，返回该节点的下一个位置
iterator erase(iterator pos)
{
assert(pos._pNode != _pHead);
Node* Prev = pos._pNode->_pPre;
Node* Next = pos._pNode->_pNext;
delete pos._pNode;
Prev->_pNext = Next;
Next->_pPre = Prev;
return iterator(Next);
}
🍃List Modify
void push_back(const T& val) { insert(end(), val); }
void pop_back() { erase(--end()); }
void push_front(const T& val)
{
assert(!empty());
insert(begin(), val);
}
void pop_front() { erase(begin()); }
🍁全部代码
#pragma once
#include<assert.h>
#include<iostream>
using namespace std;
namespace My_List
{
// List的节点类
template<class T>
struct ListNode
{
ListNode(const T& val = T())
:_val(val)
,_pPre(nullptr)
,_pNext(nullptr)
{}
ListNode<T>* _pPre;
ListNode<T>* _pNext;
T _val;
};
//List的迭代器类
template<class T, class Ref, class Ptr>
struct ListIterator
{
typedef ListNode<T>* PNode;
typedef ListIterator<T, Ref, Ptr> Self;
ListIterator(PNode pNode = nullptr)
:_pNode(pNode)
{}
ListIterator(const Self& l)
{
_pNode = l._pNode;
}
T& operator*()
{
assert(_pNode != _pNode->_pNext);
return _pNode->_val;
}
T* operator->()
{
return &(*this);
}
Self& operator++()
{
_pNode = _pNode->_pNext;
return *this;
}
Self operator++(int)
{
PNode* tmp = _pNode;
_pNode = _pNode->_pNext;
return tmp;
}
Self& operator--()
{
_pNode = _pNode->_pPre;
return *this;
}
Self& operator--(int)
{
PNode* tmp = _pNode;
_pNode = _pNode->_pPre;
return tmp;
}
bool operator!=(const Self& l)
{
return _pNode != l._pNode;
}
bool operator==(const Self& l)
{
return !(*this != l);
}
PNode _pNode;
};
//list类
template<class T>
class list
{
typedef ListNode<T> Node;
typedef Node* PNode;
public:
typedef ListIterator<T, T&, T*> iterator;
typedef ListIterator<T, const T&, const T&> const_iterator;
public:
///
// List的构造
list(const PNode& pHead = nullptr)
{
CreateHead();
/*_pHead = new Node();
_pHead->_pNext = _pHead;
_pHead->_pPre = _pHead;*/
}
list(int n, const T& value = T())
{
CreateHead();
for (int i = 0; i < n; ++i)
push_back(value);
/*int cnt = 0;
while (cnt < n)
{
PNode _first = new Node(value);
PNode tmp = _pHead->_pPre;
tmp->_pNext = _first;
_first->_pPre = tmp;
_first->_pNext = _pHead;
_pHead->_pPre = _first;
++cnt;
}*/
}
template <class Iterator>
list(Iterator first, Iterator last)
{
CreateHead();
while (first != last)
{
push_back(*first);
++first;
}
/*while (first != last)
{
PNode _first = new Node(*first);
PNode tmp = _pHead->_pPre;
tmp->_pNext = _first;
_first->_pPre = tmp;
_first->_pNext = _pHead;
_pHead->_pPre = _first;
++first;
}*/
}
list(const list<T>& l)
{
CreateHead();
list<T> temp(l.cbegin(), l.cend());
swap(temp);
/*iterator first = l._pHead->_pNext;
iterator last = l._pHead;
while (first != last)
{
PNode _first = new Node(*first);
PNode tmp = _pHead->_pPre;
tmp->_pNext = _first;
_first->_pPre = tmp;
_first->_pNext = _pHead;
_pHead->_pPre = _first;
++first;
}*/
}
list<T>& operator=(const list<T> l)
{
CreateHead();
swap(l);
return *this;
/*iterator first = l._pHead->_pNext;
iterator last = l._pHead;
while (first != last)
{
PNode _first = new Node(*first);
PNode tmp = _pHead->_pPre;
tmp->_pNext = _first;
_first->_pPre = tmp;
_first->_pNext = _pHead;
_pHead->_pPre = _first;
++first;
}
return *this;*/
}
~list()
{
clear();
delete _pHead;
_pHead = nullptr;
/*Node* cur = _pHead->_pNext;
Node* tmp = cur->_pNext;
while (cur != _pHead)
{
delete cur;
cur = tmp;
tmp = tmp->_pNext;
}
tmp = cur = nullptr;
_pHead->_pNext = _pHead;
_pHead->_pPre = _pHead;*/
}
///
// List Iterator
iterator begin()
{
return _pHead->_pNext;
}
iterator end()
{
return _pHead;
}
const_iterator begin() const
{
return _pHead->_pNext;
}
const_iterator end() const
{
return _pHead;
}
///
// List Capacity
size_t size()const
{
Node* cur = _pHead->_pNext;
size_t cnt = 0;
while (cur != _pHead)
{
++cnt;
cur = cur->_pNext;
}
return cnt;
}
bool empty()const
{
return size() == 0;
}
// List Access
T& front()
{
return _pHead->_pNext->_val;
}
const T& front()const
{
return _pHead->_pNext->_val;
}
T& back()
{
return _pHead->_pPre->_val;
}
const T& back()const
{
return _pHead->_pPre->_val;
}
// List Modify
void push_back(const T& val) { insert(end(), val); }
void pop_back() { erase(--end()); }
void push_front(const T& val)
{
assert(!empty());
insert(begin(), val);
}
void pop_front() { erase(begin()); }
// 在pos位置前插入值为val的节点
iterator insert(iterator pos, const T& val)
{
Node* cur = pos._pNode;
Node* newnode = new Node(val);
Node* prev = cur->_pPre;
// prev newnode cur
prev->_pNext = newnode;
newnode->_pPre = prev;
newnode->_pNext = cur;
cur->_pPre = newnode;
return iterator(newnode);
}
// 删除pos位置的节点，返回该节点的下一个位置
iterator erase(iterator pos)
{
assert(pos._pNode != _pHead);
Node* Prev = pos._pNode->_pPre;
Node* Next = pos._pNode->_pNext;
delete pos._pNode;
Prev->_pNext = Next;
Next->_pPre = Prev;
return iterator(Next);
}
void clear()
{
iterator cur = begin();
while (cur != end())
{
cur = erase(cur);
}
_pHead->_pNext = _pHead;
_pHead->_pPre = _pHead;
}
void swap(list<T>& l)
{
/*list<T> tmp = l;
l = *this;
*this = tmp;*/
PNode tmp = _pHead;
_pHead = l._pHead;
l._pHead = tmp;
}
private:
void CreateHead()
{
_pHead = new Node();
_pHead->_pNext = _pHead;
_pHead->_pPre = _pHead;
}
PNode _pHead;
};
};
你学会了吗？
好啦，本章对于《C++：list模拟实现》的学习就先到这里，如果有什么问题，还请指教指教，希望本篇文章能够对你有所帮助，我们下一篇见！！！
如你喜欢，点点赞就是对我的支持，感谢感谢！！！
2113
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
