C++数据结构之双向链表(十九)

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/qq_32642107/article/details/102731781

引用了猎豹网校的教程

main.cpp

#include <iostream>
#include "List.h"

using namespace std;

int main()
{
	List<int> myList;

	myList.push_front(20);
	myList.push_front(30);
	myList.push_back(10);

	List<int>::const_iterator iter = myList.begin();
	cout << *iter << endl;
	++iter;
	cout << *iter << endl;
	++iter;
	cout << *iter << endl;

	return 0;
}

list.h

#ifndef LIST_H
#define LIST_H

class IteratorMismatchException{};

template <typename Object>
class List
{
private:
    struct Node
    {
	   Object  data;
	   Node   *prev;
	   Node   *next;

	   Node( const Object & d = Object( ), Node *p = 0, Node *n = 0 )
		  : data( d ), prev( p ), next( n ) { }
    };

public:
    class const_iterator
    {
    public:
	   const_iterator( ) : current( 0 )
	   { }

	   const Object & operator* ( ) const
	   { return retrieve( ); }

	   const_iterator & operator++ ( )
	   {
		  current = current->next;
		  return *this;
	   }

	   const_iterator operator++ ( int )
	   {
		  const_iterator old = *this;
		  ++( *this );
		  return old;
	   }

	   bool operator== ( const const_iterator & rhs ) const
	   { return current == rhs.current; }
	   bool operator!= ( const const_iterator & rhs ) const
	   { return !( *this == rhs ); }

    protected:
	   const List<Object> *theList;
	   Node *current;

	   Object & retrieve( ) const
	   { return current->data; }


	   const_iterator(Node *p) : current(p)
	   {}

	   const_iterator( const List<Object> & lst, Node *p )
		  : theList( &lst ), current( p )
	   {
	   }

	   void assertIsValid( ) const
	   {
		  if( theList == 0 || current == 0 || current == theList->head )
			 throw IteratorOutOfBoundsException( );
	   }

	   friend class List<Object>;
    };


    class iterator : public const_iterator
    {
    public:
	   iterator( )
	   { }

	   Object & operator* ( )
	   { return retrieve( ); }
	   const Object & operator* ( ) const
	   { return const_iterator::operator*( ); }

	   iterator & operator++ ( )
	   {
		  current = current->next;
		  return *this;
	   }

	   iterator operator++ ( int )
	   {
		  iterator old = *this;
		  ++( *this );
		  return old;
	   }

    protected:
	   iterator( Node *p ) : const_iterator( p )
	   { }

	   friend class List<Object>;
    };

public:
    List( )
    { init( ); }

    ~List( )
    {
	   clear( );
	   delete head;
	   delete tail;
    }

    List( const List & rhs )
    {
	   init( );
	   *this = rhs;
    }

    const List & operator= ( const List & rhs )
    {
	   if( this == &rhs )
		  return *this;
	   clear( );
	   for( const_iterator itr = rhs.begin( ); itr != rhs.end( ); ++itr )
		  push_back( *itr );
	   return *this;
    }

    iterator begin()
    { return iterator(head->next);}
    const_iterator begin() const
    { return const_iterator(head->next);}
    iterator end()
    { return iterator(tail);}
    const_iterator end() const
    { return const_iterator(tail); }

    int size() const
    { return theSize; }
    bool empty() const
    { return size() == 0; }

    void clear()
    {
	   while(!empty())
		  pop_front();
    }

    Object & front( )
    { return *begin( ); }
    const Object & front( ) const
    { return *begin( ); }
    Object & back( )
    { return *--end( ); }
    const Object & back( ) const
    { return *--end( ); }
    void push_front( const Object & x )
    { insert( begin( ), x ); }
    void push_back( const Object & x )
    { insert( end( ), x ); }
    void pop_front( )
    { erase( begin( ) ); }
    void pop_back( )
    { erase( --end( ) ); }

    //// Insert x before itr.
    //iterator insert( iterator itr, const Object & x )
    //{
    //    itr.assertIsValid( );
    //    if( itr.theList != this )
    //        throw IteratorMismatchException( );
    //
    //    Node *p = itr.current;
    //    theSize++;
    //    return iterator( *this,
    //                     p->prev = p->prev->next = new Node( x, p->prev, p ) );
    //}

    // Insert x before itr.
    iterator insert( iterator itr, const Object & x )
    {
        Node *p = itr.current;
        theSize++;
        return iterator( p->prev = p->prev->next = new Node( x, p->prev, p ) );
    }

    // Erase item at itr.
    iterator erase( iterator itr )
    {
	   Node *p = itr.current;
	   iterator retVal( p->next );
	   p->prev->next = p->next;
	   p->next->prev = p->prev;
	   delete p;
	   theSize--;

	   return retVal;
    }

    iterator erase( iterator start, iterator end )
    {
	   for( iterator itr = from; itr != to; )
		  itr = erase( itr );

	   return to;
    }

private:
    int   theSize;
    Node *head;
    Node *tail;

    void init( )
    {
	   theSize = 0;
	   head = new Node;
	   tail = new Node;
	   head->next = tail;
	   tail->prev = head;
    }
};

#endif