C++《list的模拟实现》

在上一篇C++《list》专题当中我们了解了STL当中list类当中的各个成员函数该如何使用，接下来在本篇当中我们将试着模拟实现list，在本篇当中我们将通过模拟实现list过程中深入理解list迭代器和之前学习的vector和string迭代器的不同，接下来就开始本篇的学习吧！！！

---

1.实现各个函数之前的工作

在list模拟实现中由于是使用类模板来模拟实现list，因此在此list内的函数声明与定义就不分离，这里的原因接下来在模板进阶篇章中会进行讲解。

所以只需要两个文件list.cpp与test.cpp；在list.cpp内实现list类，在test测试实现的list各个成员函数是否满足我们的要求。并且为了避免我们模拟实现的list和std命名空间内的std冲突，在此要将模拟实现的list放在我们新创建的命名空间内

完成了程序文件的实现接下来来实现list类内的成员变量，由于STL内的list其实是一个双链表也就是带头双向循环链表，因此和之前在数据结构内实现链表一样先要实现一个结构体来表示链表的节点

注：链表的节点也是用模板来实现这样就可以使得链表的节点可以存储任意类型的数据。并且由于要实现的是双链表因此链表的节点当中有三个数据分别是存储的数据、指向前一个节点的指针、指向后一个节点的指针

#include<iostream>
using namespace std;

namespace zhz
{

	template<class T>
	struct list_node
	{

		T date;
		list_node<T>* prev;
		list_node<T>* next;

		list_node(const T& x = T())
		:date(x)
		, prev(nullptr)
		, next(nullptr)
		{

		}

	};


}

由于以上的类在之后创建的list类当中使用到list_node内的成员函数以及成员变量，因此就直接将该类用struct来创建，这样就会使得内部的成员函数以及成员变量默认都是公有的，这是你可能有会有疑惑这样不会使得用户可以修改程序底层的数据破坏原有的封装了吗？

在此其实时不会出现这样的问题，这是因为用户在使用时时无法感受到容器底层的结构的，就比如在学习list底层之前用户是无法感知到list底层是带头的链表，无法感知到底层的节点存储着什么数据，其实在此就是一种隐形的封装。所以就算程序底层的一些是公有的，但是对应用户来说也是属于封闭的，就像是"黑箱"一样

在以上链表节点的结构体当中我们还实现了默认构造函数，这样就可以让之后每创建一个节点都能在定义之后自动初始化

实现了表示链表节点的结构体之后接下来就可以实现list类内的成员变量了

#include<iostream>
using namespace std;

namespace zhz
{

	template<class T>
	struct list_node
	{

		T date;
		list_node<T>* prev;
		list_node<T>* next;

		list_node(const T& x = T())
		:date(x)
		, prev(nullptr)
		, next(nullptr)
		{

		}

	};


	template<class T>
	class list
	{
		typedef list_node<T> Node;
    public:
        //成员函数......

	private:
		Node* head;
		size_t _size;

	};


}

在此list类的成员变量为两个；一个是list对象内的头节点head，另一个list对象内的有效节点数size

2. list模拟实现

在以上我们实现了程序文件的创建、list类内成员变量的实现，接下来就可以一一模拟实现list内的成员函数了

2.1 无参构造函数

在list的构造函数中我们先实现无参的构造函数其他的构造函数在实现了插入函数insert之后再实现，这样的原因是使用insert来插入就不需要我我们显示的开空间而是将这些工作交给inert函数来实现，这样其他的构造函数写起来就较为简洁

在list内无参的构造函数中由于list底层要实现的是带头双向循环链表，因此在无参构造时要创建一个头节点也就是哨兵位节点

在list.cpp内实现无参构造函数，代码如下所示：

template<class T>
class list
{
	typedef list_node<T> Node;

public:
	//成员函数......

	list()
	{
		EmptyInit();
	}


private:
	Node* head;
	size_t _size;

	void EmptyInit()
	{
		head = new Node();
		head->next = head;
		head->prev = head;
	}

};

2.2 size与empty

在此size和empty的函数实现较为简单，以下就直接实现代码

代码如下所示：

size_t size()const
{
	return _size;
}

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

2.3 ⭐迭代器

在模拟实现list当中我们需要重点学习的就是list内的迭代器该如何实现，前面说过，大家可将迭代器暂时理解成类似于指针，但是在list就不能这样认为了；这是由于list底层节点物理空间不一定是连续的，所以我们就不能简单认为迭代器就是指针，那么接下来就来分析list内的迭代器该如何实现

