C++——list容器模拟实现

目录

1. list三个基本函数类

2. 节点类接口实现

2.1 基本框架

2.2 构造函数

3. 迭代器类接口

3.1 正向迭代器

3.1.1 基本框架

3.1.2 默认构造函数

3.1.3 构造函数

3.1.4 *运算符重载

3.1.5 ->运算符重载

3.1.6 ++运算符号重载

3.1.7 --运算符重载

3.1.8 ！=运算符重载

3.1.9 ==运算符重载

3.2 反向迭代器

4 list类核心接口实现

4.1 基本框架

4.2 默认成员函数

4.2.1 构造函数

4.2.2 析构函数

4.2.3 拷贝构造函数

4.2.4 赋值运算符重载函数

4.3 迭代器相关函数

4.3.1 begin和end

4.3.2 rbegin和rend

4.4 增加相关函数

4.4.1 insert

4.4.2 push_back

4.4.3 push_front

4.5 删除相关函数

4.5.1 erase

4.5.2 pop_back

4.5.3 pop_front

4.6 其它函数

4.6.1 clear

4.6.2 empty_init空初始化

4.6.3 swap

1. list三个基本函数类

C++中的list其实就是一个带头双向循环链表。

现在要模拟实现list，要实现下列三个类：

1. 模拟实现结点类
2. 模拟实现迭代器的类
3. 模拟list主要功能的类

这三个类的实现层层递进，比如整个核心list类模拟实现其基本功能（增加删除……）要建立在迭代器类和结点类均已实现好的情况下才得以完成。

2. 节点类接口实现

因为list的本质为带头双向循环链表，所以其每个结点要确保有下列成员：

1. 前驱指针
2. 后继指针
3. data值存放数据

而结点类的内部只需要实现一个构造函数即可。

2.1 基本框架

//1、结点类的模拟实现
template
struct list_node//因为成员函数都是公有，就不设计成class了，直接struct
{
	list_node* _next;//后继指针
	list_node* _prev;//前驱指针
	T _data;//记录数据
};

2.2 构造函数

//构造函数
list_node(const T& val = T())//给一个缺省值T()
	:_next(nullptr)
	, _prev(nullptr)
	, _data(val)
{}

3. 迭代器类接口

这里强调下，因为list的特殊性，其本质是带头双向循环链表，对于链表，我们已然得知其内存空间是不连续的，是通过结点的指针顺次链接，我们不能像先前的string和vector一样直接解引用去访问其数据，结点的指针解引用还是结点，结点指针++还是结点指针，归根结底在于list物理空间不连续。而string和vector的物理空间是连续的，所以这俩不需要实现迭代器类，可以直接使用。

为了能让list像vector一样去解引用，++访问到下一个数据，我们需要单独写一个迭代器类的接口实现，在其内部进行封装补齐相应的功能，而这就要借助运算符重载来完成。

注意：迭代器又分为正向迭代器和反向迭代器。

3.1 正向迭代器

3.1.1 基本框架

//模拟实现迭代器类
template
struct __list_iterator//因为成员函数都是公有，就不设计成class了，直接struct
{
	typedef list_node Node;
	typedef __list_iterator self;//只要用自己的类型，就对其typedef成self，方便后续使用
	Node* _node;
};

• 注意：

这里迭代器类的模板参数里面包含了3个参数：template

而后文list类的模拟实现中，我对迭代器进行了两种typedef：

typedef __list_iterator iterator;//普通迭代器
typedef __list_iterator const_iterator;//const迭代器

根据这里的对应关系：Ref对应的是&引用类型，Ptr对应的是*指针类型，这里如果我是普通对象传过来的迭代器，生成对应的普通迭代器，如果是const对象传递过来的迭代器，会生成对应的const迭代器。

这样做的原因在于避免单独写一个支持不能修改迭代器指向结点数据的类而造成的复用性差。

3.1.2 默认构造函数

这里的默认成员函数我们只需要写构造函数。

• 析构函数 -- 结点不属于迭代器，不需要迭代器释放
• 拷贝构造 -- 默认浅拷贝即可
• 赋值重载 -- 默认浅拷贝即可

3.1.3 构造函数

