【STL】list容器的使用以及模拟实现

最新推荐文章于 2024-08-30 16:00:44 发布

fulufulucode

最新推荐文章于 2024-08-30 16:00:44 发布

阅读量587

点赞数 20

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/fulufulucode/article/details/141610981

版权

1.简要介绍list

1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。（相较于vector，list的的插入删除效率更高，因为底层数据结构是链表，没有挪动数据和插入数据带来的巨大消耗）。

2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。

3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。

4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。

5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素）。

2.list的使用

由于之前已经具体介绍过vector的用法，这里不再详细说明list的相关接口。

可以对照文档查阅：list文档

其中较为常用的有：

begin: 获取起始位置迭代器

end: 获取有效位置的下一个位置的迭代器

push_front: 头插数据

pop_front: 尾删数据

push_back: 尾插数据

pop_back: 尾删数据

erase: 指定位置删除数据，并且返回其有效位置的下一个位置的迭代器

insert: 指定位置前插入数据

swap：交换两个list容器的内容

list的使用总体来说比较简单，其中需要注意的点是：

1.list提供的迭代器类型为bidirectional_iterator（双向迭代器），而之前提到的vector提供的是random_access_iterator（随机迭代器），两者的区别是双向迭代器提供了++，--，!= ,==的运算符重载，但是不支持 +,-整数，以及> <等运算符。这也导致了双向迭代器不支持随机访问，无法使用sort等需要随机迭代器的函数。

2.执行删除操作后，删除位置的迭代器会失效，需要通过返回值更新

3.list的模拟实现

为了更加清晰的展示，以下都为声明和定义分离的形式。

3.1 list底层数据结构以及封装

为了实现链表的的数据结构，首先要定义list的节点：

//list节点类
template<class T>//设计成模板，实现基本的泛型结构
struct ListNode
{
	ListNode(const T& val = T());//提供默认构造
	ListNode<T>* _pPre;//指向上一个节点的指针
	ListNode<T>* _pNext;//指向下一个节点的指针
	T _val;//数据
};

template<class T>
ListNode<T>::ListNode(const T& val)//构造
	:_pPre(this)                   //提供一个传入数据的构造
	, _pNext(this)                 //方便list使用
	, _val(val)
{}

链表数据结构的框架非常简单，重点在下面的增删查改操作中。

3.2 list的主体结构

//list类
template<class T>
class list
{
	typedef ListNode<T> Node;
	typedef Node* PNode;
	typedef ListIterator<T, T&, T*> iterator; //重点关注iterator和const_iterator        
                                              //模板参数的区别
	typedef ListIterator<T, const T&, const T*> const_iterator;
	typedef Reverse_iterator<iterator,T&,T*> reverse_iterator;
	typedef Reverse_iterator<const_iterator, const T&, const T*> const_reverse_iterator;
public:
	list();//默认构造
	list(int n ,const T& value = T());//n个元素构造
	template<class Iterator>
	list(Iterator first, Iterator last);//任意迭代器区间初始化
	list(const list<T>& l);//拷贝构造
	list<T>& operator=(const list<T>& l);//赋值运算符重载
	~list();//析构
	//list iterator
	iterator begin();//获取起始位置迭代器
	iterator end();//获取有效位置的下一个迭代器
	const_iterator begin()const;//体现了iterator设置三个参数的好处
	const_iterator end()const;//  不用单独写const迭代器的函数逻辑
	//反向迭代器
	reverse_iterator rbegin();//获取反向起始位置迭代器
	reverse_iterator rend();//获取反向末尾位置迭代器
	const_reverse_iterator rbegin()const;//反向const版
	const_reverse_iterator rend()const;//反向const版

	//list modify
	void push_back(const T& val);//尾插
	void pop_back();//尾删
	void pop_front();//头删
	void push_front(const T& val);//头插
	iterator erase(iterator pos);//指定位置删除
	iterator insert(iterator pos, const T& val);//在pos位置前插入
	void clear();//清空list
	void swap(list<T>& l);//交换

	// list access
	T& front();//获取起始元素
	const T& front()const;//获取起始元素
	T& back();//获取末尾元素
	const T& back()const;//获取末尾元素

	//list capacity 
	size_t size()const;//获取元素个数
	bool empty();//判断是否为空
private:
	PNode _pHead;//头节点指针
	void CreateHead();//创建头节点(建议分离出来，因为各个构造都要用)
};