首先要来分析的是和之前实现string和vector的迭代器不同由于无法使用原生指针来实现迭代器，在之前我们了解了list的迭代器是属于双向迭代器，那么在之后list迭代器要能实现迭代器的++与--，这就使得要实现这两个运算符的重载函数。这时你可能会简单的认为直接在list类内实习运算符重载函数不就可以实现要求的了，但是在此就会存在两个非常严重的问题：
首先是在不同的容器实现迭代器就是为了在用户使用时屏蔽底层的细节，屏蔽不同容器底层结构上的差异，通过封装底层的差异与细节来给用户实现统一的访问方式，因此如果在list内实现迭代器就会使得在之后的list迭代器++或者--时就直接通用对对象++或者--就能实现操作，这种实现不就和我们实现迭代器的初衷违背了吗？

其次就是如果是将迭代器实现在list类内，当我们对一个对象进行++或者--之后，该对象内底层的指向头节点指针不就改变了吗？这就会造成之后无法找到头节点，这就会使得之后进行的操作会出现各种问题，要解决这个问题就需要在list类内再创建多个指向头节点的指针，但是这样的话要创建多少个呢，如果是多个迭代器同时遍历list对象那么存在创建的头节点指针数不够怎么办

通过以上的分析就可以得出在list要实现迭代器就不能将迭代器实现在list类内部，那么正确的解决方式是什么呢？

在此合理的方法是载创建一个类list_iterator去封装节点的指针，将list对象内节点的指针作为该类的成员变量，之后使用这个新的类来作为迭代器。在此封装了节点的指针之后就可以重载我们想要实现的*、++、--等的运算符。并且这种实现迭代器的方式就不会出现以上的问题

那么接下来就来实现实现list_iterator类

由于在list类以及之后用户在实现list的迭代器时都会调用list_iterator的内部成员，因此list_iterator也和list_node一样不做访问限定符的限制，在此也使用struct来定义类

以下就先来实现list_iterator内的构造函数

template<class T>
struct list_iterator
{
    //为了简化之后的代码，将以下的两个类型重命名
	typedef list_node<T> Node;
    typedef list_iterator<T> Self;


	list_iterator(Node* node)
		:_node(node)
	{

	}

    //节点指针
	Node* _node;
};

我们知道在链表的节点解引用时想要得到的是对应节点内的数据data，在此接下来就在list_iterator内重载*运算符

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

为了能实现对节点内的数据进行读和写，那么就下需要想以上一样将*运算符重载的函数返回值为该节点内数据的引用
接下来来实现迭代器中的++与--，在此由于list为双向迭代器因此我们要实现前置++与--、后置++与--

//前置++
Self& operator++()
{
	_node = _node->next;
	return *this;
}
//后置++
Self operator++(int)
{
	Self tmp(*this);
	_node = _node->next;
	return tmp;
}
//前置--
Self& operator--()
{
	_node = _node->prev;
	return *this;
}
//后置--
Self operator--(int)
{
	Self tmp(*this);
	_node = _node->prev;
	return tmp;
}

注：在此的后置++和后置--=要加一个形参int的原因在之前C++《类和对象》章节就讲解过，这是为了使得前置和后置函数构成函数重载，后置加一个参数便于区分
在迭代器的使用当中通常还会判断两个迭代器是否相等，那么接下来就来实现==与!=的运算符重载函数

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

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

接下来我们还要实现一个之前没有实现过的运算符->，要实现这个运算符是因为list对象的类型可以是自定义类型，那么当类型是自定义类型时以上实现的迭代器使用*得到的是整个自定义类型对象，那么如果我们要得到的是该自定义类型内的数据就需要再通过再一次解引用才能实现。

那么为了能一步实现以上的操作就来实现运算符->

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

注：在使用以上操作符时，当list对象为自定义类型时，要得到自定义类型对象内的数据正常应该是要迭代器->->自定义类型对象内的变量，但在此为了可读性就省略一个->，变成迭代器->自定义类型对象内的变量

以上我们就完成了list的普通迭代器，那么const迭代器该如何实现呢？

在此你会认为再创建一个const_list_iterator就可以实现const迭代器，只需要将该类内的部分函数的返回值修改就可以满足需求了。

以上这种方式也是可以满足要求的，但以上这样实现虽然能满足要求但是两个****const_list_iterator和list_iterator高度的相识，这样就会使得代码很冗余，那么该如何实现呢？

其实在原本的list_iterator类的模板参数再加两个就可以解决，这就不需要实现两个类了

实现代码如下所示：

注：在此类模板的第一个参数T表示list对象内存储的数据类型，第二个参数Ref表示的是T类型的引用，第三个参数Pre表示T类型的指针

template<class T, class Ref, class Ptr>
struct list_iterator
{
 //为了简化之后的代码，将以下的两个类型重命名
	typedef list_node<T> Node;
	typedef list_iterator<T, Ref, Ptr> Self;


