STL中的list的部分实现，包括了迭代器的整体实现思想和空间配置器的部分功能。

main.cpp

//STL中的list是一个双向循环链表
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include"mymemory.h"
using namespace std;

class String
{
public:
	String(const char* str="")
	{
		this->m_data = new char[strlen(str) + 1];
		strcpy(this->m_data, str);
	}

	String(const String& s)
	{
		this->m_data = new char[strlen(s.m_data) + 1];
		strcpy(this->m_data, s.m_data);
	}

	~String()
	{
		delete[] this->m_data;
	}

private:
	char* m_data;
};

namespace myList
{
	template<class _Ty, class _A=my_alloctor<_Ty>>
	class list
	{
	public:
		//类型的萃取
		typedef size_t size_type;
		typedef _Ty    value_type;
		typedef _Ty*   pointer_type;
		typedef _Ty& reference_type;


		struct _Node;
		typedef _Node* _Nodeptr;
		struct _Node
		{
			_Nodeptr _Next;
			_Nodeptr _Prev;
			_Ty     _Value;
		};
		struct _ACC
		{
			typedef _Node*& _Nodepref;
			typedef _Ty& _Vref;
			static  _Nodepref _Next(_Nodeptr _P)
			{return _P->_Next;}
			static _Nodepref _Prev(_Nodeptr _P)
			{return _P->_Prev;}
			static _Vref _Value(_Nodeptr _P)
			{return _P->_Value;}
		};

		class iterator
		{
	     public:
			 iterator() {}
			 iterator(_Nodeptr P):_Ptr(P){}
			 
			 _Ty& operator*()
			 {
				 return _Ptr->_Value;//返回值而不是返回结点
			 }

			 iterator& operator++()
			 {
				 _Ptr = _Ptr->_Next;
				 return *this;
			 }

			 iterator& operator--()
			 {
				 _Ptr = _Ptr->_Prev;
				 return *this;
			 }

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

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

			 _Nodeptr _Mynode()
			 {
				 return _Ptr;
			 }

		protected:
			_Nodeptr _Ptr;
		};

		explicit list():_Head(_Buynode()),_Size(0)
		{}

		explicit list(size_type _N, const _Ty& _V = _Ty()):_Head(_Buynode()),_Size(0)
		{
			insert(begin(), _N, _V);
		}

		iterator begin()
		{
			return  iterator(_Head->_Next);
		}

		iterator end()
		{
			return iterator(_Head);//_Head->_Prev->_Next 左闭右开，双向循环链表特殊情况
		}

		iterator insert(iterator _P, const _Ty& _X = _Ty())//_X=_Ty()为零初始化
		{
		/*	_Nodeptr _S = _Buynode(_P.Mynode(), _P.Mynode()->_Prev);
			_S->_Prev->_Next = _S;
			_S->_Next->_Prev = _S;
			_S->_Value = _X;
			++_Size;*/

			_Nodeptr _S = _P._Mynode();
			_ACC::_Prev(_S) = _Buynode(_S, _ACC::_Prev(_S));
			_S = _ACC::_Prev(_S);
			_ACC::_Next(_ACC::_Prev(_S)) = _S;
			//_S->_Value = _X;
			allocator.construct(&_ACC::_Value(_S), _X);
			++_Size;
			return iterator(_S);
		}

		void insert(iterator _P, size_type _M, const _Ty& _X)
		{
			for (; 0 < _M; --_M)
				insert(_P, _X);
		}

		void insert(iterator _P, const _Ty* _F, const _Ty* _L)
		{
			for (; _F != _L; ++_F)
			{
				insert(_P, *_F);
			}	
		}

		void push_back(const _Ty& x)
		{

			insert(end(), x);

			//_Nodeptr _S = _Buynode();
			//_S->_Next = _Head;
			//_S->_Prev = _Head->_Prev;
			//_S->_Prev->_Next = _S;
			//_S->_Next->_Prev = _S;

			//_Nodeptr _S = _Buynode(_Head,_ACC::_Prev(_Head));
			_Head->_Prev->_Next = _S;
			//_ACC::_Value(_S) = x;
			//_ACC::_Next(_ACC::_Prev(_Head)) = _S;
			_Head->_Prev = _S;
			//_ACC::_Prev(_Head) = _S;
			//_Size++;
		}