从list主体部分可以看出，比较复杂的部分在于Listiterator（链表迭代器）的相关定义和封装，这也是list实现的难点。

3.3 list的初始化以及销毁（构造析构等）具体实现

	//list部分
template<class T>
list<T>::list()//默认构造
{
	CreateHead();//复用CreateHead()
}

template<class T>
list<T>::list(int n, const T& value)//n个元素构造
{
	CreateHead();//复用CreateHead()
	for (int i = 0; i < n; ++i)
	{
		push_back(value);//复用push_back
	}
}

template<class T>
template<class Iterator>
list<T>::list(Iterator first, Iterator last)//任意迭代器区间初始化
{
	CreateHead();//复用CreateHead()
	while (first != last)
	{
		push_back(*first);
		++first;
	}
}
template<class T>
list<T>::list(const list<T>& l)//拷贝构造
{
	CreateHead();//复用CreateHead()
	auto it = l.begin();
	while (it != l.end())
	{
		push_back(*it);
		++it;
	}
}

template<class T>
list<T>& list<T>::operator=(const list<T>& l)//赋值运算符重载
{
    //赋值前先清理被赋值对象的资源
	clear();
    //注意是深拷贝
	for (auto e : l)
	{
		push_back(e);//复用push_back
	}
	return *this;
}

template<class T>
list<T>::~list()//析构
{
	while (!empty())
	{
		erase(begin());//复用erase()逻辑，也可复用clear()
	}
    //由于erase（）无法释放头节点，所以头节点要手动释放
	delete _pHead;
	_pHead = nullptr;
}

其中复用了CreateHead()，以及erase(),push_back等操作(在增删查改部分) ，CreateHead()的具体实现如下：

template<class T>
void list<T>::CreateHead()//创建头节点
{
	_pHead = new Node;
}

list的底层数据结构是带头双向链表，所以在初始化过程中要先创建头节点。

3.4 list增删查改具体实现

template<class T>
typename list<T>::iterator list<T>::insert(iterator pos, const T& val)//在pos位置前插入
{
	PNode newnode = new Node(val);
	PNode pcur = pos._pNode;
	PNode prev = pcur->_pPre;
	newnode->_pNext = pcur;
	newnode->_pPre = prev;
	prev->_pNext = newnode;
	pcur->_pPre = newnode;
	return newnode;
}

template<class T>
void list<T>::push_front(const T& val)//头插
{
	insert(begin(), val);
}

template<class T>
void list<T>::pop_front()//头删
{
	erase(begin());
}

template<class T>
void list<T>::pop_back()//尾删
{
	erase(--end());
}

template<class T>
void list<T>::push_back(const T& val)//尾插
{
	insert(_pHead, val);
}


template<class T>
typename list<T>::iterator list<T>::erase(iterator pos)//指定位置删除
{
    //判断pos位置是否为头节点
	assert(pos != end());
    //保存pos节点之前，之后的节点指针，便于删除后链接前后
	PNode pcur = pos._pNode;//访问迭代器中的节点
	PNode prev = pcur->_pPre;
	PNode pnext = pcur->_pNext;
    //释放pos位置节点
	delete pcur;
	prev->_pNext = pnext;
	pnext->_pPre = prev;
	return pnext;//注意返回值是pos节点的下一个
}

template<class T>
void list<T>::clear()//清空list
{
	while (!empty())
	{
		erase(begin());
	}
}

template<class T>
void list<T>::swap(list<T>& l)//交换
{
    //直接交换头节点指针，减少消耗
	PNode tmp = _pHead;
	_pHead = l._pHead;
	l._pHead = tmp;
}

template<class T>
T& list<T>::front()//获取起始元素
{
	return *begin();
}

template<class T>
const T& list<T>::front()const//获取起始元素
{
	return *begin();
}

template<class T>
T& list<T>::back()//获取末尾元素
{
	return *(--end());
}

template<class T>
const T& list<T>::back()const//获取末尾元素
{
	return *(--end());
}

template<class T>
size_t list<T>::size()const//获取元素个数
{
	size_t count = 0;
	for (auto e : *this)
	{
		++count;
	}
	return count;
}

