双向链表的C++类模板实现

师兄的，转自：http://my.oschina.net/zmjerry/blog/3653

头文件：

 

/***************************************************************************** *                                 doublelist.h * * Double List. * * This class template includes a smart pointer supporting "*", "++", "--", * "==" and "!=" operations,  which makes it easy to implement the frequently * used operations, such as "is empty", "make empty", "begin", "end", "fornt", * "back", "push front", "push back", "pop front", "pop back", "insert", * "erase" and so on. * * Zhang Ming, 2009-10 *****************************************************************************/#ifndef DOUBLELIST_H#define DOUBLELIST_H#include <iostream>namespace itlab{    /**     * List Node     */    template <typename Type>    struct Node    {        Type        data;        Node<Type>  *prev;        Node<Type>  *next;        Node( const Type &d=Type(), Node<Type> *p=NULL, Node<Type> *n=NULL )          : data(d), prev(p), next(n)        { }    };    // class Node    /**     * List Iterator     */    template <typename Type> class DList;    template <typename Type>    class ListItr    {        friend class DList<Type>;    public:        ListItr();        ListItr( Node<Type> *p );        ~ListItr();        inline Type& operator*();        inline const Type& operator*() const;        inline ListItr& operator++();        inline ListItr operator++( int );        inline ListItr& operator--();        inline ListItr operator--( int );        inline bool operator==( const ListItr &rhs ) const;        inline bool operator!=( const ListItr &rhs ) const;    private:        Node<Type> *current;    };    // class ListItr    /**     * Double List     */    template <typename Type>    class DList    {    public:        DList();        DList( const DList<Type> &rhs );        ~DList();        DList<Type>& operator=( const DList<Type> &rhs );        typedef ListItr<Type>   Iterator;        typedef const Iterator  Const_Iterator;        inline void clear();        inline bool isEmpty() const;        inline int size() const;        inline Iterator begin();        inline Const_Iterator begin() const;        inline Iterator end();        inline Const_Iterator end() const;        inline Type& front();        inline const Type& front() const;        inline Type& back();        inline const Type& back() const;        inline void pushFront( const Type &x );        inline void pushBack( const Type &x );        inline void popFront();        inline void popBack();        Iterator insert( Iterator itr, const Type &x );        Iterator erase( Iterator itr );        Iterator erase( Iterator start, Iterator end );    private:        int         listSize;        Node<Type>  *head;        Node<Type>  *tail;        inline void init();    };    // class DList    #include <doublelist-impl.h>}// namespace itlab#endif// DOUBLELIST_H

 

实现文件：

 