这里我们通过结点的指针即可完成构造。通过结点指针构造一个迭代器。

//构造函数
__list_iterator(Node* node)//通过结点指针构造一个迭代器
	:_node(node)
{}

3.1.4 *运算符重载

*解引用的目的是为了获取结点里的_data数据，因此我们直接return返回结点指向的_data即可。

//*运算符重载
Ref operator*()//结点出了作用域还在，用引用返回
{
	return _node->_data;//返回结点指向的数据
}

3.1.5 ->运算符重载

假设出现这样的场景，我链表存储的不是内置类型，而是自定义类型，如下：

struct AA
{
	AA(int a1 = 0, int a2 = 0)
		:_a1(a1)
		, _a2(a2)
	{}
	int _a1;
	int _a2;
};
void test()
{
	cpp::list lt;
	lt.push_back(AA(1, 1));
	lt.push_back(AA(2, 2));
	lt.push_back(AA(3, 3));
	lt.push_back(AA(4, 4));
}

对于内置类型和自定义类型成员的指针，其访问方式都是不同的：

int*  *it
AA*   (*it). 或者 it->

而这里我们应该重载一个->运算符。以便于访问自定义类型成员的指针的数据。

//->运算符重载
Ptr operator->()
{
    return &(operator*());//返回结点指针所指结点的数据的地址
    //或者return &_node->_data;
}

实现了->运算符重载后，我们执行it->_a1，编译器将其转换成it.operator->()，此时获得的是结点位置的地址即AA*，而理应还有一个箭头->才能获取数据，也就是这样：it.operator->()->_a1

总结：编译器为了可读性进行优化处理，如果不优化应该是it->->_a1，优化以后，省略了一个箭头->。

3.1.6 ++运算符号重载

++运算符分为前置++和后置++

• 前置++

迭代器++的返回值还是迭代器，这里的++是为了让结点指向下一个结点的指针，注意前置++是要返回自增后的结点指针。

//前置++
self& operator++()//迭代器++的返回值还是迭代器
{
	_node = _node->_next;//直接让自己指向下一个结点即可实现++
	return *this;//返回自增后的结点指针
}

• 后置++

为了区分前置++，后置++通常要加上一个参数以便区别。此外，后置++是返回自增前的结点指针。

//后置++
self operator++(int)//加参数以便于区分前置++
{
	self tmp(*this);//拷贝构造tmp
	_node = _node->_next;//直接让自己指向下一个结点即可实现++
	return tmp;//注意返回tmp，才是后置++
}

3.1.7 --运算符重载

--运算符也分前置--和后置--

• 前置--

前置--是让此结点指向上一个结点，最后返回自减后的结点指针即可。

//前置--
self& operator--()
{
	_node = _node->_prev;//让_node指向上一个结点即可实现--
	return *this;
}

• 后置--

注意传参以区分前置--，最后返回的是自减前的结点指针即可。

//后置--
self operator--(int)//记得传缺省值以区分前置--
{
	self tmp(*this);//拷贝构造tmp
	_node = _node->_prev;
	return tmp;
}

3.1.8 ！=运算符重载

这里比较是否不等，是两个迭代器的比较，直接返回两个结点的位置是否不同即可。

//!=运算符重载
bool operator!=(const self& it)
{
	return _node != it._node;//返回两个结点指针的位置是否不同即可
}

3.1.9 ==运算符重载

这里直接返回俩结点指针是否相同即可。

//==运算符重载
bool operator==(const self& it)
{
	return _node == it._node;//返回俩结点指针是否相同
}

3.2 反向迭代器

反向迭代器是一个适配器模式（后文会将适配器）。相较于正向迭代器，反向迭代器有下面三种主要变化：

• 反向迭代器的++执行的操作是正向迭代器里的--，
• 反向迭代器里的--执行的操作是正向迭代器里的++，
• 反向迭代器的*解引用和->操作指向的是前一个数据。

总代码如下：

namespace cpp
{
	template
	struct Reverse_iterator
	{
		Iterator _it;
		typedef Reverse_iterator Self;
		