	list_iterator(Node* node)
		:_node(node)
	{

	}
	Ref operator*()
	{
		return _node->date;
	}


	Ptr operator->()
	{
		return &_node->data;
	}

	Self& operator++()
	{
		_node = _node->next;
		return *this;
	}

	Self operator++(int)
	{
		Self tmp(*this);
		_node = _node->next;
		return tmp;
	}

	Self& operator--()
	{
		_node = _node->prev;
		return *this;
	}

	Self operator--(int)
	{
		Self tmp(*this);
		_node = _node->prev;
		return tmp;
	}
	bool operator!=(const Self& l)
	{
		return _node != l._node;
	}

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


	Node* _node;


};

这时list类实现的begin()和end()函数就如下所示：

template<class T>
class list
{
	typedef list_node<T> Node;
public:
//为了将保证的用户能使用list的迭代器需要将以上我们创建的迭代器类型进行重命名
	typedef list_iterator<T, T&, T*> iterator;
	typedef list_iterator<T, const T&, const T*> const_iterator;



public:
	
	list()
	{
		EmptyInit();
	}




	iterator begin()
	{
		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);

	}



private:
	Node* head;
	size_t _size;

	void EmptyInit()
	{
		head = new Node();
		head->next = head;
		head->prev = head;
	}

};

**注：前面说过，此处大家可将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，**只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

2.4 insert与erase

通过之前的学习我们知道list内实现了insert和erase来分别实现任意位置的插入和删除，并且要删除和插入的位置是通过相应的迭代器位置实现，接下来我们就来试着实现这两个函数的代码

先来实现insert函数的代码
在insert函数当中我们要实现的操作是在pos迭代器之前插入指定的值，要实现这个操作就需要先创建一个新的节点之后将指定的值存储到节点当中，之后改节点插入到pos迭代器指向的节点和pos迭代器指向的节点之前的节点中间。以上要实现操作就和之前我们数据结构中学习的双链表任意位置插入数据实现过程类型

实现代码如下所示：

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;
	cur->prev = newnode;
	newnode->prev = Prev;
	newnode->next = cur;
	++_size;
	return iterator(newnode);
}

接下来来实现erase函数的代码

在erase函数当中我们要实现的操作是将pos迭代器指向的节点删除，要实现这个操作就需要先将原来pos迭代器指向的节点之前的节点的next指针指向原来pos迭代器指向的节点之后的节点，将原来pos迭代器指向的节点之后的节点的prev指针指向原来pos迭代器指向的节点之前的节点，之后再将原pos迭代器指向的节点释放，最后返回新节点的迭代器。以上要实现操作就和之前我们数据结构中学习的双链表任意位置删除数据类似

实现代码如下所示：

iterator erase(iterator pos)
{
	Node* cur = pos._node;
	Node* Prev = cur->prev;
	Node* Next = cur->next;
	//Prev cur Next
	Prev->next = Next;
	Next->prev = Prev;
	delete cur;
	pos = Next;
	--_size;
	return iterator(pos);
}

2.5 push_back、push_front、pop_back、pop_front

实现了insert和erase之后要实现头尾插入与删除就简单了，在这些函数内部直接通过调用之前实现的insert和erase就能实现要求了

实现代码如下所示：

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


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


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


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

2.6 构造函数（含参）

在一开始我们实现了无参的构造函数，但仅仅这一个函数是无法满足我们的要求的，在此还要实现使用迭代器区间的构造、n个指向值构造、拷贝构造等构造函数。

由于在以上我们实现了插入函数，那么接下来实现构造函数就很简单了，在构造函数当中将数据插入到对象内就直接通过调用实现的插入函数就可以实现了

实现代码如下所示：

//拷贝构造
list(const list<T>& lt)
{
	EmptyInit();
	for (auto& i : lt)
	{
		push_back(i);
	}
}

//n个指定的值x构造
list(int n, const T& x)
{
	EmptyInit();
	for (int i = 0; i < n; i++)
	{
		push_back(x);
	}
}

//迭代器区间构造
template<class InputIterator>
list(InputIterator first, InputIterator fin)
{
	EmptyInit();
	while (first != fin)
	{
		push_back(*first);
		++first;
	}

}

2.7 析构函数

在list内由于成员变量是有资源的申请的，那么编译器自动生成的析构函数就无法满足要求，需要我们显示的写析构函数。在此在析构函数内要实现的是将链表的节点一一 释放（包括头节点）

在list.cpp内实现析构函数，代码如下所示：

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


		void clear()
		{
			auto s = begin();
			while (s != end())
			{
				s=erase(s);
			}
		}

