✨ 夜暗方显万颗星，灯明始见一缕尘 🌏
📃个人主页：island1314
🔥个人专栏：C++学习
🚀 欢迎关注：👍点赞 👂🏽留言 😍收藏 💞 💞 💞
list容器的深度剖析及底层实现
🚀前言
要模拟实现list，必须要熟悉list的底层结构以及其接口的含义，list的底层是带头双向循环链表，现在我们来模拟实现list容器的主要接口。
list的介绍
1、list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
2、list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。3、list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
4、与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
5、与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)
与前面的vector类似，由于使用了模板，也只分成.cpp和.h两个文件。
.cpp文件里放节点类，迭代器类，list类及其成员函数，测试函数的实现，在.h文件里进行测试。
本文的重点是：对三个类的区分与理解，迭代器类的实现。
1. 节点类
1.为什么定义节点结构体时使用struct而不是class?
(1)其实用class也可以，但是class与struct默认的访问限定不同，当没有声明公有，私有时，struct内容默认是公有，class内容默认的私有，所以用class要加上public。
(2)当我们用class没有加上public，也没有实例化对象时，编译不会报错(报私有成员的错误)，因为模版是不会被细节编译的。只有当我们实例化出对象，模版才会被编译，并且类的实例化并不是对所有成员函数都实例化，而是调用哪个成员函数就实例化哪个。这叫做按需实例化。
2.可用匿名对象初始化。如果T是自定义类型，则调用其默认构造，并且T是内置类型也升级成了有默认构造的概念了。
template<class T>
struct ListNode //不能用class，因为要用友元公有化成员变量和成员函数
{
ListNode<T>* _next;
ListNode<T>* _prev;
T _data;
//书写其构造函数，则下面的 _head = new Node() 里面要加参数
ListNode(const T& data = T()) //写成全缺省，避免下面的不带参问题
:_next(nullptr)
, _prev(nullptr)
, _data(data)
{}
};2. 迭代器类
前面学习的string类和vector的迭代器用的是原生指针类型，即T*。但是在list容器中是不能这样的，因为前面两者的底层物理空间是连续的，符合迭代器++与- -的行为。但是list是由一个一个节点构成的，物理空间不连续，Node*的++和- -不符合迭代器的行为，无法变遍历。
所以用一个类把Node* 封装，就可以重载运算符，使得用起来像内置类型，但会转换成函数调用，继而控制Node*的行为。
🌈2.1 普通迭代器类的实现
遍历需要的核心运算符重载是 *，!=，++ 和 ->。所以只需要利用带头双向循环链表的特性，对Node * 进行封装，从而控制Node * 的行为。
/*由于Node*不符合遍历的行为，因为Node*为自定义类型，必须要有内置类型，才能通过编译
Listlterator类封装Node*
再通过重载运算符控制其行为*/
template<class T>
class ListConstIterator //class 封装迭代器，控制其行为
{
typedef ListNode<T> Node;
typedef ListConstIterator<T> Self;
Node* _node;
public:
ListConstIterator(Node *node)
:_node(node)
{}
//前置 ++it
Self& operator++() //自加遍历
{
_node = _node->_next; //往后走
return *this;
}
Self& operator--()
{
_node = _node->_prev; //往前走
return *this;
}
//两个区别：后置不能直接引用返回,而且后置括号中有int进行区分
//后置 就不能引用返回了
Self operator++(int)
{
Self tmp(*this);
_node = _node->_next;
return tmp;
}
Self& operator--(int)
{
Self tmp(*this);
_node = _node->_prev;
return tmp;
}
const T& operator*() //解引用
{
return _node->_data;
}
const T* operator->()
{
return &_node->_data;
}
bool operator!=(const Self& it)
{
return _node != it._node;
}
bool operator == (const Self& it)
{
return _node == it._node;
}
};🌈2、->运算符的使用场景
struct Pos
{
int _row;
int _col;
//用T实例化，必须提供默认构造
Pos(int row = 0, int col = 0)
:_row(row)
, _col(col)
{}
};若我们插入坐标，想要打印出结果，应该怎么做？
错误示范：
void test_list2()
{
list<Pos> lt1;
lt1.push_back(Pos(100, 100));//使用匿名对象
lt1.push_back(Pos(200, 200));
lt1.push_back(Pos(300, 300));
list<Pos>::iterator it = lt1.begin(); //这里的it是Pos*,是结构体指针
while (it != lt1.end())
{
cout << *it << " ";
++it;
}
cout << endl;
}
原因：因为这里的*it返回的是Pos自定义类型，而访问自定义类型需要需要在类中自己重载流插入(<<)，这里并没有重载，所以报错。
正确操遍历的两种方式：
方式1：通过.操作符直接访问结构体的成员变量(一般不这样访问数据)。
cout << (*it)._row << ":" << (*it)._col << endl;//ok
方式2：通过重载->运算符，对结构体指针进行解引用。
cout << it.operator->()->_row << ":" << it.operator->()->_col << endl;//ok
注意：其实这里严格来说是有两个箭头,第一个运算符重载的调用 it.operator->() 返回的是 Pos*，第二个箭头才是原生指针，Pos*再用箭头访问。为了可读性，省略了一个->。
void test_list2()
{
list<Pos>l1;
l1.push_back(Pos(100, 100));
l1.push_back(Pos(200, 200));
l1.push_back(Pos(300, 400));
list<Pos>::iterator it = l1.begin(); //这里的Pos的是结构体指针
//传值返回产生的临时对象不能引用访问
//list<Pos>::iterator& it = l1.begin();
//++为非const，可以用
//list<Pos>::iterator it = ++l1.begin();
while (it != l1.end())
{
//方式一：
//cout << (*it)._row << ":" << (*it)._col <<endl;
//方式二：
cout << it->_row << ":" << it->_col << endl;//结构体或者共有类可以用箭头去访问
//为了可读性省略了一个 ->
//cout << it->->_row << ":" << it->->_col << endl;
cout << it.operator->()->_row << ":" << it.operator->()->_col << endl; //本质，operator返回pos*
++it;
}
cout << endl;
}🌈3、const迭代器类的实现
🥳🥳在我们遍历数据时，有时会写一个打印函数，引用传参，一般建议加const，这就出现了一个const链表：
void Func(const list<int>& lt) //const 迭代器
{
list<int>::const_iterator it = lt.begin();
while (it != lt.end())
{
//指向的内容不能修改
//*it += 10;
cout << *it << " ";
++it;
}
cout << endl;
}const迭代器不是在普通迭代器前面加const,即不是const iterator。
const list<int>::iterator it = lt.begin(); //那么it无法++，因为const改变
const 迭代器目标本身可以修改，指向内容不可以修改，类似于const T* p
因此我们需要再定义一个类，控制*和->的返回值就可以了。
template <class T>
class ListConstIterator
{
typedef ListNode<T> Node;
typedef ListConstIterator<T> Self;//名字变得简短
public:
Node* _node;//定义一个节点指针
ListConstIterator(Node* node)
:_node(node)
{}
//前置:返回之后的值
//++it;//返回与自己一样的类型
Self& operator++()
{
_node = _node->_next;
return *this;
}
Self& operator--()
{
_node = _node->_prev;
return *this;
}
//后置:返回之前的值
Self operator++(int)
{
Self tmp(*this);
_node = _node->_next;
return tmp;
}
Self operator--(int)
{
Self tmp(*this);
_node = _node->_prev;
return tmp;
}
// 所以我们要再定义一个类，使用const控制*和->的返回值就可以
const T& operator*()
{
return _node->_data;
}
const T* operator->()
{
return &_node->_data;
}
bool operator!=(const Self& it)
{
return _node != it._node;
}
bool operator==(const Self& it)
{
return _node == it._node;
}
};
🌈4、通过模板参数，把两个类型的迭代器类结合
🥳🥳可以发现，其实普通迭代器和const迭代器的本质区别是 * 和 ->，这两个运算符的返回类型的变化。两个类代码冗余，所以可以通过模板，给不同的模板参数，让编译器自己实例化两个类。
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;
Self& operator++()
{
_node = _node->_next;
return *this;
}
Self& operator--()
{
_node = _node->_prev;
return *this;
}
Self operator++(int)
{
Self tmp(*this);
_node = _node->_next;
return tmp;
}
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& it)
{
return _node != it._node;
}
bool operator==(const Self& it)
{
return _node == it._node;
}
};
🌈 5、代器类的一些问题的思考
(1) 类中是否需要写析构函数？
这个迭代器类并不用写析构函数，因为这里的节点不是迭代器的，是链表的，不需要把它释放。使用begin（），end（）返回节点给迭代器，是借助迭代器修改，访问数据，所以我们不需要释放。
(2) 类中是否需要写拷贝构造进行深拷贝和写赋值拷贝？
这里也不需要写拷贝构造进行深拷贝，因为这里需要的就是浅拷贝。begin返回了第一个节点的迭代器给it，这里就是用默认生成的拷贝构造，浅拷贝给it，那这两个迭代器就指向同一个节点，所以这里用默认的拷贝构造和赋值拷贝就可以了。
3. list 类
🍋 3.1 list类的结构
template<class T>
class list
{
typedef ListNode<T> Node;
public:
//不符合迭代器行为，无法遍历
//typedef Node* iterator;
//自己实现两个类，但是代码冗余
//typedef ListIterator<T> iterator;
//typedef ListConstIterator<T> const_iterator;
//通过模板，给不同模板参数，让编译器帮我们写两个类（实例化）
typedef ListIterator<T, T&, T*> iterator;
typedef ListIterator<T, const T&, const T*> const_iterator;
private:
Node* _head;
};🍋 3.2 迭代器的实现
🥳🥳包含普通迭代器和const迭代器
iterator begin()
{
//iterator it(_head->_next);
//return it;
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);
}
🍋3.3 插入数据insert
//没有iterator失效
//为防止迭代器失效，需要用 iterator返回
iterator insert(iterator pos, const T& x)
{
Node* newnode = new Node(x);
Node* cur = pos._node; //获取当前位置节点
Node* prev = cur->_prev;
//prev newnode cur
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
return iterator(newnode);
}注意：为了避免链表的insert没有迭代器的失效问题，因为没有扩容的概念，pos位置的节点不会改变。但是STL库里insert也给了返回值，返回的是新插入位置的迭代器。
🍋3.4 删除数据erase
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);
}注意：为防止迭代器失效，需要用 iterator返回，erase后pos失效，pos 指向节点被释放
🍋3.5 头插，头删，尾插，尾删
可以复用前面的 insert和 erase
//尾插:end()的下一个位置
void push_back(const T& x)
{
//Node* newnode = new Node(x);//申请节点并且初始化
//Node* tail = _head->_prev;
链接节点
//tail->_next = newnode;
//newnode->_prev = tail;
//_head->_prev = newnode;
//newnode->_next = _head;
insert(end(), x);
}
//尾删
void pop_back()
{
erase(--end());//注意：前置--
}
//头插:在begin前面插入
void push_front(const T& x)
{
insert(begin(), x);
}
//头删
void pop_front()
{
erase(begin());
}
🍋3.6 常见构造函数的实现
主要包含：构造函数，拷贝构造，initializer_list构造(列表构造)。
注意：由于这些都是在有哨兵位头节点的前提下实现的，所以可以把申请哨兵位头节点这一步骤提取出来。
//空初始化，申请哨兵位头节点
void empty_init()
{
_head = new Node();
_head->_next = _head;
_head->_prev = _head;
}
list()
{
empty_init();
}
//拷贝构造:直接复用尾插，前提要有哨兵位头节点
//lt2(lt1)
list(const list<T>& lt)
{
empty_init();
//注意：使用范围for时加上const和&
for (const auto& e : lt)
{
push_back(e);
}
}
//initializer_list构造，前提要有哨兵位头节点
list(initializer_list<T> il)
{
empty_init();
for (const auto& e : il)
{
push_back(e);
}
}
🍋3.7 析构函数
析构函数的作用是：删除整个链表结构，包括哨兵位头节点。
//清空当前数据 留头节点，其余节点释放
void clear()
{
auto it = begin();
while (it != end())
{
//返回删除节点的下一个节点的迭代器
it = erase(it);
}
}
//析构：销毁整个链表
~list()
{
clear();
delete _head;
_head = nullptr;
}
📖总结及完整代码
完整实现和测试代码及注解如下：
#pragma once
#include<assert.h>
namespace qian
{
template<class T>
struct ListNode
{
ListNode<T>* _next;
ListNode<T>* _prev;
T _data;
ListNode(const T& data = T())
:_next(nullptr)
,_prev(nullptr)
,_data(data)
{}
};
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)
{}
ListIterator(const ListIterator<T, T&, T*>& it)
:_node(it._node)
{}
// ++it;
Self& operator++()
{
_node = _node->_next;
return *this;
}
Self& operator--()
{
_node = _node->_prev;
return *this;
}
Self operator++(int)
{
Self tmp(*this);
_node = _node->_next;
return tmp;
}
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& 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 Node* iterator;
//typedef ListIterator<T> iterator;
//typedef ListConstIterator<T> const_iterator;
// 同一个类模板给不同参数会实例化出不同的类型
typedef ListIterator<T, T&, T*> iterator;
typedef ListIterator<T, const T&, const T*> const_iterator;
iterator begin()
{
//iterator it(_head->_next);
//return it;
return iterator(_head->_next);
}
const_iterator begin() const
{
return const_iterator(_head->_next);
}
iterator end()
{
return iterator(_head);
}
const_iterator end() const
{
return const_iterator(_head);
}
void empty_init()
{
_head = new Node();
_head->_next = _head;
_head->_prev = _head;
}
list()
{
empty_init();
}
list(initializer_list<T> il)
{
empty_init();
for (const auto& e : il)
{
push_back(e);
}
}
// lt2(lt1)
list(const list<T>& lt)
{
empty_init();
for (const auto& e : lt)
{
push_back(e);
}
}
// lt1 = lt3
list<T>& operator=(list<T> lt)
{
swap(_head, lt._head);
return *this;
}
~list()
{
clear();
delete _head;
_head = nullptr;
}
void clear()
{
auto it = begin();
while (it != end())
{
it = erase(it);
}
}
void push_back(const T& x)
{
/*Node* newnode = new Node(x);
Node* tail = _head->_prev;
tail->_next = newnode;
newnode->_prev = tail;
newnode->_next = _head;
_head->_prev = newnode;*/
insert(end(), x);
}
void pop_back()
{
erase(--end());
}
void push_front(const T& x)
{
insert(begin(), x);
}
void pop_front()
{
erase(begin());
}
// 没有iterator失效
iterator insert(iterator pos, const T& x)
{
Node* cur = pos._node;
Node* newnode = new Node(x);
Node* prev = cur->_prev;
// prev newnode cur
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
return iterator(newnode);
}
// erase 后 pos失效了，pos指向节点被释放了
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;
};
void Func(const list<int>& lt)
{
// const iterator const 迭代器不能普通迭代器前面加const修饰
// const 迭代器目标本身可以修改，指向的内容不能修改 类似const T* p
list<int>::const_iterator it = lt.begin();
while (it != lt.end())
{
// 指向的内容不能修改
//*it += 10;
cout << *it << " ";
++it;
}
cout << endl;
}
void test_list1()
{
list<int> lt1;
// 按需实例化（不调用就不实例化这个成员函数）
lt1.push_back(1);
lt1.push_back(2);
lt1.push_back(3);
lt1.push_back(4);
lt1.push_back(5);
Func(lt1);
//ListIterator<int> it = lt1.begin();
list<int>::iterator it = lt1.begin();
while (it != lt1.end())
{
*it += 10;
cout << *it << " ";
++it;
}
cout << endl;
for (auto e : lt1)
{
cout << e << " ";
}
cout << endl;
}
struct Pos
{
int _row;
int _col;
Pos(int row = 0, int col = 0)
:_row(row)
,_col(col)
{}
};
void test_list2()
{
list<Pos> lt1;
lt1.push_back(Pos(100, 100));
lt1.push_back(Pos(200, 200));
lt1.push_back(Pos(300, 300));
list<Pos>::iterator it = lt1.begin();
while (it != lt1.end())
{
//cout << (*it)._row << ":" << (*it)._col << endl;
// 为了可读性，省略了一个->
cout << it->_row << ":" << it->_col << endl;
//cout << it->->_row << ":" << it->->_col << endl;
cout << it.operator->()->_row << ":" << it.operator->()->_col << endl;
++it;
}
cout << endl;
}
void test_list4()
{
list<int> lt1;
lt1.push_back(1);
lt1.push_back(2);
lt1.push_back(3);
lt1.push_back(4);
lt1.push_back(5);
Func(lt1);
lt1.push_front(10);
lt1.push_front(20);
lt1.push_front(30);
Func(lt1);
lt1.pop_front();
lt1.pop_front();
Func(lt1);
lt1.pop_back();
lt1.pop_back();
Func(lt1);
lt1.pop_back();
lt1.pop_back();
lt1.pop_back();
lt1.pop_back();
//lt1.pop_back();
Func(lt1);
}
void test_list5()
{
list<int> lt1;
lt1.push_back(1);
lt1.push_back(2);
lt1.push_back(3);
lt1.push_back(4);
lt1.push_back(5);
Func(lt1);
list<int> lt2(lt1);
lt1.push_back(6);
Func(lt1);
Func(lt2);
list<int> lt3;
lt3.push_back(10);
lt3.push_back(20);
lt3.push_back(30);
lt1 = lt3;
Func(lt1);
Func(lt3);
}
void test_list6()
{
list<int> lt1 = { 1,2,3,4,5,6 };
Func(lt1);
}
}
以上就是List链表的全部内容啦
💞 💞 💞本篇到此就结束，希望我的这篇博客可以给你提供有益的参考和启示，感谢大家支持！！！祝大家天天顺心如意。
扫一扫
1380
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
