list模拟实现

list模拟实现

前期我已经简单的介绍过list相关内容，今天进行list的模拟实现。

代码见下：

#pragma once

#include"Iterator.h"
#include<iostream>
#include<assert.h>

using namespace std;

template <class T>

struct ListNode
{
    ListNode<T>* _next;
    ListNode<T>* _prev;
    T _data;

    ListNode(const T& x)
        :_next(NULL)
        , _prev(NULL)
        , _data(x)
    {}
};

template <class T, class Ref, class Ptr>
struct _Iterator
{
    typedef _Iterator<T, Ref, Ptr> iter;
    typedef ListNode<T> Node;
    typedef Ref Reference;
    typedef Ptr Pointer;
    Node* _node;

    _Iterator(Node* node)
        :_node(node)
    {}

    Ref operator*()
    {
        return _node->_data; 
    }

    Ptr operator->()
    {
        return &(Node->_data);
    }

    iter& operator++()
    {
        _node = _node->_next;
        return *this;
    }

    iter operator++(int)
    {
        iter tmp(_node);
        _node = _node->_next;
        return tmp;
    }

    iter operator--()
    {
        _node = _node->_prev;
        return *this;
    }

    iter operator--(int)
    {
        iter tmp(_node);
        _node = _node->_prev;
        return tmp;
    }

    bool operator==(const iter& it)
    {
        return (_node == it._node);
    }

    bool operator!=(const iter& it)
    {
        return !(_node == it._node);
    }
};

template <class T>
class List
{
    typedef ListNode<T> Node; 
public:
    typedef _Iterator<T, T&, T*> Iterator;
    typedef _Iterator<T, const T&, const T*> ConstIterator;
    typedef __ReverseIterator<Iterator> ReverseIterator;

    List()
        :_head(new Node(T()))
    { 
        _head->_next = _head;
        _head->_prev = _head;
    }

    Iterator Begin()
    {
        return Iterator(_head->_next);
    }

    ConstIterator Begin() const
    {
        return ConstIterator(_head->_next);
    }

    ReverseIterator rBegin()
    {
        return End();
    }

    Iterator End()
    {
        return Iterator(_head);
    }

    ConstIterator End() const
    {
        return ConstIterator(_head);
    }

    ReverseIterator rEnd()
    {
        return Begin();
    }

    void PushBack(const T& x)
    {
        Insert(End(), x);
    }

    void PopBack()
    {
        Erase(--End());
    }

    void PushFront(const T& x)
    {
        Insert(Begin(), x);
    }

    void PopFront()
    {
        Erase(Begin());
    }

    void Insert(Iterator pos, const T& x)
    {
        Node* tmp = pos._node;
        Node* prev = tmp->_prev;

        Node* newNode = new Node(x);
        newNode->_next = tmp;
        newNode->_prev = prev;
        prev->_next = newNode;
        tmp->_prev = newNode;
    }

    Iterator Erase(Iterator& pos)
    {
        assert(pos != End());
        assert(_head->_next != _head);

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

        delete pos._node;

        prev->_next = next;
        next->_prev = prev;
        pos=prev;
        return next;
    }

private:
    Node* _head;
};

头文件包含的Iterator.h文件内容如下，其为一个容器适配器:

#pragma once

// 复用和效率

// 适配器模式 --> 复用
// List->__ListIterator
// Vector->T*
template<class Iterator>
struct __ReverseIterator
{
    Iterator _it;

    __ReverseIterator(Iterator it)
        :_it(it)
    {}

    typename Iterator::Reference operator*()
    {
        Iterator it = _it;
        return *(--it);
    }

    typename Iterator::Pointer operator->()
    {
        return &(operator*());
    }

    __ReverseIterator operator++()
    {
        --_it;
        return *this;
    }

    __ReverseIterator operator--()
    {
        ++_it;

        return *this;
    }

    bool operator != (__ReverseIterator<Iterator>& s)
    {
        return _it != s._it;
    }

    bool operator == (__ReverseIterator<Iterator>& s)
    {
        return _it == s._it;
    }
};

测试代码见下：

template <class T>
void Print(List<T>& l)
{
    List<int>::Iterator it1 = l.Begin();
    while (it1 != l.End())
    {
        cout << *it1 << " ";
        it1++;
    }
    cout << endl;
}

template <class T>
void PrintConst(const List<T>& l)
{
    List<int>::ConstIterator it1 = l.Begin();
    List<int>::ConstIterator it2 = l.End();
    while (it1 != l.End())
    {
        cout << *it1 << " ";
        it1++;
    }
    cout << endl;
}

void MyListTest()
{
    List<int> l;
    l.PushBack(1);
    l.PushBack(2);
    l.PushBack(3);
    l.PushBack(4);
    Print(l);

    // ReverseIterator 测试
    List<int>::ReverseIterator rIt = l.rBegin();
    while (rIt != l.rEnd())
    {
        cout << *rIt << " ";
        ++rIt;
    }
    cout << endl;

    // ConstIterator 测试
    List<int> l1;
    l1.PushBack(1);
    l1.PushBack(2);
    l1.PushBack(3);
    l1.PushBack(4);
    PrintConst(l1); 

    List<int>::Iterator it1 = l.Begin();
    l.Insert(it1, 0);
    Print(l);
    l.PushFront(-1);
    Print(l);
    List<int>::Iterator it2 = l.Begin();
    l.Erase(it2);
    Print(l);
}

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

程序运行结果如下：