2.8 swap

在此在list类当中实现一个函数，在list类外也要实现一个swap函数，这样就会在我们使用参数为两个list对象的swap不会调用到算法库内的swap函数，这和之前在vector章节实现两个swap的原因类型

实现代码如下所示：

//list类内的swap
void swap(list<T>& lt)
{
	std::swap(head, lt.head);
	std::swap(_size, lt._size);
}


//list类外的swap函数
template<class T>
void swap(list<T>& lt1, list<T>& lt2)
{
	lt1.swap(lt2);
}

2.9 赋值运算符重载

在此在模拟实现的list类内赋值运算符的重载函数我们可以直接借助swap来实现

实现代码如下所示：

list<T>& operator=(list<T> tmp)
{
	swap(tmp);
	return *this;
}

2.10 front和back

在list当中front和back函数是用于分别得到list对象当中链表第一个有效节点和尾节点

实现代码如下所示：

T& front()
{
	return head->next->date;
}

const T& front()const
{
	return head->next->date;
}
T& back()
{
	return head->prev->date;
}

const T& back()const
{
	return head->prev->date;
}

3.完整代码

#include<iostream>
using namespace std;

namespace zhz
{

	template<class T>
	struct list_node
	{

		T date;
		list_node<T>* prev;
		list_node<T>* next;

		list_node(const T& x = T())
		:date(x)
		, prev(nullptr)
		, next(nullptr)
		{

		}

	};

	template<class T, class Ref, class Ptr>
	struct list_iterator
	{
		typedef list_node<T> Node;
		typedef list_iterator<T, Ref, Ptr> Self;

	
		list_iterator(Node* node)
			:_node(node)
		{

		}
		Ref operator*()
		{
			return _node->date;
		}


		Ptr operator->()
		{
			return &_node->data;
		}

		Self& operator++()
		{
			_node = _node->next;
			return *this;
		}

		Self operator++(int)
		{
			Self tmp(*this);
			_node = _node->next;
			return tmp;
		}

		Self& operator--()
		{
			_node = _node->prev;
			return *this;
		}

		Self operator--(int)
		{
			Self tmp(*this);
			_node = _node->prev;
			return tmp;
		}
		bool operator!=(const Self& l)
		{
			return _node != l._node;
		}

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


		Node* _node;


	};



	template<class T>
	class list
	{
		typedef list_node<T> Node;
	public:
		typedef list_iterator<T, T&, T*> iterator;
		typedef list_iterator<T, const T&, const T*> const_iterator;




	public:
		

		list()
		{
			EmptyInit();
		}


		//拷贝构造
		list(const list<T>& lt)
		{
			EmptyInit();
			for (auto& i : lt)
			{
				push_back(i);
			}
		}

		//n个指定的值x构造
		list(int n, const T& x)
		{
			EmptyInit();
			for (int i = 0; i < n; i++)
			{
				push_back(x);
			}
		}

		//迭代器区间构造
		template<class InputIterator>
		list(InputIterator first, InputIterator fin)
		{
			EmptyInit();
			while (first != fin)
			{
				push_back(*first);
				++first;
			}

		}



		list<T>& operator=(list<T> tmp)
		{
			swap(tmp);
			return *this;
		}


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



		size_t size()const
		{
			return _size;
		}

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

		void clear()
		{
			auto s = begin();
			while (s != end())
			{
				s=erase(s);
			}
		}


		iterator begin()
		{
			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);

		}

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


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


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


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

		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;
			cur->prev = newnode;
			newnode->prev = Prev;
			newnode->next = cur;
			++_size;
			return iterator(newnode);
		}


		iterator erase(iterator pos)
		{
			Node* cur = pos._node;
			Node* Prev = cur->prev;
			Node* Next = cur->next;
			//Prev cur Next
			Prev->next = Next;
			Next->prev = Prev;
			delete cur;
			pos = Next;
			--_size;
			return iterator(pos);
		}

		void swap(list<T>& lt)
		{
			std::swap(head, lt.head);
			std::swap(_size, lt._size);
		}
	

		T& front()
		{
			return head->next->date;
		}

		const T& front()const
		{
			return head->next->date;
		}
		T& back()
		{
			return head->prev->date;
		}

		const T& back()const
		{
			return head->prev->date;
		}



	private:
		Node* head;
		size_t _size;

		void EmptyInit()
		{
			head = new Node();
			head->next = head;
			head->prev = head;
		}

	};


	template<class T>
	void swap(list<T>& lt1, list<T>& lt2)
	{
		lt1.swap(lt2);
	}

}

以上就是《list的模拟实现》章节的全部内容了，希望能得到你的点赞和收藏