c++编程（15）——list的模拟实现

欢迎来到博主的专栏------c++编程

博主ID：代码小豪

---

文章目录

• • 前言
  • list的数据结构
  • list的默认构造
  • 尾插与尾删
  • iterator
  • 插入和删除
  • 构造、析构、赋值
  • • copy构造
    • initializer_list构造
    • [operator =](#operator =)
    • 析构函数

前言

受限于博主当前的技术水平，暂时还不能模拟实现出STL当中用到的allocator，所以在这片博客当中，博主更想表达的是list的数据结构，以及list的各个操作涉及的算法，还有list的迭代器是怎样的工作原理。

博主参考的是SGI版本的STL源码，如果你对源码非常感兴趣，可以私聊博主获取源码。

在《vectoe的模拟实现》这一博客当中，我是按照c++在线文档的接口顺序来模拟实现的，但是list的结构要比vector复杂，所以博主选择跳跃式的方法来模拟实现list。

list的数据结构

list是一个带头双向循环链表的数据结构，其结点具有以下结构

1. 存储数据的val
2. 指向上一个节点的指针prev
3. 指向下一个节点的指针next
   

而链表的结构则需要将表头节点和尾结点链接起来，头结点不存储有效数据，只记录前驱节点和后继节点。

那么我们需要定义两个类，一个类是节点，另外一个类是管理头结点的链表。链表中的成员只需要一个，那就是指向头结点的指针。

	template<class T>
	struct ListNode//结点
	{
		T _data;//数据
		ListNode* _next;//指向下一个节点的指针
		ListNode* _prev;//指向上一个节点的指针
	};

	template<class T>
	class list
	{
		typedef ListNode<T> Node;
		Node* _head;//指向链表头结点
	};

list的默认构造

我们先来为链表和节点设计一个默认构造吧、还有其他的构造等我们实现了list的插入和删除再来实现。

先来想想怎么默认构造链表，根据c++标准，list的默认构造是实例化出一个空表，由于list是一个带头双向循环链表，因此即使list是一个空表，我们也需要生成这个链表的头结点（带头链表的头结点是不计入有效节点的）。

由于头结点不设置有效数据，那么在构造头结点的时候，我们只需要调用节点的默认构造就行。

list()
{
	_head = new Node;//_head指向头结点，头结点是默认构造的Node
	_head->next=_head;
	_head->prev=_head;
}

那么问题就来了，list的默认构造会调用Node的默认构造，可是Node的默认构造还没有生成呢！

节点的默认构造则是这样，我们允许节点传入一个T类型的参数val，这个val是传递给data的值。但是有参数的构造不属于默认构造，那么我们就为这个val设置一个缺省值吧，由于ListNode是一个模板类，那么data的值可能是各种各样的类，我们应该为这个val设置什么缺省值呢？

用匿名对象T()作为val的缺省值，如果T实例化成了内置类型，那么val的缺省值就是0，如果T实例化成了类类型，比如string。那么val的缺省值就会调用T类型的默认构造。

ListNode(T val = T())
{
	date = val;
	next = nullptr;
	prev = nullptr;
}

尾插与尾删

实际上push_back和pop_back应该放在插入和删除那一部分的，但如果你查看一下c++手册，你会发现insert和erase都需要用到迭代器，但是如果我们要实现迭代器，又需要插入和删除数据才能验证这些迭代器是无误的，那么这就进入了死循环。

好在push_back和push_pop不需要迭代器，那么我们先来实现这两个操作吧。

void push_back(const T& val);
void push_back();

我们先找到当前链表的尾结点，双向链表的尾结点是非常好找的，_head->prev就是尾结点。尾插的操作如下：

（1）new一个新节点newnode

（2）newnode的next指向头结点

（3）newnode的prev指向尾结点

（4）让尾结点的next指向newnode

（5）头结点的prev指向newnode

void push_back(const T& val)
{
	Node* tail = _head->prev;//找到尾结点
	Node* newnode = new Node(val);
	newnode->next = _head;
	newnode->prev = tail;
	tail->next = newnode;
	_head->prev = newnode;
}

尾删法的操作如下：

（1）找到尾结点tail的前驱节点Prev。

（2）让Prev的next指向_head

（3）让_head的prev指向Prev

（4）delete掉tail节点

不过有一点要注意，那就是避免对空表进行尾删操作，这是会导致程序报错的，因此我们可以设置一个异常，也可以直接断言。这里博主为了方便就选择断言了

void push_back()
{
	Node* tail = _head->prev;//找到tail节点
	assert(tail != _head);//当尾结点就是头结点时，list为空表
	Node* prev = tail -> prev;//找到prev节点

	prev->next = _head;
	_head->prev = prev;
	delete tail;
}

这个断言其实不太好，等我们实现了list的迭代器后，我们可以让迭代器完成这项工作，即

assert(this->begin()!=this->!end());

iterator

好吧，最终还是来到了最让我头疼的iterator部分，我第一次尝试实现迭代器的时候是非常痛苦的。不过还是从SGI版本的list的迭代器中学到了精妙的编程方式，也深深的感叹c++封装特性的奇妙之处。

在string和vector的模拟实现当中，博主都是粗暴的将容器中的指针当成迭代器来使用，即

typedef T* iterator;

这是因为string和vector的元素的存储方式都是连续存储。这就导致指针的行为逻辑（++，--，判断）都和迭代器一致。因此我们可以直接把指针当做迭代器。

但是list可不是顺序存储的数据结构，如果我们还是让迭代器具有指针的行为逻辑，那么迭代的结果肯定是飞到姥姥家去了。原因也很简单，迭代器需要执行++操作的吧，而指针++是指向顺序存储的下一个元素空间，但是list不是顺序存储，那么迭代器指向的空间就是未使用的空间，那不成野指针了吗。

那么我们该怎么实现list的迭代器呢？SGI板的STL是这么解决的，list的迭代器的主要问题是由于指针的行为不符合list的迭代要求，那么我们将指针封装起来，成为一个类，那么我们不就可以定义operator++，operator--，使得这个指针符合list迭代的需求。简直是一个奇妙的想法。

博主这里直接将这个类模拟实现出来，源码之下没有秘密，千言万语不如让大家亲身感受。

template<class T,class ref,class ptr>
struct listiterator
{
	typedef ListNode<T> Node;
	typedef listiterator self;
	listiterator(Node* listnode=nullptr)
	{
		linkptr = listnode;
	}
	self operator++()//前置++
	{
		linkptr = linkptr->next;
		return linkptr;
	}

	self operator++(int)//后置++
	{
		listiterator tmp = linkptr;
		linkptr = linkptr->next;
		return tmp;
	}

	self operator--()//前置--
	{
		linkptr = linkptr->prev;
		return linkptr;
	}

	self operator--(int)//后置--
	{
		listiterator tmp = linkptr;
		linkptr = linkptr->next;
		return tmp;
	}

	ref operator*()//解引用
	{
		return linkptr->data;
	}

	ptr operator->()//成员访问
	{
		return &(linkptr->data);
	}

	bool operator!=(listiterator it)//判等
	{
		return linkptr != it.linkptr;
	}

	bool operator==(listiterator it)//判等
	{
		return linkptr == it.linkptr;
	}

	Node* linkptr;
};

list的迭代器的设计思路是这样的：由于Node*的指针的行为不符合list对迭代器的需求。那么就把指针封装起来，设计成一个类，这样我们就能在类中重载各种操作符的函数，使这个类符合迭代器的行为。

比如，listiterator的迭代器进行++操作，linkptr并不会指向顺序结构的下一个元素的位置，而是指向节点的后继节点，这就使listiertaor符合list的迭代器行为，然后在list当中将listiterator实例化成iterator。这样就能用迭代器完成迭代操作了。

既然写好了迭代器的类，现在就将迭代器放进list类中吧，顺便再把begin和end实现出来

template<class T>
	class list
	{
	public:
		typedef ListNode<T> Node;
		typedef listiterator<T, T&, T*> iterator;
		typedef listiterator<T, const T&, const T*> const_iterator;
		iterator begin()
		{
			return _head->next;//begin返回第一个有效节点
			//即_head的下一个节点
		}

		const_iterator begin()const
		{
			return _head->next;
		}

		iterator end() 
		{
			return _head;
			//头节点是无效节点，当链表遍历到这里时，即为遍历成功
		}

		const_iterator end() const
		{
			return _head;
		}

	private:
		Node* _head;//指向链表头结点
	};
}