		//构造函数
		Reverse_iterator(Iterator it)
			:_it(it)
		{}
		//*运算符重载
		Ref operator*()
		{
			Iterator tmp = _it;
			//返回上一个数据
			return *(--tmp);
		}
		//->运算符重载
		Ptr operator->()
		{
			//复用operator*，返回上一个数据
			return &(operator*());
		}
		//++运算符重载
		Self& operator++()
		{
			--_it;
			return *this;
		}
		//--运算符重载
		Self& operator--()
		{
			++_it;
			return *this;
		}
		//!=运算符重载
		bool operator!=(const Self& s)
		{
			return _it != s._it;//返回两个结点指针的位置是否不同即可
		}
		//==运算符重载
		bool operator==(const Self& s)
		{
			return _it == s._it;//返回俩结点指针是否相同
		}
	};
}

4 list类核心接口实现

4.1 基本框架

在list类中的唯一成员变量即自定义类型的变量，由先前的结点类构成的头结点：

/*3、模拟实现list的功能类*/
template
class list
{
	typedef list_node Node;	
public:
	//正向迭代器
	typedef __list_iterator iterator;//普通迭代器
	typedef __list_iterator const_iterator;//const迭代器
 
	//反向迭代器适配支持
	typedef Reverse_iteratorreverse_iterator;
	typedef Reverse_iterator const_reverse_iterator;//const反向迭代器
private:
	Node* _head;
};

4.2 默认成员函数

4.2.1 构造函数

• 无参构造：

此目的是为了对哨兵位的头结点_head进行初始化：

//构造函数
list()
{
	_head = new Node();//申请一个头结点
	_head->_next = _head;//头结点的下一个结点指向自己构成循环
	_head->_prev = _head;//头结点的上一个结点指向自己构成循环
}

• 传迭代器区间构造：

先初始化，再利用循环对迭代器区间的元素挨个尾插即可。

//传迭代器区间构造
template 
list(InputIterator first, InputIterator last)
{
	empty_init();
	while (first != last)
	{
		push_back(*first);
		first++;
	}
}

4.2.2 析构函数

这里可以先复用clear函数把除了头结点的所有结点给删除掉，最后delete头结点即可。

//析构函数
~list()
{
	clear();
	delete _head;//删去哨兵位头结点
	_head = nullptr;
}

4.2.3 拷贝构造函数

 假设要用lt1拷贝构造lt2。

• 传统写法：

首先复用empty_init对头结点进行初始化，接着遍历lt1的元素，在遍历的过程中尾插将lt1的元素尾插到lt2上即可。这里直接利用push_back自动开辟空间完成深拷贝。

//传统写法
list(const list& lt)
{
	//先初始化lt2
	empty_init();
	//遍历lt1，把lt1的元素push_back到lt2里头
	for (auto e : lt)
	{
		push_back(e);//自动开辟新空间，完成深拷贝
	}	
}

• 现代写法：

这里先初始化lt2自己，再把lt1引用传参传给lt，传lt的迭代器区间构造tmp，复用swap交换头结点指针即可完成深拷贝的现代写法。

//现代写法
list(const list& lt)
{
	//初始化自己
	empty_init();
	listtmp(lt.begin(), lt.end());//借用迭代器区间去构造tmp
	//交换头结点指针即可完成深拷贝现代写法
	swap(tmp);
}

4.2.4 赋值运算符重载函数

• 假设要把lt1赋值给lt2。

这里直接给出现代写法。注意这里传值传参把lt1传给lt自定义类型传值传参调用拷贝构造，拷贝构造完成的是深拷贝生成了lt，复用swap函数交换lt1与lt的头结点指针指向即可，最后返回*this。

//赋值运算符重载（现代写法）
list& operator=(list lt)//套用传值传参去拷贝构造完成深拷贝
{
	swap(lt);
	return *this;
}

4.3 迭代器相关函数

4.3.1 begin和end

• begin的作用是返回第一个位置的结点的迭代器，而第一个结点就是哨兵位头结点的下一个结点，因此，直接return返回_head的_next即可。
• end的作用就是返回最后一个有效数据的下一个位置的迭代器，而这里对于list指的就是头结点_head的位置。

begin和end均分为普通对象调用和const对象调用，因此要写两个版本。

