【STL】list的应用模拟实现

     STL：标准模板库，惠普实验室开发的一系列软件的统称。

STL的六大组件：

容器，迭代器，算法，适配器，空间配置器，仿函数。

下面模拟序列式容器的一个列表：list（本质：带头结点的双向循环链表）。

库中list的使用：

#include <iostream>
#include <list>
#include <algorithm>
using namespace std;

//迭代器的使用
void ListTest()
{
list<int> l1;
l1.push_back(1);
l1.push_back(2);
l1.push_back(3);
l1.push_back(4);
l1.push_back(5);
//正向迭代器
list<int>::iterator it1 = l1.begin();
while(it1 != l1.end())
{
cout<<*it1<<" ";
it1++;
}
cout<<endl;

//反向迭代器
list<int>::reverse_iterator it2 = l1.rbegin();
while(it2 != l1.rend())
{
cout<<*it2<<" ";
it2++;
}
cout<<endl;

//max_size():整型的最大值/每个元素的字节数
unsigned int i;

cout << "Enter number of elements: ";
cin >> i;

if (i<l1.max_size())
l1.resize(i);
else
cout << "That size exceeds the limit.\n";
cout<<l1.size()<<endl;

//insert:在指定位置的数据之前插入
list<int>::iterator it3 = l1.begin();
it3++;
l1.insert(it3,10);
it3 = l1.begin();
while(it3 != l1.end())
{
cout<<*it3<<" ";
it3++;
}
cout<<endl;

//erase:擦除指定位置的元素(由于list中没有find接口，所以需要引入算法头文件)
list<int>::iterator it4 = find(l1.begin(),l1.end(),10);
if(it4 != l1.end())
l1.erase(it4);
it4 = l1.begin();
while(it4 != l1.end())
{
cout<<*it4<<" ";
it4++;
}
cout<<endl;

//迭代器失效
list<int>::iterator it5 = l1.begin();
//if (it5 != l1.end())
//{
//	l1.erase(it5);//释放之后it5指向随机空间
//}
//it5++;//对随机空间++，导致程序崩溃

//解决方法：1、先加加，再删除
if (it5 != l1.end())
{
it5++;
l1.erase(it5);
}
//2、利用返回值对其进行改进
it5 = l1.begin();
if (it5 != l1.end())
{
it5 = l1.erase(it5);
}
else
{
it5++;
}

//remove:删除值某特定值的元素
l1.remove(4);
it5 = l1.begin();
while(it5 != l1.end())
{
cout<<*it5<<" ";
it5++;
}
cout<<endl;

}
int main()
{
ListTest();
system("pause");
return 0;
}

运行结果：



模拟list:

//模拟list(带头结点的双向循环链表)
#pragma  once
#include <iostream>
using namespace std;
#include <Cassert>

template <class T>
struct ListNode
{
ListNode <T>* _prev;
ListNode <T>* _pnext;

T _data;

ListNode(const T& data)
:_data(data)
,_prev(NULL)
,_pnext(NULL)
{}
};

// T T& T*
//typedef ListIterator<T,T&,T*> Iterator;//普通迭代器
//typedef ListIterator<T,const T&, const T*> ConstIterator;//const迭代器

template <class T, class Ref, class Ptr>
struct ListIterator
{
typedef ListNode<T> Node;
typedef ListIterator<T, Ref, Ptr> Self;
Node* _node;

ListIterator()
{}
ListIterator(Node* node)
:_node(node)
{}
bool operator==(const Self& s)
{
return s._node == _node;
}
bool operator!=(const Self& s)
{
return s._node != _node;
}
//T& operator*()
Ref operator*()
{
return _node->_data;
}
//T* operator->()
Ptr operator->()
{
return &_node->_data;
}
Self& operator++()//前置++
{
_node = _node->_pnext;
return *this;
}
Self operator++(int)//后置++
{
Self tmp(*this);
_node = _node->_pnext;
return tmp;
}
Self& operator--()//前置--
{
_node = _node->_prev;
return *this;
}
Self operator--(int)//后置--
{
//Self tmp(*this);
Self tmp(_node);
_node = _node->_prev;
return tmp;
}
};
template <typename T>
class List
{
public:
typedef ListNode <T> Node;
typedef ListIterator<T,T&,T*> Iterator;//普通迭代器
typedef ListIterator<T,const T&, const T*> ConstIterator;//const迭代器

public:
List()
:_head(BuyNode(T()))
{
_head->_pnext = _head;
_head->_prev = _head;
}
void PushBack(const T& data)
{
Node* tail = _head->_prev;
Node* newnode = BuyNode(data);

tail->_pnext = newnode;
newnode->_prev = tail;

newnode->_pnext = _head;
_head->_prev = newnode;
}
void PopBack()
{
Erase(--End());
}
void PushFront(const T& data)
{
Insert(Begin(),data);
}
void PopFront()
{
Erase(Begin());
}

template <typename InputIterator>//模板类中的模板函数
void Insert(Iterator pos, InputIterator first, InputIterator last)
{
while (first != last)
{
Insert(pos, *first);
++first;
}
}
Iterator Insert(Iterator pos,const T& data)
{
assert(pos._node);

Node* cur = pos._node;
Node* prev = cur->_prev;

Node* tmp = new Node(data);

prev->_pnext = tmp;
tmp->_prev = prev;

tmp->_pnext = cur;
cur->_prev = tmp;

return tmp;
}
Iterator Erase(Iterator pos)
{
assert(pos._node && pos._node != _head);

Node* prev = pos._node->_prev;
Node* next = pos._node->_next;

prev->_next = next;
next->_prev = prev;

delete pos._node;

return Iterator(next);//返回下一个节点，防止迭代器失效
}
Iterator Begin()
{
//return Iterator(_head->_next);
return _head->_pnext; //自动进行隐式类型转换:
//构造函数和拷贝构造同一步骤使用，编译器会进行自动优化,只调用一个
}

Iterator End()
{
//return Iterator(_head);
return _head;//自动进行隐式类型转换
//构造函数和拷贝构造同一步骤使用，编译器会进行自动优化,只调用一个
}

ConstIterator Begin() const
{
//return ConstIterator(_head->_next);
return _head->_pnext;//自动进行隐式类型转换
//构造函数和拷贝构造同一步骤使用，编译器会进行自动优化,只调用一个
}

ConstIterator End() const
{
//return ConstIterator(_head);
return _head;//自动进行隐式类型转换
//构造函数和拷贝构造同一步骤使用，编译器会进行自动优化,只调用一个
}
private:
Node* BuyNode(const T& data)
{
return new Node(data);
}
protected:
Node* _head;//指向头结点的指针
};

void PrintListConst(const List<int>& l)
{
List<int>::ConstIterator it = l.Begin();

while (it != l.End())
{
cout<<*it<<" ";
it++;
}
cout<<endl;
}

void PrintList(List<int>& l)
{
List<int>::Iterator it = l.Begin();

while (it != l.End())
{
cout<<*it<<" ";
it++;
}
cout<<endl;
}

void TestList()
{
List<int> l1;
l1.PushBack(1);
l1.PushBack(2);
l1.PushBack(3);
l1.PushBack(4);

PrintList(l1);

List<int> l2;
l2.PushBack(5);
l2.PushBack(6);
l2.PushBack(7);

List<int>::Iterator pos = l1.Begin();
l1.Insert(pos, l2.Begin(), l2.End());
PrintListConst(l1);

}
int main()
{
TestList();
system("pause");
return 0;
}

运行结果：