begin()指向list中的第一个有效数据，因此我们返回_head->next.

而end()指向list的无效数据（因为STL规定begin到end的区间是左闭右开[begin,end)，这意味着end()返回无效的位置），而头结点保存的是无效数据，因此end()返回头结点_head

我们用范围for测试一下，如果成功，就代表迭代器实现完成了。

void TestMylist1()
{
	list<int> list1;
	list1.push_back(1);
	list1.push_back(2);
	list1.push_back(3);
	list1.push_back(4);

	for (auto& e : list1)
	{
		cout << e << ' ';
	}
}

插入和删除

我们先来写写单元素的insert和erase。来看看c标准定义的函数原型吧。

iterator insert (iterator position, const value_type& val);
iterator erase (iterator position);

insert需要传入迭代器position，在position位置处插入新的节点。具体操作如下：

（1）构造一个值为val的新节点newnode

（2）令position位置的节点为cur，cur的前驱节点为prev

（3）让newnode的next指向cur

（4）让newnode的prev指向prev。

（5）让prev的next指向newnode

（6）让cur的prev指向newnode

这个position可以是任意位置，包括头结点和尾结点。我们注意insert是存在返回值的，而且返回值是一个迭代器。我们查看c++文档的叙述。这个返回值是指向新插入的节点的迭代器。

iterator insert(iterator position, const T& val)
{
	Node* newnode = new Node(val);
	Node* cur = position.linkptr;
	Node* prev = cur->prev;

	newnode->next = cur;
	newnode -> prev = prev;
	prev->next = newnode;
	cur->prev = newnode;
	return iterator(newnode);
}