• 普通对象调用版

//begin
iterator begin()//begin返回的就是第一个有效数据，即头结点的下一个结点
{
	return iterator(_head->_next);//构造了一个匿名对象，通过调用构造函数利用头结点指向的第一个结点作为参数，来返回头结点
	//return _head->_next;  也可以这样写
}
//end
iterator end()
{
	return iterator(_head);//end返回的是最后一个结点的下一个结点，就是头结点_head
	//return _head;  也可以这样写
}

• const对象调用版

//begin
const_iterator begin() const
{
	return const_iterator(_head->_next);
	//return _head->_next; 
}
//end
const_iterator end() const
{
	return const_iterator(_head);
	//return _head;  也可以这样写
}

4.3.2 rbegin和rend

rbegin就是正向迭代器里end()的位置，rend就是正向迭代器里begin()的位置。

• 普通对象调用：

//rbegin()
reverse_iterator rbegin()
{
	return reverse_iterator(end());
}
//rend
reverse_iterator rend()
{
	return reverse_iterator(begin());
}

• const对象调用：

//const反向迭代器
const_reverse_iterator rbegin() const
{
	return const_reverse_iterator(end());
}
const_reverse_iterator rend() const
{
	return const_reverse_iterator(begin());
}

4.4 增加相关函数

4.4.1 insert

实现insert首先创建一个新的结点存储插入的值，接着取出插入位置pos的结点为cur，记录cur的上一个结点位置prev，先链接prev和newnode，再链接newnode和cur即可。最后记得要返回新插入元素的迭代器位置。

//insert，插入pos位置之前
iterator insert(iterator pos, const T& x)
{
	Node* newnode = new Node(x);//创建新的结点
	Node* cur = pos._node; //迭代器pos处的结点指针
	Node* prev = cur->_prev;
	//prev newnode cur
	//链接prev和newnode
	prev->_next = newnode;
	newnode->_prev = prev;
	//链接newnode和cur
	newnode->_next = cur;
	cur->_prev = newnode;
	//返回新插入元素的迭代器位置
	return iterator(newnode);
}

• 补充：list的insert不存在野指针和意义变了的迭代器失效问题。

4.4.2 push_back

• 法一：

首先，创建一个新结点用来存储尾插的值，接着找到尾结点。将尾结点和新结点前后链接构成循环，再将头结点和新结点前后链接构成循环即可。

//尾插
void push_back(const T& x)
{
	Node* tail = _head->_prev;//找尾
	Node* newnode = new Node(x);//创建一个新的结点
	//_head  tail  newnode
	//使tail和newnode构成循环
	tail->_next = newnode;
	newnode->_prev = tail;
	//使newnode和头结点_head构成循环
	newnode->_next = _head;
	_head->_prev = newnode;
 
}

• 法二：

这里也可以复用insert函数，当insert中的pos位置为哨兵位头结点的位置时，实现的就是尾插，因为insert插入是在pos位置前插入，而pos位哨兵位头结点时，在其前一个位置（尾部）插入就是实现了尾插。

//尾插
void push_back(const T& x)
{
	//法二：复用insert
	insert(end(), x);
}

4.4.3 push_front

直接复用insert函数，当pos位置为begin()时，获得的pos就是第一个有效结点数据，即可满足头插。

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

4.5 删除相关函数

4.5.1 erase

erase删除的是pos位置的结点，首先取出pos位置的结点为cur，记录cur上一个结点的位置为prev，再记录cur下一个结点的位置为next，链接prev和next，最后delete释放cur的结点指针即可。最后记得返回删除元素后一个元素的迭代器位置。

//erase
iterator erase(iterator pos)
{
	assert(pos != end());
	Node* cur = pos._node;
	Node* prev = cur->_prev;
	Node* next = cur->_next;
	//prev cur next
	//链接prev和next
	prev->_next = next;
	next->_prev = prev;
	//delete要删去的结点
	delete cur;
	//返回删除元素后一个元素的迭代器位置
	//return next;
	return iterator(next);
}

4.5.2 pop_back

直接复用erase即可，当pos位置为--end()时，pos就是最后一个结点的位置，实现的就是尾删。

