【C++】List模拟实现

List模拟实现

1.1 创建结点

	template<class T>
	struct  ListNode
	{
		ListNode<T>* _next;//指向后一个节点
		ListNode<T>* _prev;//指向前一个节点
		T _data; // 存数据
    // 这里用匿名对象当缺省值
		ListNode(const T& data = T())
			:_next(nullptr)
			, _prev(nullptr)
			, _data(data)
		{}
	};

因为要频繁的调用ListNode里面的数据选择了struct ，struct具有公有性。 

	template<class T>
	class list
	{
		typedef ListNode<T> Node;
	private:
		Node* _head;
	};

1.2 实现遍历功能

在class list类中添加了构造以及插入函数 

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

当创建一个list对象首先发生构造，创建头结点，之后就是插入数据 

---

迭代器 

 在main函数中我们要这样使用迭代器，进行循环 

		list<int> lit;
		lit.push_back(1);
		lit.push_back(2);
		lit.push_back(3);
		lit.push_back(4);
		lit.push_back(5);
		list<int>::iterator it = lit.begin();
		// it.operator!=(lit.end());
		while (it != lit.end())
		{
			cout << *it << " ";
			++it;
		}

我们先创建一个对象lit，在这个对象中，我们在各个节点中push_back数据，在push_back内部我们使其各个分散的节点连接一起，最后定义了迭代器进行循环 

在循环的过程中，我们使用下面的迭代器可以吗？

typedef Node* iterator;

不能，因为每个节点是独立的空间地址，每个节点是不连续的，我们无法保证++来移动指针，使其下个地址就是下个节点的位置。 

那应该怎么办？

因为，我们要求这个迭代器++就能指向下一个节点位置，我们只能创建个类 

在这里我们创建一个类，来模拟自定义类型Node的指针，为其添加类似于内置类型的功能（++，--）最后封装成iterator

	template<class T>
	class ListIterator
	{
		typedef ListNode<T> Node;
        typedef ListIterator<T> Self;
	public:
		ListIterator(Node* node)
			:_node(node)
		{}
		// ++it
		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
		bool operator!=(const Self& it)
		{
			return _node != it._node;
		}
		T& operator*()
		{
			return _node->_data;
		}
		T* operator->()
		{
			return &_node->_data;
		}
	private:
		Node* _node;
	};

 循环遍历首先要++，移动指针的位置，使其指向下一个节点

在上面的main函数中

list<int>::iterator it = lit.begin();

it接受第一个节点的地址后

之后进行++it<------>it.operator(第一个节点地址)

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

 把一个节点地址修改为下一个节点的地址进行返回

循环遍历的循环条件是

it != lit.end()

迭代器的区间一般又是左闭右开

所以iterator end返回的是头节点

指向的位置

什么意思呢？就是指向的位置是左闭右开

 之后就是访问里面的数据

 如果_data里面存储的是内置类型可以直接解引用使用operator*

如果_data里面存储的是自定义类型这样就要使用operator->去访问里面的数据（若是自定义类型不是一定要用operator->去访问）

	struct Pos
	{
		int _row;
		int _col;
 
		Pos(int row = 0,int col = 0)
			:_row(row)
			,_col(col)
		{}
	};

 例如我们自定义一个这样的类型

我们push_back存储数据，该如何遍历里面的数据呢？

		list<Pos> lt1;
		lt1.push_back(Pos(100, 100));
		lt1.push_back(Pos(200, 200));
		lt1.push_back(Pos(300, 300));

cout << it.operator->()->_col << ":" << it.operator->()->_row << endl;

我们可以向上面一样访问

operator->返回的是匿名对象存数据的地址，之后再访问Pos类里面的内容（只是调用了一次operator->）

系统默认优化这样写也行

cout << it->_col << ":" << it->_row << endl;

上面的代码可以这么理解，迭代器就是一个指针，指针访问数据

也可以这么写

cout << (*it)._col << ":" << (*it)._row << endl;

我们这里operator*采用的是引用返回，方便修改数据

operator->采用的是T*返回，也能修改数据。

如果不想修改数据，又该如何操作 

const 迭代器 