template<class T>
bool list<T>::empty()//判断是否为空
{
	return _pHead == _pHead->_pNext;
}

可以看到增删查改的核心在于insert()，和erase()函数，其他大多数只需要复用就可以了。

3.5 list迭代器的封装与实现

首先是迭代器的主体部分：

//list迭代器类
//这样写的好处是只用写一个模板就可以实现iterator和const_iterator
template<class T, class Ref, class Ptr>
struct ListIterator
{
	typedef ListNode<T>* PNode;
	typedef ListIterator<T, Ref, Ptr> Self;
	ListIterator(PNode pNode = nullptr);//迭代器默认构造
	Ref operator*();//解引用重载
	Ptr operator->();//箭头重载
	Self& operator--();// 前置--重载
	Self operator--(int);// 后置--重载
	Self& operator++();// 前置++重载
	Self operator++(int);// 后置++重载
	bool operator!=(const ListIterator<T, Ref, Ptr>& other);// !=重载
	bool operator==(const Self& other);// ==重载
	PNode _pNode;
};

需要注意的是模板参数列表中的三个值，在list主体中对应的传入类型，这样写提高了模板的泛用性，这样写的好处是只用写一个模板就可以实现iterator和const_iterator，需要仔细体会，这种代码复用叫做适配器模式。

具体实现：

template<class T>
typename list<T>::iterator list<T>::begin()//获取起始位置迭代器
{
	return _pHead->_pNext;
}

template<class T>
typename list<T>::const_iterator list<T>::begin()const//获取起始位置迭代器
{
	return _pHead->_pNext;
}

template<class T>
typename list<T>::iterator list<T>::end()//获取有效位置的下一个迭代器
{
	return _pHead;
}

template<class T>
typename list<T>::const_iterator list<T>::end()const//获取有效位置的下一个迭代器
{
	return _pHead;
}


//iterator内部分
template<class T, class Ref, class Ptr>
ListIterator<T, Ref, Ptr>::ListIterator(PNode pNode)//构造
	:_pNode(pNode)
{}

template<class T,class Ref,class Ptr>
bool ListIterator<T, Ref, Ptr>::operator!=(const ListIterator<T, Ref, Ptr>::Self& other)// !=重载
{
	return this->_pNode != other._pNode;
}

template<class T, class Ref, class Ptr>
bool ListIterator<T, Ref, Ptr>::operator==(const ListIterator<T, Ref, Ptr>::Self& other)// ==重载
{
	return this->_pNode == other._pNode;
}


template<class T, class Ref, class Ptr>
Ptr ListIterator<T, Ref, Ptr>::operator->()// ->重载
{
	return &_pNode->_val;
}

template<class T, class Ref, class Ptr>
Ref ListIterator<T, Ref, Ptr>::operator*()// *重载
{
	return _pNode->_val;
}

template<class T, class Ref, class Ptr>
typename ListIterator<T, Ref, Ptr>::Self& ListIterator<T, Ref, Ptr>::operator--()// 前置--重载 
{
	_pNode = _pNode->_pPre;//内部指针向前走
	return *this;
}

template<class T, class Ref, class Ptr>
typename ListIterator<T, Ref, Ptr>::Self ListIterator<T, Ref, Ptr>::operator--(int)// 后置--重载 
{
	PNode pcur = _pNode;//内部指针先保存再向前走
	_pNode = _pNode->_pPre;
	return pcur;
}

template<class T, class Ref, class Ptr>
typename ListIterator<T, Ref, Ptr>::Self& ListIterator<T, Ref, Ptr>::operator++()// 前置++重载
{
	_pNode = _pNode->_pNext;//内部指针向后走
	return *this;
}

template<class T, class Ref, class Ptr>
typename ListIterator<T, Ref, Ptr>::Self ListIterator<T, Ref, Ptr>::operator++(int)// 后置++重载
{
	PNode pcur = _pNode;//内部指针先保存再向后走
	_pNode = _pNode->_pNext;
	return pcur;
}

在实现迭代器时核心思想就是封装底层结构，同时模拟指针的行为。

list与vector不同，因为空间不连续，想要模拟指针的行为必须封装后进行运算符重载，在进行++和--操作是实际上变更迭代器内部节点的地址。

3.6 list反向迭代器的封装和实现

