今天把List容器給實現了一遍。List容器的實現應該來說是比較簡單的，以前學習C語言的時候就已經是實現過這個數據結構，這次主要是要與STL中的東西相互結合，比如，內存管理使用自己寫的空間配置器，然後使用迭代器來封裝其中的指針。在寫LIST容器時候，我將代碼的整體結構做了很大改動，與前面的有點不同，以前不同的就先不改了，等以後將所有容器實現後，會將所有代碼放上面來。
/*
**
iterator_list.h
list的迭代器，繼承基類，實現專屬的迭代器,注意所有迭代器都是封裝了指針，但是所有迭代器都不會用該指針new出一個新對象出來,
只會將已存在的內存空間賦值給它-
*/
#ifndef ITERATOR_LIST_H_INCLUDED
#define ITERATOR_LIST_H_INCLUDED
#include"simple_allocator.h"
#include"my_iterator_base.h"
namespace juine
{
template<class T>
struct ListNode
{
T data;
ListNode *next;
ListNode *prex;
ListNode(T _data,ListNode *_next=0,ListNode *_prex=0):data(_data),next(_next),prex(_prex){}
};
template<class T>
class Iterator_list
{
public:
typedef ListNode<T>* pointer;
typedef bidirectional_iterator_tag iterator_category;
//構造函數和copy構造函數
Iterator_list(pointer item=0):point(item){}
Iterator_list(const Iterator_list& iter):point(iter.point){}
//析構函數
~Iterator_list(){}
Iterator_list operator++()
{
point=point->next;
return *this;
}
Iterator_list operator++(int )
{
Iterator_list iter=*this;
this->point=point->next;
return iter;
}
Iterator_list operator+(size_t n)
{
Iterator_list iter=*this;
while(n)
{
iter++;
n--;
}
return iter;
}
Iterator_list operator--()
{
this->point=point->prex;
return *this;
}
Iterator_list operator--(int )
{
Iterator_list iter=*this;
this->point=point->prex;
return iter;
}
Iterator_list operator-(size_t n)
{
Iterator_list iter=*this;
while(n)
{
iter--;
n--;
}
return iter;
}
//實現*和->的引用，!=
T& operator*(){ return point->data; }
pointer operator->(){ return point; }
bool operator==(Iterator_list iter){ return point==iter.point; }
bool operator!=(Iterator_list iter){ return point!=iter.point; }
pointer& get_pointer() { return this->point; }
protected:
pointer point;
};
}
#endif // ITERATOR_LIST_H_INCLUDED
//my_list.h
#ifndef MY_LIST_H_INCLUDED
#define MY_LIST_H_INCLUDED
#include"iterator_list.h"
#include"simple_allocator.h"
namespace juine
{
template<class T,class Alloc=my_alloc>
class my_list
{
public:
typedef T value_type;
typedef T* pointer;
typedef size_t size_type;
typedef ListNode<T> item_type;
typedef Iterator_list<T> iterator;
typedef simple_allocator<ListNode<T>,Alloc> data_container;
private:
iterator start;
iterator finish; //finish並不爲空，而是將其中元素值設爲0，next指針設爲0
size_type _size;
//創建節點，並用來初始化節點
item_type* uninitialized(value_type value,item_type* _prex,item_type* _next)
{
item_type* p=data_container::alloc(1);
p->data=value;
p->prex=_prex;
p->next=_next;
if(_prex!=0)
_prex->next=p;
if(_next!=0)
_next->prex=p;
return p;
}
void fill_uninitialized(size_type n,value_type value)
{
item_type* p=uninitialized(value,0,0);
start.get_pointer()=p;
while(n>1)
{
uninitialized(value,p,0);
p=p->next;
n--;
}
uninitialized(0,p,0);
finish.get_pointer()=p->next;
}
template<class InputIterator>
void fill_uninitialized(InputIterator first,InputIterator last)
{
item_type* p=uninitialized(*first,0,0);
start.get_pointer()=p;
first++;
_size=1;
while(first!=last)
{
uninitialized(*first,p,0);
p=p->next;
first++;
_size++;
}
uninitialized(0,p,0);
finish.get_pointer()=p->next;
}
void deallocate()
{
iterator temp;
cout<<"List容器釋放內存"<<endl;
while(start!=finish)
{
temp=start;
start++;
destroy(temp.get_pointer());
data_container::dealloc(temp.get_pointer());
}
}
public:
//構造函數,析構函數
my_list():start(0),finish(0),_size(0){}
my_list(size_type n,value_type value):_size(n){ fill_uninitialized(n,value);}
template<class InputIterator>
my_list(InputIterator first,InputIterator last){ fill_uninitialized(first,last); }
~my_list(){ deallocate() ;}
iterator begin() { return start; }
iterator end() { return finish; }
size_type size() { return _size; }
bool empty() { return _size==0; }
value_type& front() { return *start ;}
value_type& back() { return *(finish-1); }
void push_back(value_type value){ insert(finish,value); }
void push_front(value_type value){ insert(start,value); }
void insert(iterator position,value_type value)
{
item_type* temp=position->prex;
uninitialized(value,temp,position.get_pointer());
if(position==start) //插頭插尾不一樣
start--;
_size++;
}
template<class InputIterator>
void insert(iterator position,InputIterator first,InputIterator last)
{
item_type* temp=position->prex;
InputIterator _temp=last-1;
if(first==_temp) //明顯只插入一個，交給insert(position,value)處理
{
insert(position,*first);
return ;
}
int flag=1;
while(true)
{
temp=uninitialized(*first,temp,0);
if((position==start)&&flag)
{
flag=0;
start.get_pointer()=temp;
}
first++;
_size++;
if(first==_temp)
{
//最後插入的一個元素單獨處理
uninitialized(*first,temp,position.get_pointer());
_size++;
break;
}
}
}
//刪頭刪尾做的考慮都交給erase
void pop_back(){ erase(start); }
void pop_front(){ erase(finish-1); }
void erase(iterator position)
{
if(position==start) //刪頭刪尾不一樣
{
position->next->prex=0;
start.get_pointer()=position->next;
}
else
{
position->prex->next=position->next;
position->next->prex=position->prex;
}
destroy(position.get_pointer());
data_container::dealloc(position.get_pointer());
}
void erase(iterator first,iterator last)
{
iterator temp=last-1;
if(first==temp)
{
erase(first);
return ;
}
if(first==start)
{
last->prex=0;
start=last;
}
else
{
last->prex=first->prex;
first->prex->next=last.get_pointer();
}
}
void clear()
{
erase(start,finish);
}
};
}
#endif // MY_LIST_H_INCLUDED
測試代碼：
#include<iostream>
#define _USE_ALLOC
#include"my_list.h"
using namespace juine;
using namespace std;
template<class T,class U>
void display(T a,U b)
{ cout<<"hello"<<endl; }
template<>
void display(size_t a,int b)
{ cout<<"world"<<endl; }
//void test_list_funtion()
int main()
{
int a[6]={1,2,3,4,5,6};
my_list<int> ll(a,a+6);
ll.erase(ll.begin(),ll.end());
my_list<int>::iterator iter=ll.begin();
while(iter!=ll.end())
{
cout<<*iter++<<endl;
}
}