//尾删
void pop_back()
{
	erase(--end());
}

4.5.3 pop_front

直接复用erase即可，当pos位置为begin()时，pos就是第一个有效数据，实现的就是头删。

//头删
void pop_front()
{
	erase(begin());
}

4.6 其它函数

4.6.1 clear

clear的作用是清除除了头结点外的所有结点，这里可以复用erase并通过遍历的方式一个一个删除。

//clear清除
void clear()
{
	//复用erase
	iterator it = begin();
	while (it != end())
	{
		it = erase(it);//用it接收删除后的下一个结点的位置
	}
}

4.6.2 empty_init空初始化

此函数的作用把哨兵位的头结点开出来，再对齐初始化。该函数是库里的。

//空初始化  对头结点进行初始化
void empty_init()
{
	_head = new Node();
	_head->_next = _head;
	_head->_prev = _head;
}

4.6.3 swap

对于链表的swap，直接交换头结点指针的指向即可完成。直接复用库函数的swap即可。

//swap交换函数
void swap(list& lt)
{
	std::swap(_head, lt._head);//交换头指针
}

5 总代码

5.1 list.h

#pragma once
#include
#include
#include"Reverse_Iterator.h"
using namespace std;

namespace cpp
{
	/*1、模拟实现结点类*/
	template
	struct list_node//因为成员函数都是公有，就不设计成class了，直接struct
	{
		list_node* _next;//后继指针
		list_node* _prev;//前驱指针
		T _data;//记录数据
		//构造函数
		list_node(const T& val = T())//给一个缺省值T()
			:_next(nullptr)
			, _prev(nullptr)
			, _data(val)
		{}
	};

	/*2、模拟实现迭代器类*/
	template
	struct __list_iterator//因为成员函数都是公有，就不设计成class了，直接struct
	{
		typedef list_node Node;
		typedef __list_iterator self;//对其进行typedef，方便后续使用
		Node* _node;
		//基本成员函数
			//1、构造函数
		__list_iterator(Node* node)//通过结点指针构造一个迭代器
			:_node(node)
		{}
		/*
		  2、析构函数 -- 结点不属于迭代器，不需要迭代器释放
		  3、拷贝构造 -- 默认浅拷贝即可
		  4、赋值重载 -- 默认浅拷贝即可
		*/

		//*运算符重载
		Ref operator*()//结点出了作用域还在，用引用返回
		{
			return _node->_data;//返回结点指向的数据
		}
		*运算符重载
		//T& operator*()//结点出了作用域还在，用引用返回
		//{
		//	return _node->_data;//返回结点指向的数据
		//}
		//->运算符重载
		Ptr operator->()
		{
			return &(operator*());
		}
		->运算符重载
		//T* operator->()
		//{
		//	//return &(operator*());
		//	return &_node->_data;//返回结点指针所指结点的数据的地址
		//}

		//前置++
		self& operator++()//迭代器++的返回值还是迭代器
		{
			_node = _node->_next;//直接让自己指向下一个结点即可实现++
			return *this;//返回自增后的结点指针
		}
		//后置++
		self operator++(int)//加参数以便于区分前置++
		{
			self tmp(*this);//拷贝构造tmp
			_node = _node->_next;//直接让自己指向下一个结点即可实现++
			return tmp;//主要返回tmp，才是后置++
		}
		//前置--
		self& operator--()
		{
			_node = _node->_prev;//让_node指向上一个结点即可实现--
			return *this;
		}
		//后置--
		self operator--(int)//记得传缺省值以区分前置--
		{
			self tmp(*this);//拷贝构造tmp
			_node = _node->_prev;
			return tmp;
		}

		//!=运算符重载
		bool operator!=(const self& it)
		{
			return _node != it._node;//返回两个结点指针的位置是否不同即可
		}
		//==运算符重载
		bool operator==(const self& it)
		{
			return _node == it._node;//返回俩结点指针是否相同
		}

	};

	/*3、模拟实现list的功能类*/
	template
	class list
	{
		typedef list_node Node;
	public:
		//正向迭代器
		typedef __list_iterator iterator;//普通迭代器
		typedef __list_iterator const_iterator;//const迭代器

