STL之双向链表及其迭代器简单实现

最近在看STL，试着写一个自己的链表模板，与STL相比没有使用空间配置器，方法也只实现了几个简单的插入删除元素。但是理清了容器、迭代器之间的关系。代码及测试用例如下。

list_test.h文件
# ifndef LIST_TEST
# define LIST_TEST

#include<iostream>

template <typename T>
class listnode
{
public:
listnode<T>* prev;
listnode<T>* next;
T data;
};

template <typename T>
class list_iterator
{
typedef listnode<T>* link_type;
public:
listnode<T>* node;
list_iterator()
{
node = NULL;
}
list_iterator(link_type n)
{
node = n;
}
bool operator==(const list_iterator& x) const
{
return node == x.node;
}
bool operator!=(const list_iterator& x)const
{
return node != x.node;
}
T operator*() const
{
return node->data;
}
list_iterator operator++()
{
node = node->next;
return *this;
}
list_iterator operator++(int)
{
list_iterator tmp=*this;
++*this;
return tmp;
}
list_iterator operator--()
{
node = node->prev;
return *this;
}
list_iterator operator--(int)
{
list_iterator tmp = *this;
--*this;
return tmp;
}
};

template <typename T>
class list_test
{
typedef listnode<T> list_node;
typedef listnode<T>* link_type;
typedef list_iterator<T> iterator;
public:
link_type head;
link_type get_node()
{
return new list_node();
}
list_test()
{
head = get_node();
head->next = head;
head->prev = head;
}
list_test(const list_test& source)
{
this->head = get_node();           //此处三行不可以直接调用构造函数
this->head->next = head;
this->head->prev = head;
link_type tmp = source.head->prev;
while (tmp != source.head)
{
this->put_front(tmp->data);
tmp = tmp->prev;
}
}
~list_test()
{
link_type tmp1 = head;
link_type tmp2 = head->prev;
while (tmp2 != head)
{
tmp1 = tmp2->prev;
delete tmp2;
tmp2 = tmp1;
}
delete head;
head = NULL;
}

iterator insert(iterator pos,const T value)
{
link_type temp = get_node();
temp->data = value;
temp->next = pos.node;
temp->prev = pos.node->prev;
pos.node->prev->next = temp;
pos.node->prev = temp;
return temp;
}

iterator put_back(const T value)
{
iterator temp = this->insert(head, value);
return temp;
}
iterator put_front(const T value)
{
iterator temp = this->insert(head->next, value);
return temp;
}

iterator begin()
{
return head->next;
}
iterator end()
{
return head;
}
iterator erase(iterator position)
{
link_type next_node = link_type(position.node->next);
link_type prev_node = link_type(position.node->prev);
prev_node->next = next_node;
next_node->prev = prev_node;
delete position.node;
return iterator(next_node);
}

};

# endif

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "list_test.h"
using namespace std;
int main(int argv, char** argc)
{
list_test < int > test ;
for (int n = 0; n < 5; ++n)
{
test.put_front(n);                       //方法测试
}
for (auto i = test.begin(); i != test.end();i++)
{
cout << *i << " ";
}
cout << endl;

list_test < int > *test1 = new list_test < int >();
for (int n = 0; n < 5; ++n)
{
test1->put_front(n);
}
for (auto i = test1->begin(); i != test1->end(); i++)
{
cout << *i << " ";
}
cout << endl;
delete test1;                      //析构函数测试

list_test < int > test2(test);     //拷贝复制函数测试
test2.erase(++test2.begin());      //方法测试
test2.put_back(-1);                //方法测试
test2.put_front(5);                //方法测试
for (auto i = test2.begin(); i != test2.end(); i++)
{
cout << *i << " ";
}
cout << endl;
}

测试结果如下图


另外给出析构函数的测试截图

执行析构函数前，test1所指链表的head指向0x00319288内存单元



执行析构指令后head被复位为0xfeee，但test1存在与栈上，仍然存在，此时test1便成为野指针。