C++实现STL_List

今天用c++实现一个简易版的List。

首先定义链表的结点：

	template <class T>
	struct List_Node
	{
		T _data;
		List_Node<T>* _next;
		List_Node<T>* _prev;

		List_Node(const T& x = T())
			: _data(x)
			, _next(nullptr)
			, _prev(nullptr)
		{}
	};

链表节点包含前驱指针和后驱指针，同时把构造函数写好，构造函数只需要为节点中的数据成员赋值，并将前驱节点和后驱节点置成空即可。这样一个节点的草图就完成了。

接下来实现List类，List类主要是完成对节点的操作，比如说链接前后节点，给链表插入数据，控制迭代器等等，List的数据成员设计成一个指向节点的指针，和STL保持一致。我们这里实现的链表是带哨兵位的双向循环链表，所以构造函数需要创建一个哨兵位节点，让

class List
	{
		typedef List_Node<T> Node;
    public:
        List()
		{
			_head = new Node; //创建一个新结点作为哨兵位
			_head->_next = _head;
			_head->_prev = _head;
		}
	private:
		Node* _head;
    }

这时候的链表还只是一个空架子，只有一个哨兵位，其他啥都没有，我们想插入数据，就实现一个简单的尾插函数。

		void push_back(const T& x)
		{
			Node* tail = _head->_prev;
			Node* newnode = new Node(x);
			tail->_next = newnode;
			newnode->_next = _head;
			newnode->_prev = tail;
			_head->_prev = newnode;
		}

为了方便测试，我在类中写了一个print函数，用来打印我们的链表

尾插函数的测试：

void test1()
{
	zy_List::List<int> s1;
	s1.push_back(1);
	s1.push_back(2);
	s1.push_back(3);
	s1.push_back(4);
	s1.push_back(5);
	s1.push_back(6);
	s1.print();
}

结果：

通过这里我们发现，我想打印链表还得自己在类里面写个函数，不然还访问不了，这怎么能行？于是乎我们就得自己写一写迭代器了。

List不同于vector，List的空间是不连续的，所以我们不可能用原生指针来控制链表。但是我们可以利用C++的特性让迭代器用起来和指针一摸一样。

翻看stl_list的源码不难发现，iterator(迭代器)是单独的一个类，其中存放着一个指向节点的指针

 那么我们也模仿stl来实现一个自己的iterator类，这时候要思考的问题是iterator要实现什么功能？

 最基本的肯定是获取节点数据以及遍历功能，我们先看我们是如何使用库中的List的

	List<int> s1;
    s1.push_back(1);
	s1.push_back(2);
	s1.push_back(3);
	s1.push_back(4);
	s1.push_back(5);
	s1.push_back(6);
    auto it = s1.begin();
	while (it != s1.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

获取节点数据需要的是解引用 * ，而遍历需要判断是否遍历到end位置以及++(让迭代器往后走)，以及begin(开始位置的迭代器),end(最后一个元素的下一个节点位置)和判断迭代器相等，这些符号可以用操作符重载来实现。

template <class T>
struct my_iterator
	{
        typedef my_iterator<T> iterator;
		typedef List_Node<T> Node;
	    bool operator==(const iterator& it) const
		{
			return _node == it._node;
		}

		bool operator!=(const iterator& it) const
		{
			return _node != it._node;
		}

        iterator& operator++ ()
		{
			this->_node = _node->_next;
			return *this;
		}

		iterator& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

	private:
		Node* _node;
	};

在List类中添加begin和end函数(end是最后一个元素的下一个位置)

		iterator begin()
		{
			return iterator(_head->_next);
		}
		iterator end()
		{
			return iterator(_head);
		}

这样一个简易的iterator架子就搭好啦，可以遍历链表并且读写数据。

测试：

void test1()
{
	zy_List::List<int> s1;
	s1.push_back(1);
	s1.push_back(2);
	s1.push_back(3);
	s1.push_back(4);
	s1.push_back(5);
	s1.push_back(6);
	
	auto it = s1.begin();
	while (it != s1.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

结果: 

 这里有一个问题，如果我们想用const_iterator（常迭代器）怎么办?  直接把iterator的返回值改成const吗？但是返回值不同是不构成重载的啊，那怎么办呢？

这时候我们可以通过模板实例化来解决这个问题，即iterator和const_iterator使用不同的模板参数，当调用不同的iterator的时候my_iterator会实例化成不同的类型，也就会返回不同的值，emm讲的有点抽象，结合代码一起说吧

		typedef my_iterator<T, T&, T*> iterator;
		typedef my_iterator<T, const T&, const T*> const_iterator;

如果我们调用iterator，那么my_iterator的模板参数就是<T, T&, T*>, 用const_iterator则是<T, const T&, const T*>, 如果用第二个模板参数作为返回值，那么调用iterator就返回T&,调用const_iterator就返回const T&，这样就达到了泛型化的目的。

完整代码：

#include <iostream>
#pragma once


using namespace std;

namespace zy_List
{
	template <class T>
	struct List_Node
	{
		T _data;
		List_Node<T>* _next;
		List_Node<T>* _prev;

		List_Node(const T& x = T())
			: _data(x)
			, _next(nullptr)
			, _prev(nullptr)
		{}
	};

	//定义一个iterator
	template <class T, class ref, class Ptr>
	struct my_iterator
	{
		typedef List_Node<T> Node;
		typedef my_iterator<T> iterator;

		//typedef my_iterator<T, ref, Ptr> iterator;
	

		my_iterator(Node* node)
			: _node(node)
		{}

		bool operator==(const iterator& it) const
		{
			return _node == it._node;
		}

		bool operator!=(const iterator& it) const
		{
			return _node != it._node;
		}

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

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

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

		iterator& operator++ ()
		{
			this->_node = _node->_next;
			return *this;
		}

		iterator& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

	private:
		Node* _node;
	};

	template <class T>
	class List
	{
		typedef List_Node<T> Node;
	public:
		typedef my_iterator<T, T&, T*> iterator;
		typedef my_iterator<T, const T&, const T*> const_iterator;

		iterator begin()
		{
			return iterator(_head->_next);
		}
		iterator end()
		{
			return iterator(_head);
		}

		List()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
		}

		void push_back(const T& x)
		{
			Node* tail = _head->_prev;
			Node* newnode = new Node(x);
			tail->_next = newnode;
			newnode->_next = _head;
			newnode->_prev = tail;
			_head->_prev = newnode;
		}

	private:
		Node* _head;
	};

}