		//反向迭代器适配支持
		typedef Reverse_iterator reverse_iterator;
		typedef Reverse_iterator const_reverse_iterator;//const反向迭代器
		//默认成员函数
			//1、构造函数
		list()
		{
			_head = new Node();//申请一个头结点
			_head->_next = _head;//头结点的下一个结点指向自己构成循环
			_head->_prev = _head;//头结点的上一个结点指向自己构成循环
		}
		//传迭代器区间构造
		template 
		list(InputIterator first, InputIterator last)
		{
			empty_init();
			while (first != last)
			{
				push_back(*first);
				first++;
			}
		}
		//2、析构函数
		~list()
		{
			clear();
			delete _head;//删去哨兵位头结点
			_head = nullptr;
		}
		//3、拷贝构造函数 lt2(lt1)
		/*传统写法
		list(const list& lt)
		{
			//先初始化lt2
			empty_init();
			//遍历lt1，把lt1的元素push_back到lt2里头
			for (auto e : lt)
			{
				push_back(e);//自动开辟新空间，完成深拷贝
			}
		}
		*/
		//空初始化  对头结点进行初始化
		void empty_init()
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;
		}
		//swap交换函数
		void swap(list& lt)
		{
			std::swap(_head, lt._head);//交换头指针
		}

		/*现代写法*/
		list(const list& lt)
		{
			//初始化自己
			empty_init();
			listtmp(lt.begin(), lt.end());//借用迭代器区间去构造tmp
			//交换头结点指针即可完成深拷贝现代写法
			swap(tmp);
		}

		//4、赋值运算符重载（现代写法）
		list& operator=(list lt)//套用传值传参去拷贝构造完成深拷贝
		{
			swap(lt);
			return *this;
		}

		//clear清除
		void clear()
		{
			//复用erase
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

		//尾插
		void push_back(const T& x)
		{
			Node* tail = _head->_prev;//找尾
			Node* newnode = new Node(x);//创建一个新的结点
			//_head  tail  newnode
			//使tail和newnode构成循环
			tail->_next = newnode;
			newnode->_prev = tail;
			//使newnode和头结点_head构成循环
			newnode->_next = _head;
			_head->_prev = newnode;

			/*
			* 法二：复用insert
			* insert(end(), x);
			*/
		}
		//头插
		void push_front(const T& x)
		{
			insert(begin(), x);
		}
		//insert，插入pos位置之前
		iterator insert(iterator pos, const T& x)
		{
			Node* newnode = new Node(x);//创建新的结点
			Node* cur = pos._node; //迭代器pos处的结点指针
			Node* prev = cur->_prev;
			//prev newnode cur
			//链接prev和newnode
			prev->_next = newnode;
			newnode->_prev = prev;
			//链接newnode和cur
			newnode->_next = cur;
			cur->_prev = newnode;
			//返回新插入元素的迭代器位置
			return iterator(newnode);
		}
		//尾删
		void pop_back()
		{
			erase(--end());
		}
		//头删
		void pop_front()
		{
			erase(begin());
		}
		//erase
		iterator erase(iterator pos)
		{
			assert(pos != end());
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;
			//prev cur next
			//链接prev和next
			prev->_next = next;
			next->_prev = prev;
			//delete要删去的结点
			delete cur;
			//返回删除元素后一个元素的迭代器位置
			//return next;
			return iterator(next);
		}

		//迭代器相关函数
			//begin
		iterator begin()//begin返回的就是第一个有效数据，即头结点的下一个结点
		{
			return iterator(_head->_next);//构造了一个匿名对象，通过调用构造函数利用头结点指向的第一个结点作为参数，来返回头结点
			//return _head->_next;  也可以这样写
		}
		const_iterator begin() const
		{
			return const_iterator(_head->_next);
			//return _head->_next; 
		}
		//end
		iterator end()
		{
			return iterator(_head);//end返回的是最后一个结点的下一个结点，就是头结点_head
			//return _head;  也可以这样写
		}
		const_iterator end() const
		{
			return const_iterator(_head);
			//return _head;  也可以这样写
		}

		//反向迭代器
		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}
		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}
		//const反向迭代器
		const_reverse_iterator rbegin() const
		{
			return const_reverse_iterator(end());
		}
		const_reverse_iterator rend() const
		{
			return const_reverse_iterator(begin());
		}

	private:
		Node* _head;
	};
}

