list 简化版模拟实现

 1ListNode

template<class T>
	struct ListNode
	{
	public:
		ListNode(const T& x = T())
			:_next(nullptr)
			, _prev(nullptr)
			, _data(x)
		{}
		//private:
			//共有可访问
		ListNode<T>* _next;
		ListNode<T>* _prev;
		T _data;
	};

 实现iterator对Node*的封装  实现运算符重载

 

void const_print(const MyList::list<int>& lt)//这里的const本意是lt的node中的data不可改，却使lt不可改
//const迭代器是指， it已经封装过，把it当作指向node中的data的指针    it内的_node 的
{
	MyList::list<int>::const_iterator it = lt.begin();//所以应该是 通过函数重载，返回一个迭代器，不能支持对（*it）的改动
	while (it != lt.end())
	{
		//报错，必须是可修改的左值  *it += 19;
		//*it += 19;
		cout << (*it) << ' ';
		it++;
	}
	cout << endl;
}

 2ListIterator

template<class T, class Ref, class Ptr>
	class ListIterator
	{
	public:
		typedef ListNode<T> Node;
		typedef ListIterator<T, Ref, Ptr> Self;//变化
		ListIterator(Node* node)
			:_node(node)
		{}
		Ref operator*()//变化
		{
			return _node->_data;
		}
		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!=(Self it)
		{
			return _node != it._node;
		}
		//private:   共有
		Node* _node;
	};

 3list

template<class T>
	class list
	{
	public:
		typedef ListNode<T> Node;
		//typedef ListIterator<T> iterator;
		//typedef ListConstIterator<T> const_iterator;//但这样要实现两个类 可以合并

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

		iterator begin()//头是head下一个节点
		{
			return _head->_next;//单参数的自定义类型支持隐式类型转化  c++11对于多参数的也可以{xx,xx,xx}
		}
		iterator end()//尾是head
		{
			return _head;
		}
		const_iterator begin()const//直接加const 对于const对象能调用，然后刚好构成函数重载，
		{
			return _head->_next;//返回值也不能是 const itertor 这指的是it不能改，应该封装成（*it）不可改
		}
		const_iterator end()const
		{
			return _head;
		}
		void empty_init()
		{
			//先new一个节点
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
		}
		list(initializer_list<T>il)
		{
			empty_init();
			for (auto& e : il)
				push_back(e);
		}
		list()
		{
			empty_init();
		}
		list(const list<T>& lt)
		{
			empty_init();
			for (auto& i : lt)//要引用 有可能是自定义类型
			{
				push_back(i);
			}
		}
		/*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;
		}*/
		void push_back(const T& x)
		{
			insert(end(), x);
		}
		void push_front(const T& x)
		{
			insert(begin(), x);
		}
		void pop_back()
		{
			erase(--end());//不能是-1，没有重载
		}
		void pop_front()
		{
			erase(begin());
		}
		void insert(iterator pos, T val)
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* newnode = new Node(val);

			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
		}
		iterator erase(iterator pos)//迭代器失效  返回next
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;

			prev->_next = next;
			next->_prev = prev;

			delete cur;//
			return iterator(next);
		}
		size_t size()
		{
			size_t sz = 0;
			for (auto i : (*this))
				sz++;
			return sz;
		}
		bool empty()
		{
			return size() == 0;
		}
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}
		~list()
		{
			clear();
			delete _head;
		}
	private:
		Node* _head;
	};

 4对于const迭代器的解释和->操作符重载

struct A
{
	int _a1;
	int _a2;
	A(int a1 = 0, int a2 = 0)
		:_a1(a1)
		, _a2(a2)
	{}
};
void const_print(const MyList::list<int>& lt)//这里的const本意是lt的node中的data不可改，却使lt不可改（
//const迭代器是指， it已经封装过，把it当作指向node中的data的指针    
{
	MyList::list<int>::const_iterator it = lt.begin();//所以应该是 通过函数重载，返回一个迭代器，不能支持对（*it）的改动
	while (it != lt.end())
	{
		//报错，必须是可修改的左值  *it += 19;
		//*it += 19;
		cout << (*it) << ' ';
		it++;
	}
	cout << endl;
}
void print(MyList::list<int>& lt)
{
	MyList::list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		*it += 19;
		cout << (*it) << ' ';
		it++;
	}
	cout << endl;
}
void test2()
{
	MyList::list<A>lt;
	lt.push_back({ 1,2 });//隐式类型转换，c++11
	lt.push_back({ 1,2 });
	lt.push_back({ 1,2 });
	MyList::list<A>::iterator it = lt.begin();
	while (it != lt.end())
	{
		//报错cout << (*it) << " ";//(*it)访问的是 节点的数据 对于int 数据就是int 支持流输出 ，这里是A对象
		//其实就是把it当作 指向A的指针，但本质不是    （*it)就是A  
		//就是（*it）经过封装，（*it)就是A  ，，但it->没封装
		//cout << (*it)._a1 << "." << (*it)._a2<<endl;//但本应该it->data  要支持->重载  返回值是_data *
		cout << it->_a1 << "." << it->_a2 << endl;
		it++;
	}
	cout << endl;
}