STL （序列式容器list）

标准模板库 STL（目标：使代码达到通用性）

分为六大部分：空间配置器（申请空间、释放空间、构造对象、析构对象）、迭代器（数据结构相关、算法与容器之间的粘合剂）、算法、容器、仿函数（象函数（使用方法相似）的对象）、容器适配器（将现有的容器进行封装）

下面主要是序列式容器list的简单构架

代码如下：

//主函数stlmain.cpp

#include<iostream>
#include"list.h"


using namespace std;




void main()
{
list<int> mylist;
mylist.push_back(1);
mylist.push_back(2);
mylist.push_back(3);
mylist.push_back(4);
mylist.push_back(5);


mylist.pop_back();
mylist.pop_front();

list<int>::iterator it;
it = mylist.begin();
while(it!=mylist.end())
{
cout<<*it<<"->";
++it;
}
cout<<"OVER!"<<endl;
}

//list.h

#ifndef _LIST_H
#define _LIST_H


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


template<class _Ty,class _A = _my_allocator<_Ty>>
class list
{
typedef size_t size_type;
public:
struct _Node;
typedef _Node* _Nodeptr;
struct _Node
{
_Nodeptr _Next;
_Nodeptr _Prev;
_Ty      _Value;
};
struct _Acc
{
typedef _Nodeptr& _Nodepref;
typedef _Ty& _Vpref;
static _Nodepref _Pref(_Nodeptr _P)
{return ((_Nodepref)((*_P)._Prev));}
static _Nodepref _Next(_Nodeptr _P)
{return ((_Nodepref)(*_P)._Next);}
static _Vpref _Value(_Nodeptr _P)
{return ((_Vpref)(*_P)._Value);}
};
public:
class iterator
{
public:
iterator()
{}
iterator(_Nodeptr _P):_Ptr(_P)
{}
_Nodeptr _Mynode()const
{
return _Ptr;
}
public:
bool operator==(const iterator& _P)const
{return(_Ptr==_P._Ptr);}
bool operator!=(const iterator& _P)const
{return !(*this == _P);}


_Ty& operator*()const
{return _Acc::_Value(_Ptr);}
_Ty* operator->()const
{return &**this;}//返回当前对象的值的指针


iterator& operator++()//前加加
{
_Ptr = _Acc::_Next(_Ptr);
return *this;
}
iterator operator++(int)//后加加
{
   iterator _Tmp = *this;
++*this;
return _Tmp;
}
iterator& operator--()
{
_Ptr = _Acc::_Pref(_Ptr);
return *this;
}
iterator operator--(int)
{
iterator * Tmp = *this;
--*this;
return Tmp;
}
protected:
_Nodeptr _Ptr;
};
public:
   iterator begin()
{return (iterator(_Acc::_Next(_Head)));}//返回节点的地址当做参数返回迭代器的构造函数
iterator end()
{return (iterator(_Head));}
public:
explicit list():_Head(_Buynode()),_Size(0)
{}

explicit list(size_type _N, const _Ty &_V=_Ty()):_Head(_Buynode()),_Size(0)
{insert(begin(), _N, _V);}
list(const _Ty *_F,const _Ty* _L):_Head(_Buynode()),_Size(0)
{insert(begin(),_F,_L);}
list(iterator _F,iterator _L):_Head(_Buynode()),_Size(0)
{insert(begin(),_F,_L);}
~list()
{
erase(begin(),end());
_Freenode(_Head);
_Head = NULL;
_Size = 0;
}
public:
iterator insert(iterator _P,const _Ty& _X=_Ty())//在_P的位置插入_X//_Ty()若没提供值，则用默认值0
{
_Nodeptr _S = _P._Mynode();
_Acc::_Pref(_S) = _Buynode(_S,_Acc::_Pref(_S));
_S = _Acc::_Pref(_S);
_Acc::_Next(_Acc::_Pref(_S)) = _S;
_Acc::_Value(_S) = _X;
++_Size;
return (iterator(_S));
}
void insert(iterator _P,size_type _M,const _Ty& _X)//在_P的位置插入_M个_X
{
for(;0<_M;--_M)
insert(_P,_X);
}
void insert(iterator _P,const _Ty* _F,const _Ty* _L)//_Ty* _F
{
for(;_F!=_L;++_F)
insert(_P,*_F);
}
void insert(iterator _P,iterator _F,iterator _L)
{
for(;_F!=_L;++_F)
insert(_P,*_F);
}
void push_back(const _Ty& X)
{
insert(end(),X);
/*
_Nodeptr _S = _Buynode(_Head,_Acc::_Pref(_Head));
_Acc::_Next(_Acc::_Pref(_S)) = _S;
_Acc::_Pref(_Head) = _S;
_Acc::_Value(_S)= X;
++_Size;*/
}
void push_front(const _Ty& X)
{
insert(begin(),X);
}
iterator erase(iterator _P)
{
_Nodeptr _S = (_P++)._Mynode();//保证迭代器执行完删除操作仍有效
_Acc::_Pref(_Acc::_Next(_S)) = _Acc::_Pref(_S);
_Acc::_Next(_Acc::_Pref(_S)) = _Acc::_Next(_S);
allocator.destory(&_Acc::_Value(_S));
_Freenode(_S);
--_Size;
return _P;
}
iterator erase(iterator _F,iterator _L)
{
while(_F!=_L)
erase(_F++);
return _F;
}

void pop_back()
{erase(--end());}
void pop_front()
{erase(begin());}
protected:
_Nodeptr _Buynode(_Nodeptr _Narg = 0,_Nodeptr _Parg = 0)
{
_Nodeptr _S = (_Nodeptr)malloc(sizeof(_Node));
assert(_S!=NULL);
_Acc::_Next(_S) = _Narg!=0 ?_Narg:_S;
_Acc::_Pref(_S) = _Parg!=0?_Parg:_S;
return _S;
}
void _Freenode(_Nodeptr _p)
{
allocator.deallocator(_p,1);
}
private:
_A allocator;
_Nodeptr _Head;
size_type _Size;
};
#endif

//memory.h

#ifndef _MEMORY_H
#define _MEMORY_H


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


template<class _T1,class _T2>
void _My_Construct(_T1* _P,const _T2& _V)
{
new((void*)_P)_T2(_V);//placement new  （定位new）_P所指的位置构造一个_T1对象用_V的值初始化
}


template<class _Ty>
void _My_Destory(_Ty* _P)
{
_P->~_Ty();//调用该类型的析构函数
}

template<class _Ty>
class _my_allocator
{
public:
_Ty* address(_Ty& _X)const
{return(&_X);}
const _Ty* address(const _Ty& _X)const
{return(&_X);}
_Ty* allocator(size_t _N,const void *)//申请空间
{
return(_My_Allocator((ptrdiff_t)_N,(_Ty*)0));
}
char* _Charalloc(size_t _N)//申请字符空间
{
return(_My_Allocator((ptrdiff_t)_N,(char*)0));//地址为0，主要看其类型
}
void deallocator(void* _P,size_t)//释放空间
{
operator delete(_P);
}
void construct(_Ty* _P,const _Ty& _V)//构造函数
{
_My_Construct(_P,_V);
}
void destory(_Ty* _P)
{
_My_Destory(_P);
}
size_t max_size()//开辟多大空间
{
size_t _N = (size_t)(-1)/sizeof(_Ty);//给-1FFFF FFFF FFFF FFFF取无符号型，则为最大值，再除以类型大小
return (0<_N?_N:1);
}
};


#endif