//反向迭代器
template<class Iterator,class Ref,class Ptr>
struct Reverse_iterator
{
	typedef Reverse_iterator<Iterator, Ref, Ptr> Self;
	Reverse_iterator(Iterator it = Iterator());//反向迭代器默认构造
	Ref operator*();//解引用重载
	Ptr operator->();//箭头重载
	Self& operator--();// 前置--重载
	Self operator--(int);// 后置--重载
	Self& operator++();// 前置++重载
	Self operator++(int);// 后置++重载
	bool operator!=(const Self& other);// !=重载
	bool operator==(const Self& other);// ==重载

	Iterator _it;//复用正向迭代器
};

类比上面普通迭代器的实现，反向迭代器同样可以使用适配器模式封装。

同时可以复用正向迭代器的代码，将逻辑反转即可：

template<class T>
typename list<T>::reverse_iterator list<T>::rbegin()//获取反向起始位置迭代器
{
	return (--end());
}

template<class T>
typename list<T>::const_reverse_iterator list<T>::rbegin()const//获取反向起始位置迭代器const
{
	return (--end());
}

template<class T>
typename list<T>::reverse_iterator list<T>::rend()//获取反向末尾位置迭代器
{
	return (end());
}

template<class T>
typename list<T>::const_reverse_iterator list<T>::rend()const//获取反向末尾位置迭代器const
{
	return (end());
}

//Reverse_iterator部分
template<class Iterator, class Ref, class Ptr>
Reverse_iterator<Iterator, Ref, Ptr>::Reverse_iterator(Iterator it)//反向迭代器默认构造
	:_it(it)
{}


    //全部复用iterator的(反着)
template<class Iterator, class Ref, class Ptr>
bool Reverse_iterator<Iterator, Ref, Ptr>::operator!=(const Reverse_iterator<Iterator, Ref, Ptr>::Self& other)// !=重载
{
	return _it != other._it;
}

template<class Iterator, class Ref, class Ptr>
bool Reverse_iterator<Iterator, Ref, Ptr>::operator==(const Reverse_iterator<Iterator, Ref, Ptr>::Self& other)// ==重载
{
	return _it == other._it;
}


template<class Iterator, class Ref, class Ptr>
Ptr Reverse_iterator<Iterator, Ref, Ptr>::operator->()// ->重载
{
	return _it.operator->();
}

template<class Iterator, class Ref, class Ptr>
Ref Reverse_iterator<Iterator, Ref, Ptr>::operator*()// *重载
{
	return *_it;
}

template<class Iterator, class Ref, class Ptr>
typename Reverse_iterator<Iterator, Ref, Ptr>::Self& Reverse_iterator<Iterator, Ref, Ptr>::operator--()// 前置--重载 
{
	++_it;
	return *this;
}

template<class Iterator, class Ref, class Ptr>
typename Reverse_iterator<Iterator, Ref, Ptr>::Self Reverse_iterator<Iterator, Ref, Ptr>::operator--(int)// 后置--重载 
{
	Self temp = *this;
	++_it;
	return temp;
}

template<class Iterator, class Ref, class Ptr>
typename Reverse_iterator<Iterator, Ref, Ptr>::Self& Reverse_iterator<Iterator, Ref, Ptr>::operator++()// 前置++重载
{
	--_it;
	return *this;
}

template<class Iterator, class Ref, class Ptr>
typename Reverse_iterator<Iterator, Ref, Ptr>::Self Reverse_iterator<Iterator, Ref, Ptr>::operator++(int)// 后置++重载
{
	Self temp = *this;
	--_it;
	return temp;
}

4.总结

list的封装比较复杂，如果是声明和定义分离的话，要注意指定类域到底是哪一个，要搞清list主体，list节点，list迭代器之间的关系，以及模板内部传参是如何向下传递的。最主要的难点就在于迭代器的实现，而且模板的使用过程中可能经常因为语法不正确而报一大堆错，需要细心检查。

fulufulucode

关注

20
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
【STL】list容器的使用以及模拟实现

list的封装比较复杂，如果是声明和定义分离的话，要注意指定类域到底是哪一个，要搞清list主体，list节点，list迭代器之间的关系，以及模板内部传参是如何向下传递的。最主要的难点就在于迭代器的实现，而且模板的使用过程中可能经常因为语法不正确而报一大堆错，需要细心检查。
复制链接

扫一扫