假如是一个const list我们又该如何遍历链表

	void Func(const list<int>& lt)
	{
		list<int>::iterator it = lt.begin();
		while (it != lt.end())
		{
			// *it += 10;
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}

 首先const的list需要一个const迭代器

 这个const迭代器的功能是 *it内容的数据不能修改，it可以++

直接在iterator前面+const是不可以的，因为it不能进行++了

 如何操作？再设计一个const迭代器的类

首先，要明白如何控制*it的内容不被修改------->就是迭代器中的返回的数据不能修改

也就是控制T&与 T*的返回类型，在他们前面都加上const

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

之后再list类中补充一下const list有关迭代器返回函数

		typedef ListConstIterator<T> const_iterator;//const迭代器类
        const_iterator begin() const
		{
			return const_iterator(_head->_next);
		}
		const_iterator end() const
		{
			return const_iterator(_head);
		}

 我们发现，虽然我们实现了const list的遍历，但是代码过于繁琐

 我们通过模板让编译器控制返回的类型这样可以减少代码的繁琐，

于是分别定义了两个模板在list类中，通过调用不同的名称来控制某个模板

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

迭代器的模板，接受的类型一个是T一个是Ref一个是Ptr,若是使用的iterator,迭代器模板所接受的就是T，T&，T*，若是使用的是const_iterator，迭代器模板所接受的就是T,const T&,const T*

	template<class T,class Ref,class Ptr>
	struct ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T, Ref, Ptr> Self;
		Node* _node;
		ListIterator(Node* node)
			:_node(node)
		{}
		Ref operator*()
		{
			return _node->_data;
		}
		Ptr operator->()
		{
			return &_node->_data;
		}
		bool operator!=(const Self& it)
		{
			return _node != it._node;
		}
		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
    };

最后把迭代器补充完整

后置++

// it++
Self& operator++(int)
{
	Self tmp(*this);
	_node = _node->_next;
	return tmp;
}

注意：这里实现的是浅拷贝，为什么这里不实现深拷贝？

我们这是需要指针，而不是所指向的内容，使用深拷贝太浪费空间

前置--，与后置-- 

		// --it
		Self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}
		// it--
		Self& operator--(int)
		{
			Self tmp(*this);
			_node = _node->_prev;
			return _node;
		}

operator== 

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

operator->

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

 insert

		iterator insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(x);
			Node* prev = cur->_prev;
 
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
 
			return iterator(newnode);
		}

 

insert这里没有迭代器失效，因为pos指向的位置没有改变

erase

		iterator erase(iterator pos)
		{
			assert(pos != end());
 
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;
 
			prev->_next = next;
			next->_prev = prev;
 
			delete cur;
 
			return iterator(next);
		}

这里迭代器失效了，因为pos的位置已经delete了，pos是野指针

 尾删，头插，尾删

		void pop_back()
		{
			erase(--end());
		}
 
		void push_front(const T& x)
		{
			insert(begin(), x);
		}
 
		void pop_front()
		{
			erase(begin());
		}

析构

		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}
		void clear()
		{
			auto it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

这里我们采用一个clear函数来清除节点的数据，因为清除每个节点后，it失效，erase指向下一个节点的位置，所以要重新赋值一下it，防止野指针

 拷贝构造

		void empty_init()
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;
		}
		list()
		{
			empty_init();
		}
		//lt2(lt1)
		list(const list<T>& lt)
		{
			empty_init();
			for (const auto& e : lt)
			{
				push_back(e);
			}
		}

我们这里创建一个empty_init用来初始化头结点，因为拷贝与拷贝构造都需要使用所以创建了一个函数，使其方便调用。在拷贝构造过程中，我们使用了for (const auto& e : lt)循环，为啥使用&？如果这里的T是string等其他自定义类型，会先构造生成一个临时变量，使其效率低下，所以要添加&

赋值拷贝

		list<T>& operator=(list<T> lt)
		{
			swap(_head, lt._head);
			return *this;
		}

 这里采用的是是现代写法。

 要是我想使用C++11中的这种初始化方式应该如何模拟？

		list<int> lit = {1,2,3,4};

 initializer_list<value_type> il

 

这个底层其实就是把{ }中的内容变成常量数组 

底层有2个指针，一个指向开始的位置，一个指向结束的地方 

 

		list(initializer_list<T> il)
		{
			empty_init();
			for (const auto& e : il)
			{
				push_back(e);
			}
		}

在mian函数中 初始化lit为1234之后传给形参il经过initializer_list类的实现，已经成为一个il为1234的常量数组了，之后把il中的数据插入到list链表中