erase也是通过迭代器position确定删除的节点位置，具体操作如下：

（1）让position位置的节点为cur

（2）让cur的前驱节点为prev，让position的后继节点为next

（3）让prev的next指向next

（4）让next的prev指向prev

（5）delete掉cur

要注意erase操作不能删除头结点（STL中的list也是这么做的），即pos位置不能是list.end()因此我们在函数的前面加上一句断言。

c++标准当中规定，erase返回被删除节点的下一个节点。因此erase应该实现成这样。

iterator erase(iterator position)
{
	assert(position != end());
	Node* cur = position.linkptr;
	Node* prev = cur->prev;
	Node* next = cur->next;

	next->prev = prev;
	prev->next = next;

	return iterator(next);
}

insert和erase其实是很万能的，如果我们想要头插，可以调用erase(list.begin(),val)，如果想要头删，可以调用erase(list.begin())。包括尾插和尾删，我们都可以通过insert和erase实现操作。因此push_back，push_fornt，pop_back，pop_front，都可以复用insert和erase.

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

		void pop_back()
		{
			erase(--end());
		}

		void push_front(const T&val)
		{
			insert(begin(), val);
		}

		void pop_front()
		{
			erase(end());
		}

构造、析构、赋值

通常我们在写一个类时，都会先写类的构造、析构、赋值重载函数。但是list有点不同，因为list的大部分构造、析构都依赖迭代器的实现。因此在list的末尾，博主才对这些函数进行实现。

copy构造

copy (4)	
list (const list& x);

list的拷贝构造是深拷贝，浅拷贝会导致内存错误，list深拷贝的方法如下：

我们遍历x，将x的元素按照顺序尾插到list容器中。但是光拷贝可不行啊，容器还没有生成头结点（遍历x的时候可不会遍历头结点，因为头结点被视为容器的终点end）。所以我们先创建一个头结点。

void emptynode()//创建头结点
{
	_head = new Node;//_head指向头结点，头结点是默认构造的Node
	_head->next = _head;
	_head->prev = _head;
}

emptynode函数只用于对象构造时创建空节点，所以我们最好把它隐藏起来（protected或者private）。

		list(const list& l1)
		{
			emptynode();
			for (const auto& e : l1)
			{
				push_back(e);
			}
		}

initializer_list构造

initializer_list是c++11新增的模板类，关于initializer_list大家可以查看c++手册，或者查看博主的另一篇博客：好用的c++11语言特性

initializer list (6)	
list (initializer_list<value_type> il,
       const allocator_type& alloc = allocator_type());

initializer_list可以简单的认为是一个存储数据数组，那么构造的方法也很简单，遍历initializer_list的元素，将元素挨个尾插到容器当中。

list<int> list2(list1);
for (const auto& e : list2)
{
	cout << e << ' ';
}

operator =

赋值操作和拷贝操作的逻辑一致，我直接套用就行。不过这种套用可是单纯的将程序代码复制粘贴过来，我们会利用到一种取巧的方法

const list& operator=(list x)
{
	std::swap(_head, x._head);
	return *this;
}

ok，就是这么一个简短的代码，但是其思想可一点都不简短。

首先是函数的形参，没有继续采取常用的pass by const reference(const T&)。而是选择了pass by value的形式， 这就导致调用operator=函数时，形参x会调用拷贝构造构造拷贝实参。

然后我们将容器的头结点和x的头结点进行交换，使得容器获得实参的内容。

ok，我们发现了一个有趣的现象，容器现在结构、数据都和实参一致了，这难道不是完成了复制操作吗？

而且这种方法还有一个特别有意思的地方，x是一个临时变量，这就说明x中的空间是没有实际作用的，我们需要将其空间释放掉，但是x是栈帧中的参数，一旦离开了栈帧，x会调用析构函数将资源依次释放。是不是很神奇，简短的三行代码，竟然进行了这么多的操作。而且效率还不低。

析构函数

好吧，讲到最后才完成析构函数，这其实不是很好的习惯，如果你将析构函数放到最后一步，一旦程序通过了测试，你可能就认为已经完成了所有操作，便遗忘掉了析构函数，那么等到内存泄漏的时候可就麻烦了。

list的析构函数应该完成以下操作，释放所有的有效结点，最后释放头结点。额，实际上c++标准定义了list的成员函数clear，clear会释放除头结点外的所有节点。那么为什么博主没有提到呢？因为博主忘了哈哈哈哈。

我们从第一个有效节点开始遍历，每遍历一个节点就释放该节点的空间，直到我们回到头结点为止。

void clear()
{
	iterator start = begin();
	while (start != end())
	{
		start=erase(start);
	}
}

erase的返回值是被删除节点的下一个节点，正好拿来用了哈哈哈。

诶，我们的析构函数是做什么来着，先释放所有的有效节点，再释放头结点，OK，clear正好是释放所有的有效节点，那我们就直接拿来复用就行了啊。

~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}