6.2 test.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"
//#include"Reverse_Iterator.h"

void test1()
{
	cpp::list lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	cpp::list::iterator it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << " ";//1 2 3 4
		++it;
	}
}

struct AA
{
	AA(int a1 = 0, int a2 = 0)
		:_a1(a1)
		, _a2(a2)
	{}
	int _a1;
	int _a2;
};

void test2()
{
	cpp::list lt;
	lt.push_back(AA(1, 1));
	lt.push_back(AA(2, 2));
	lt.push_back(AA(3, 3));
	lt.push_back(AA(4, 4));
	cpp::list::iterator it = lt.begin();
	while (it != lt.end())
	{
		//cout << (*it)._a1 << "-" << (*it)._a2 << " ";//1-1 2-2 3-3 4-4
		cout << it->_a1 << "-" << it->_a2 << " ";//1-1 2-2 3-3 4-4
		it++;
	}
}

void print_list(const cpp::list& lt)
{
	cpp::list::const_iterator it = lt.begin();
	while (it != lt.end())
	{
		//*it = 10;
		cout << *it << " ";//1 2 3 4
		++it;
	}
}
void print_list2(cpp::list& lt)
{
	cpp::list::iterator it = lt.begin();
	while (it != lt.end())
	{
		(*it);
		cout << *it << " ";//2 3 4 5
		++it;
	}
}
void test4()
{
	cpp::list lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);

	lt.push_front(1);
	lt.push_front(2);
	lt.push_front(3);
	lt.push_front(4);
	for (auto e : lt)
		cout << e << " ";
	cout << endl;
	lt.pop_front();
	lt.pop_front();

	lt.pop_back();
	lt.pop_back();
	for (auto e : lt)
		cout << e << " ";
}


//测试迭代器失效
/*
* list的insert不存在迭代器失效
* 不存在野指针问题，也不存在意义变了的问题
*/
void test5()
{
	cpp::list lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);
	lt.push_back(6);

	//要求在偶数的前面插入这个偶数*10
	auto it1 = lt.begin();
	while (it1 != lt.end())
	{
		if (*it1 % 2 == 0)
		{
			lt.insert(it1, *it1 * 10);
		}
		it1++;
	}
	for (auto e : lt)
		cout << e << " ";
	cout << endl;
}
/*
* list的erase以后迭代器是失效的，经典野指针失效，因为这个迭代器指向结点已经被释放了
*/
void test6()
{
	cpp::list lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);
	lt.push_back(6);

	//删除所有的偶数
	auto it1 = lt.begin();
	while (it1 != lt.end())
	{
		if (*it1 % 2 == 0)
		{
			it1 = lt.erase(it1);
		}
		it1++;
	}
	for (auto e : lt)
		cout << e << " ";
	cout << endl;
	lt.clear();
	for (auto e : lt)
		cout << e << " ";
	cout << endl;
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);
	lt.push_back(6);
	for (auto e : lt)
		cout << e << " ";
}

void test7()
{
	cpp::list lt1;
	lt1.push_back(1);
	lt1.push_back(2);
	lt1.push_back(3);
	lt1.push_back(4);
	lt1.push_back(5);
	lt1.push_back(6);

	cpp::list lt2(lt1);
	for (auto e : lt2)
	{
		cout << e << " ";
	}
	cout << endl;

	cpp::list lt3 = lt2;
	for (auto e : lt2)
	{
		cout << e << " ";
	}
	cout << endl;
}

void test8()
{
	cpp::list lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);
	lt.push_back(6);
	cpp::list::reverse_iterator rit = lt.rbegin();
	while (rit != lt.rend())
	{
		cout << *rit << " ";
		++rit;
	}
}
int main()
{
	//test1();
	//test2();
	cpp::list lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	//print_list(lt);
	//print_list2(lt);
	//test4();
	//test5();
	//test6();
	//test7();
	test8();
}