		void push_front(const _Ty& x)
		{
			insert(begin(), x);

		//	_Nodeptr _S =_Buynode(_ACC::_Next(_Head), _Head);
		///*	_ACC::_Prev(_ACC::_Next(_Head)) = _S;
		//	_ACC::_Next(_Head) = _S;*/
		//	_ACC::_Next(_ACC::_Prev(_S)) = _S;//换着方法写，增强理解
		//	_ACC::_Prev(_ACC::_Next(_S)) = _S;
		//	_ACC::_Value(_S) = x;
		//	_Size++;
		}

	/*	void show()const
		{
			_Nodeptr _P = _Head->_Next;
			while (_P != _Head)
			{
				cout << _P->_Value << "-->";
				_P = _P->_Next;
			}
		}*/

	protected:
		_Nodeptr _Buynode(_Nodeptr _Narg=0,_Nodeptr _Parg=0)//后继参数和前驱参数
		{
			//_Node* _S = (_Node*)malloc(sizeof(_Node));
			_Node* _S = (_Nodeptr)allocator.charalloc(sizeof(_Node));
			//_S->_Next = _Narg != 0 ? _Narg : _S;//头结点和普通节点都考虑了，比较巧妙
			_ACC::_Next(_S) = _Narg != 0 ? _Narg : _S;
			//_S->_Prev = _Parg != 0 ? _Parg : _S;
			_ACC::_Prev(_S)= _Parg != 0 ? _Parg : _S;
			return _S;
		}

	private:
		_A  allocator;//空间配置器对象
		_Nodeptr _Head;
		size_type _Size;
	};
}

using namespace myList;
void main()
{
	list<String> mylist;
	String s[] = { "abc","xyz","hjk" };
	mylist.push_back(s[0]);
	mylist.push_back(s[1]);
	mylist.push_back(s[2]);
	system("pause");
}

//using namespace myList;
//void main()
//{
//	list<int> mylist(10,2);
//	for (list<int>::iterator it = mylist.begin(); it != mylist.end(); ++it)
//	{
//		cout << *it << "-->";
//	}
//	cout << endl;
//	system("pause");
//}

//using namespace myList;
//void main()
//{
//	list<int> mylist;
//	mylist.push_back(1);
//	mylist.push_back(2);
//	mylist.push_back(3);
//	mylist.push_back(4);
//	mylist.push_front(5);
//	
//	list<int>::iterator it= mylist.begin();
//	/*cout << *it << endl;
//	++it;
//	cout << *it << endl;*/
//
//	while (it != mylist.end())
//	{
//		cout << *it << "-->";
//		++it;
//	}
//	cout << endl;
//
//	5 1 2 3 4
//	list<int>::iterator pos = mylist.begin();
//	++pos;
//	++pos;
//
//	int ar[] = { 20,33,35,56,68,99,12,37 };
//	int n = sizeof(ar) / sizeof(ar[0]);
//
//	mylist.insert(pos,3, 100);
//	mylist.insert(pos, ar, ar + n);
//
//	it = mylist.begin();
//	while (it != mylist.end())
//	{
//		cout << *it << "-->";
//		++it;
//	}
//	system("pause");
//}

mymemory.h

template<class _Ty>
_Ty* _My_Allocate(size_t _N, _Ty*)
{
	if (_N < 0)
		_N = 0;
	return((_Ty*)operator new(_N * sizeof(_Ty)));
}

template<class _T1, class _T2>
void _My_Construct(_T1* _P, const _T2& _V)
{
	  new((void*)_P) _T1(_V);//定位new
	
}

template<class _Ty>
void _Destroy(_Ty* _P)
{
	_P->~_Ty();
}

//空间配置器
template<class _Ty>
class my_alloctor
{
public:
	//申请空间
	_Ty* allocte(size_t _N, const void*)
	{
		return (_My_Allocate(_N, (_Ty*)0));
	}

	//申请字节空间
	char* charalloc(size_t _N)
	{
		return (_My_Allocate(_N, (char*)0));
	}

	//释放空间
	void deallocate(void* _P, size_t)
	{
		operator delete(_P);
	}

	//构造对象
	void construct(_Ty* _P, const _Ty& _V)
	{
		_My_Construct(_P, _V);
	}

	//析构对象
	void destory(_Ty* _P)
	{
		_Destory(_P);
	}
};