Flutter 学习 一部分注意点记录

目录

前言

一.deque的常用接口

二.deque的原理

2.1 vector与list的优缺点

2.2 deque的原理

三.反向迭代器

四.全部代码

前言

一.deque的常用接口

二.deque的原理

2.1 vector与list的优缺点

最后发现，二者可以说是互补的表现

2.2 deque的原理

三.反向迭代器

四.全部代码

//ReverseIterator.h

#pragma once
template<class Iterator, class Ref, class Ptr>
struct ReverseIterator
{
	typedef ReverseIterator<Iterator, Ref,Ptr> Self;

	Iterator cur;//创建正向迭代器类对象

	ReverseIterator(Iterator it)//通过正向迭代器对象构造并初始化对象
		:cur(it)
	{}

	Self& operator++()
	{
		--cur;//调用正向迭代器的--接口
		return *this;
	}

	Self& operator--()
	{
		++cur;//调用正向迭代器的++接口
		return *this;
	}

	Ref operator*()
	{
		Iterator tmp = cur;//因为反向迭代器对称的特性，后面需要前置--，而解引用不需要迭代器移动，所有用临时对象来搞
		--tmp;
		return *tmp;
	}
	Ptr operator->()
	{
		return &(operator*());//->实际上是两个，这里只需要返回解引用后的地址即可 例如*返回AA，那么&AA就是AA*了

	}

	bool operator!=(const Self& s)
	{
		return cur != s.cur;
	}
};

//list.h
#pragma once
#include <assert.h>
#include"ReverseIterator.h"
namespace lj
{
	template <class T>
	struct ListNode
	{
		ListNode<T>* _next;
		ListNode<T>* _prev;

		T _Data;
		
		//构造初始化 利用匿名对象调用该类型的构造函数
		ListNode<T>(const T& x = T())
		{
			_next = nullptr;
			_prev = nullptr;
			_Data = x;
		}
	};
	template <class T,class Ref,class Ptr>
	struct _list_iterator
	{
		typedef ListNode<T> Node;
		typedef _list_iterator<T,Ref,Ptr> self;

		Node* _node;
		//构造函数
		_list_iterator(Node* node)
		{
			_node = node;
		}
		//前置++
		self& operator++()
		{
			//不再是单纯的自加1，而是指向下一位置
			_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;
		}
		//解引用
		Ref operator*()
		{
			return _node->_Data;
		}
		//指针与指针的对比！=
		bool operator!=(const self& x)
		{
			return _node != x._node;
		}
		//指针与指针的对比==
		bool operator==(const self& x)
		{
			return _node == x._node;
		}
		Ptr operator->()
		{
			return &_node->_data;
		}

		

	};
	template <class T>
	class list
	{
		typedef ListNode<T> Node;
		
	public:
		typedef _list_iterator<T,T&,T*> iterator;
		typedef _list_iterator<T,const T&,T*> const_iterator;
		typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
		typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;


		reverse_iterator rbegin()
		{
			return reverse_iterator(end());//把正向迭代器传输过去
		}

		reverse_iterator rend()
		{
			return reverse_iterator(begin());//把正向迭代器传输过去
		}
		//构造函数
		list()
		{
			init();
		}
		void init()
		{
			_head = new Node;//创建带头节点
			_head->_next = _head;//构成双向循序
			_head->_prev = _head;
		}
		//尾插
		void push_back(const T& x)
		{
			insert(end(), x);
			先创建新节点
			//Node* newnode = new Node(x);
			先找到尾节点
			//Node* tail = _head->_prev;
			开始链接
			//tail->_next = newnode;
			//newnode->_prev = tail;
			//newnode->_next = _head;
			//_head->_prev = newnode;
		}
		//指向第一个有效节点
		iterator begin()
		{	//单参数隐式类型转换
			//return iterator(_head->_next);
			return _head->_next;
		}
		const_iterator begin()const
		{	//单参数隐式类型转换
			//return iterator(_head->_next);
			return _head->_next;
		}
		//指向头节点：哨兵位
		iterator end()
		{
			//return iterator(_head);
			return _head;
		}
		//指向头节点：哨兵位
		const_iterator end()const
		{
			//return iterator(_head);
			return _head;
		}
		//插入
		iterator insert(iterator pos,const T& x)
		{
			//创建插入节点
			Node* newnode = new Node(x);
			//记录插入位置
			Node* node = pos._node;
			Node* nodeprev = node->_prev;
			nodeprev->_next = newnode;
			newnode->_prev = nodeprev;
			newnode->_next = node;
			node->_prev = newnode;

			//return iterator(newnode);
			return newnode;

		}
		//头插
		void push_front(const T& x)
		{
			insert(begin(), x);
		}
		//erase 删除
		iterator erase(iterator pos)
		{
			//记录位置
			Node* node = pos._node;
			Node* nodenext = node->_next;
			Node* nodeprev = node->_prev;
			//开始链接
			nodeprev->_next = nodenext;
			nodenext->_prev = nodeprev;

			delete node;
			return nodenext;
		}
		//pop_back 尾删
		void pop_back()
		{
			erase(--end());
		}
		//pop_front 头删
		void pop_front()
		{
			erase(begin());
		}