/***************************************************************************** *                               doublelist-impl.h * * Implementation for ListItr and DList class. * * Zhang Ming, 2009-10 *****************************************************************************//** * constructors and destructor */template <typename Type>ListItr<Type>::ListItr(){}template <typename Type>ListItr<Type>::ListItr( Node<Type> *p ) : current(p){}template <typename Type>ListItr<Type>::~ListItr(){}/** * Overload operations of pointer. */template <typename Type>inline Type& ListItr<Type>::operator*(){    return current->data;}template <typename Type>inline const Type& ListItr<Type>::operator*() const{    return current->data;}/** * Overload operations of "++" and "--". */template <typename Type>inline ListItr<Type>& ListItr<Type>::operator++(){    current = current->next;    return *this;}template <typename Type>inline ListItr<Type> ListItr<Type>::operator++( int ){    ListItr old = *this;    ++( *this );    return old;}template <typename Type>inline ListItr<Type>& ListItr<Type>::operator--(){    current = current->prev;    return *this;}template <typename Type>inline ListItr<Type> ListItr<Type>::operator--( int ){    ListItr old = *this;    --( *this );    return old;}/** * Overload comparison operations. */template <typename Type>inline bool ListItr<Type>::operator==( const ListItr &rhs ) const{    return current == rhs.current;}template <typename Type>inline bool ListItr<Type>::operator!=( const ListItr &rhs ) const{    return !( *this == rhs );}/** * constructors and destructor */template< typename Type >inline void DList<Type>::init(){    listSize = 0;    head = new Node<Type>;    tail = new Node<Type>;    head->next = tail;    tail->prev = head;}template< typename Type >DList<Type>::DList(){    init();}template< typename Type >DList<Type>::DList( const DList &rhs ){    init();    *this = rhs;}template< typename Type >DList<Type>::~DList(){    clear();    delete head;    delete tail;}/** * assigning operator */template< typename Type >DList<Type>& DList<Type>::operator=( const DList &rhs ){    if( this == &rhs )        return *this;    clear();    for( Iterator itr=rhs.begin(); itr!=rhs.end(); ++itr )        pushBack( *itr );    return *this;}/** * Make the list empty. */template< typename Type >inline void DList<Type>::clear(){    while( !isEmpty() )        popFront();}/** * If the list is empty, return true. */template< typename Type >inline bool DList<Type>::isEmpty() const{    return size() == 0;}/** * Return the size of list. */template< typename Type >inline int DList<Type>::size() const{    return listSize;}/** * Get the beginning iterator of the list. */template< typename Type >inline typename DList<Type>::Iterator DList<Type>::begin(){    return Iterator( head->next );}template< typename Type >inline typename DList<Type>::Const_Iterator DList<Type>::begin() const{    return Iterator( head->next );}/** * Get the ending iterator of the list. */template< typename Type >inline typename DList<Type>::Iterator DList<Type>::end(){    return Iterator( tail );}template< typename Type >inline typename DList<Type>::Const_Iterator DList<Type>::end() const{    return Iterator( tail );}/** * Get the front element of the list. */template< typename Type >inline Type& DList<Type>::front(){    return *begin();}template< typename Type >inline const Type& DList<Type>::front() const{    return *begin();}/** * Get the back element of the list. */template< typename Type >inline Type& DList<Type>::back(){    return *--end();}template< typename Type >inline const Type& DList<Type>::back() const{    return *--end();}/** * Push an element from the front of the list. */template< typename Type >inline void DList<Type>::pushFront( const Type &x ){    insert( begin(), x );}/** * Push an element from the back of the list. */template< typename Type >inline void DList<Type>::pushBack( const Type &x ){    insert( end(), x );}/** * Pop an element from the front of the list. */template< typename Type >inline void DList<Type>::popFront(){    erase( begin() );}/** * Push an element from the back of the list. */template< typename Type >inline void DList<Type>::popBack(){    erase( --end() );}/** * Insert an element into list at the position pointed by "itr". */template< typename Type >typename DList<Type>::Iterator DList<Type>::insert( Iterator itr,                                                    const Type &x ){    Node<Type> *p = itr.current;    p->prev = p->prev->next = new Node<Type>( x, p->prev, p );    listSize++;    return Iterator( p->prev );}/** * Erase an element pointed by "itr". */template< typename Type >typename DList<Type>::Iterator DList<Type>::erase( Iterator itr ){    Node<Type> *p = itr.current;    Iterator tmp( p->next );    p->prev->next = p->next;    p->next->prev = p->prev;    listSize--;    delete p;    return tmp;}/** * Erase elements from "start" to "end" of the list . */template< typename Type >typename DList<Type>::Iterator DList<Type>::erase( Iterator start,                                                   Iterator end ){    for( Iterator itr = start; itr != end; )        itr = erase( itr );    return end;}

 

测试文件：

 

/***************************************************************************** *                               dlist_test.cpp * * Double list class testing. * * Zhang Ming, 2009-10 *****************************************************************************/#include <iostream>#include <string>#include <doublelist.h>using namespace std;using namespace itlab;template <typename Type>void printList( const DList<Type> &dl ){    if( dl.isEmpty() )        cout << "  The list is empty!" << endl;    typename DList<Type>::Iterator itr = dl.begin();    while( itr != dl.end() )        cout << "  " << *itr++ << endl;    cout << endl;}int main(){    string name;    DList<string> dl;    dl.pushBack( "Zhang Ming" );    dl.pushBack( "Zhang Zong" );    printList( dl );    dl.pushFront( "Yu Kai" );    dl.pushFront( "Yu Zong" );    printList( dl );    dl.popFront();    dl.popFront();    printList( dl );    dl.popBack();    printList( dl );    DList<string>::Iterator itr = dl.begin();    dl.insert( itr, "Yu Kai" );    printList( dl );    dl.insert( dl.end(), "Yu Zong" );    printList( dl );    cout << "  The first element in the list is: " << dl.front() << endl;    cout << "  The last element in the list is: " << dl.back() << endl;    cout << endl;    dl.erase( dl.begin() );    dl.erase( --dl.end() );    printList( dl );    DList<string>::Const_Iterator citr = dl.begin();    cout << "  " << *citr << endl;    cout << endl;    dl.clear();    printList( dl );    return 0;}