[C++进阶[六]]list的相关接口模拟实现

1.前言

本章重点

在list模拟实现的过程中，主要是感受list的迭代器的相关实现，这是本节的重点和难点。

2.list接口的大致框架

list是一个双向循环链表，所以在实现list之前，要先构建一个节点类

cpp 复制代码

template <class T>
struct ListNode
{
	T _val;
	ListNode* _prev;
	ListNode* _next;
	ListNode(const T& val = T())//构造函数
		:_prev(nullptr)
		, _next(nullptr)
		,_val(val)
	{}
};

节点中存储一个T模板类型的值和
上一个节点的地址和下一个节点的地址

在List类中,由于链表都是些链接关系，所以List类中的成员变量只需要定义一个那就是头节点head,知道head的链接关系。就能够知道list类对象中存放的内容!

cpp 复制代码

template <class T>
class List
{
    public:typedef ListNode<T> Node;
    private:
        //带头节点的无参构造一个随机值
        void CreateHead()
        {
	    _pnode = new Node;
	    _pnode->_prev = _pnode;
	    _pnode->_next = _pnode;
        }
        Node* _pnode;
};

解释：给头节点pnode开辟一份空间后，头节点的指向最开始都是指向自身:

3.list的构造和析构函数

构造函数

此处介绍三种构造函数：空构造；构造n个值为val的节点；用迭代器区间来进行构造

无参构造：

cpp 复制代码

//构造函数1
List()
{
	CreateHead();
}

构造n个值为val的节点

cpp 复制代码

//构造函数2：创建n个值为val的节点
List(int n, const T& val = T())
{
	CreateHead();
	for (int i = 0; i < n; i++)
	{
		push_back(val);
	}
}

这个地方使用了push_back先用着，后续再实现

迭代器区间来进行构造：

cpp 复制代码

//构造函数3：迭代器区间来进行构造
template <class InputerIterator>
List(InputerIterator first, InputerIterator last)
{
	CreateHead();
	while (first != last)
	{
		push_back(*first);
		first++;
	}
}

ps:注意，这里不管是什么构造，在最开始时都需要构造一个带哨兵卫的头节点，所以说都要先使用CreateHead函数来进行构建。

析构函数

由于链表是一块一块的空间，通过某种形式把他连接起来。所以在析构函数时，要先把这些空间全部释放掉，然后再删除带哨兵卫的头结点。

cpp 复制代码

//析构函数
void clear()
{
	iterator it = begin();
	while (it != end())
	{
		it = erase(it);
	}
}
~List()
{
	clear();
	delete _pnode;
	_pnode = nullptr;
}

这里使用到了迭代器来进行遍历，后续会实现迭代器相关的功能。

4.拷贝构造函数和赋值重载函数

拷贝构造函数

直接使用简单快速的写法来完成深拷贝。

cpp 复制代码

	//拷贝构造函数
	List(const List<T>& node)
	{
		CreateHead();
		List<T> tmp(node.begin(), node.end());
		Swap(tmp);
	}
	void Swap(List<T>& node)
	{
		swap(_pnode,node._pnode);
	}

赋值重载函数

cpp 复制代码

	//赋值重载函数
	List<T>& operator=(const List<T>& node)
	{
		List<T>tmp(node.begin(), node.end());
		Swap(tmp);
		return *this;
	}

这样的写法有两个精妙之处：

1.它先定义一个临时变量tmp来接受node的所有值,然后再将临时变量tmp
的pnode和拷贝的pnode交换,这样一来就完成了拷贝构造函数，并且tmp变量是构造函数初始化的，它是深拷贝,所以lt2对于lt1也是深拷贝。
2.tmp是临时变量,除了作用域会销毁，也就是出了此拷贝构造函数后会销毁，销毁时会调用析构函数,然而要构造的pnode以及和tmp的pnode交换了,所以tmp销毁时实际上是在帮原先的要构造的pnode销毁内存!

5.与容量有关的函数

size和empty

cpp 复制代码

bool empty()
{
	return size() == 0;
}

size_t size()
{
	size_t sz = 0;
	iterator it =begin();
	while (it!= end())
	{
		sz++;
		it++;
	}
	return sz;
}

6.迭代器的模拟实现

其实仔细分析下来，发现链表是无法进行*和++，--以及->这些相关操作的。那么想让链表和迭代器一样进行++，--，*和->这些相关的操作，那么只需要封装一个类，把这些函数进行重写就可以了。

迭代器的大体结构如下：

cpp 复制代码

template<class T>
struct List_iterator 
{
	typedef ListNode<T>* PNode;
    typedef List_iterator<T> Self;
	PNode _node;
};

构造函数

cpp 复制代码