		//clear 清理
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
				//erase(it);
			}
		}
		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}
		//list l2(l1) 拷贝构造
		list(list<T>& lt)
		{
			init();
			for (const auto& e : lt)
			{
				push_back(e);
			}
		}

		//赋值拷贝 传统写法
		/*list<T>& operator=(list<T>& lt)
		{
			if (*this != lt)
			{
				clear();
				for (const auto& e : lt)
				{
					push_back(e);
				}
			}
			return *this;
		}*/
		void swap(list<T>& tmp)
		{
			std::swap(_head, tmp._head);
		}
		//赋值拷贝 现代写法
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

		

		

	private:
		Node* _head;//带头节点：哨兵位
	};

	
		
	void test2()
	{
		lj::list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);

		lj::list<int>::reverse_iterator rit = lt.rbegin();
		while (rit != lt.rend())
		{
			cout << *rit << " ";
			++rit;
		}
		cout << endl;

		
	}
}

//vector.h
#pragma once

#include <assert.h>
#include"ReverseIterator.h"

namespace lj
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
		typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
		typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;


		//迭代器构造
		template <class Inputiterator>
		vector(Inputiterator first, Inputiterator last)
		{
			while (first != last)
			{
				push_back(*first);
				first++;
			}
		}
		reverse_iterator rbegin()
		{
			return reverse_iterator(end());//把正向迭代器传输过去
		}

		reverse_iterator rend()
		{
			return reverse_iterator(begin());//把正向迭代器传输过去
		}

		//构造函数
		vector()
		{
			_start = nullptr;
			_finish = nullptr;
			_endofstorage = nullptr;
		}
		//拷贝构造 现代写法 v2(v1)
		vector(const vector<T>& v)
		{
			reserve(v.capacity());
			for (auto e : v)
			{
				push_back(e);
			}

		}

		T& operator[](size_t pos)
		{
			assert(pos < size());

			return _start[pos];
		}
		void swap(vector<T>& v)
		{
			std::swap(_start,v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}
		vector<T>& operator=(vector<T> v)
		{
			swap(v);
			return *this;
		}
		//析构函数
		~vector()
		{
			if(_start)
			delete[] _start;
			_start = nullptr;
			_finish = nullptr;
			_endofstorage = nullptr;
		}
		size_t capacity()const
		{
			return _endofstorage - _start;
		}

		size_t size()const
		{
			return _finish - _start;
		}

		iterator begin()
		{
			return _start;
		}

		const_iterator begin()const
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator end()const
		{
			return _finish;
		}

	

		void reserve(size_t n)
		{
			if (n>capacity())
			{
				size_t old = size();//记录原空间的大小
				T* tmp = new T[n];//开辟新空间——异地扩容
				if (_start)
				{
					for (size_t i = 0; i < old; i++)
					{
						tmp[i] = _start[i];//赋值拷贝为深拷贝
					}
					delete[] _start;//释放原空间
				}
				_start = tmp;//指向新空间
				_finish = _start + old;
				_endofstorage = _start + n;
			}

		}
		//尾插函数
		void push_back(const T& x)
		{
			//检查扩容
			if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = x;
			_finish++;
		}
		//插入函数
		iterator insert(iterator pos, const T& x)
		{
			assert(pos <= _finish && pos >= _start);
			//检查扩容
			if (_finish == _endofstorage)
			{
				size_t len = pos - _start;//记录原空间长度
				reserve(capacity() == 0 ? 4 : capacity() * 2);
				pos = len + _start;//让pos指向新空间并且同步长度
			}
			//开始利用函数插入,往后挪动数据
			//memmove(pos + 1, pos, (_finish - pos) * sizeof(T));
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = x;
			_finish++;
			return pos;
		}
		//resize 扩容初始化   
		void resize(size_t n, const T& val = T())
		{
			if (n > size())
			{
				reserve(n);//扩容
				while (_finish < _start + n)
				{
					*_finish = val;
					_finish++;
				}
			}
			else
			{
				_finish = _start + n;
			}
		}

		//erase 删除
		iterator erase(iterator pos)
		{
			assert(pos <= _finish && pos >= _start);
			iterator it = pos + 1;
			while (it<_finish)
			{
				*(it-1) = *it;
				it++;
			}
			_finish--;
			return pos;
		}
		

		

	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _endofstorage = nullptr;
	
	};
	void test_vector()
	{

		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);

		lj::vector<int>::reverse_iterator rit = v.rbegin();
		while (rit != v.rend())
		{
			cout << *rit << " ";
			++rit;
		}
		cout << endl;
	}
}

//test.cpp
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<list>
#include<vector>
using namespace std;

#include"List.h"
#include"vector.h"


int main()
{
	//lj::test2();
	lj::test_vector();
	return 0;
	/*lj::list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);

	lj::list<int>::reverse_iterator rit = lt.rbegin();
	while (rit != lt.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;

	return 0;*/
}