List_iterator(const PNode& node=nullptr)
	:_node(node)
{}

拷贝构造

cpp 复制代码

//拷贝构造
List_iterator(const Self& l)
{
	_node=l._node;
}

ps:由于这里把迭代器相关类型重命名成了self，所以这里给出的就直接使用了self

++和--函数

cpp 复制代码

Self& operator++()//前置++
{
	_node = _node->_next;
	return *this;
}
Self& operator--()//前置--
{
	_node = _node->_prev;
	return *this;
}
Self operator++(int) //后置++
{
	List_iterator<T> tmp(*this);
	_node = _node->_next;
	return tmp;
}
Self operator--(int) //后置--
{
	List_iterator<T> tmp(*this);
	_node = _node->_prev;
	return tmp;
}

==和!=函数

cpp 复制代码

bool operator==(const Self& node)
{
	return _node == node._node;
}
bool operator!=(const Self& node)
{
	return _node != node._node;
}

解引用和箭头->函数

迭代器的使用就像指针一样,所以解引用后应该直接得到节点的数据!

cpp 复制代码

	T& operator*()
	{
		return _node->_val;
	}
	T* operator->()
	{
		return &(_node->_val);
	}

解释：解引用大家肯定都能理解。那么对用箭头->函数理解起来可能就有难度了。

举个例子来帮助我们理解

当list容器当中的每个结点存储的不是内置类型，而是自定义类型，例如日期类，那么当我们拿到一个位置的迭代器时，我们可能会使用->运算符访问Date的成员：

cpp 复制代码

	list<Date> lt;
	Date d1(2021, 8, 10);
	Date d2(1980, 4, 3);
	Date d3(1931, 6, 29);
	lt.push_back(d1);
	lt.push_back(d2);
	lt.push_back(d3);
	list<Date>::iterator pos = lt.begin();
	cout << pos->_year << endl; //输出第一个日期的年份

注意： 使用pos->_year这种访问方式时，需要将日期类的成员变量设置为公有。

对于->运算符的重载，我们直接返回结点当中所存储数据的地址即可。

cpp 复制代码

T* operator->()
{
	return &_pnode->_val; //返回结点指针所指结点的数据的地址
}

讲到这里，可能你会觉得不对，按照这种重载方式的话，这里使用迭代器访问日期类当中的成员变量时不是应该用两个->吗？

这里本来是应该有两个->的，第一个箭头是pos ->去调用重载的operator->返回Date* 的指针，第二个箭头是Date* 的指针去访问对象当中的成员变量_year。

但是一个地方出现两个箭头，程序的可读性太差了，所以编译器做了特殊识别处理，为了增加程序的可读性，省略了一个箭头。

7.插入删除相关函数

有了迭代器之后插入删除相关函数就好实现了。

插入函数insert

cpp 复制代码

//在pos位置前插入值为val的节点
iterator insert(iterator pos,const T&val)
{
	//创建节点
	Node* newnode = new Node(val);
	Node* cur = pos._node;
	Node* prev = pos._node->_prev;

	//开始插入
	prev->_next = newnode;
	newnode->_prev = prev;
	newnode->_next = cur;
	cur->_prev = newnode;
	return iterator(newnode);
}

这里我实现的是在插入一个值之后，并把这个值的的迭代器位置返回去。

erase函数

cpp 复制代码

//删除pos节点，然后返回下一个节点
iterator erase(iterator pos)
{
	assert(pos != end());
	Node* cur = pos._node;
	Node* next = pos._node->_next;
	Node* prev = pos._node->_prev;
	delete cur;
	prev->_next = next;
	next->_prev = prev;
	return iterator(next);
}

如果这里不返回一个合法的迭代器位置的话，那么就会有可能出现迭代器失效。

push_back和pop_back

push_back和pop_back函数分别用于list的尾插和尾删，在已经实现了insert和erase函数的情况下，我们可以通过复用函数来实现push_back和pop_back函数。

push_back函数就是在头结点前插入结点，而pop_back就是删除头结点的前一个结点。

cpp 复制代码

	void push_back(const T& val)
	{
		insert(end(), val);
	}
	void pop_back()
	{
		erase(--end());
	}

8.总结

总的来说,list的底层实现较于vector来说要复杂一点,这其中的底层原因
就是list的迭代器还需要一层封装,而vector的迭代器不需要额外封装。但是在我们使用的角度来看，这两者并没有什么区别。

C++的强大就在于把复杂的底层全部封装起来了,而表面的使用上
list和vector并无太大区别,这就是C++封装的魅力!

list模拟实现全部代码如下：

simulate_list/simulate_list · 青酒余成/初识数据结构 - 码云 - 开源中国 (gitee.com)