This is the generic list class that everything else is built on top of.

Inheritance:

Public Fields

typedef	vector : :reverse_iterator reverse_iterator
typedef	vector : :const_reverse_iterator const_reverse_iterator
typedef	vector : :const_iterator const_iterator
typedef	vector : :iterator iterator

Public Methods

void	AddToEnd (T k)
void	AddToEnd (List<T> &appendMe )
void	AlterCurrent (T k)
bool	AtEnd () const
bool	AtStart () const
T	Current ()
void	FreeList ()
void	Insert (List<T> &appendMe )
void	Insert (T k)
void	InsertAfter (List<T> &appendMe )
void	InsertAfter (T k)
T	Last () const
int	Length () const
	List ()
	List (const vector<T> & L)
	List (const List<T> & L)
bool	Lookup (T k)
void	MemorizeCurrent ()
void	Next ()
void	Prev ()
void	RemoveCurrent ()
void	Reset ()
void	RestoreCurrent ()
bool	SeekTo ( T obj )
List&	operator = (const List<T> & dl)

Public Members

typedef const value_type*	const_pointer
typedef const value_type&	const_reference
typedef size_t	difference_type
typedef value_type*	pointer
typedef value_type&	reference
typedef size_t	size_type
typedef T	value_type

Documentation

This is the generic list class that everything else is built on top of. Originally this was a linked list implementation, but that became cumbersome, so now it is a STL vector with some interface functions to envelope this fact. These interface functions are mostly there to just support backward compatability with older code that uses this class like it was a linked list.

Any of the methods listed here should be considered DEPRECIATED and therefore not to be used by any new programs writted from scratch.

For any new software written for this class, please restrict yourself to using this List class as if it were a STL vector class, and manipulate it that way.

List()

List(const List<T> & L)

List(const vector<T> & L)

void AddToEnd(T k)

void Insert(T k)

void InsertAfter(T k)

void AddToEnd(List<T> &appendMe )

void Insert(List<T> &appendMe )

void InsertAfter(List<T> &appendMe )

void FreeList()

void RemoveCurrent()

void AlterCurrent(T k)

void MemorizeCurrent()

void RestoreCurrent()

int Length() const

bool Lookup(T k)

bool SeekTo( T obj )

void Reset()

void Next()

void Prev()

bool AtEnd() const

bool AtStart() const

T Current()

T Last() const

List& operator = (const List<T> & dl)

typedef T value_type

typedef value_type* pointer

typedef const value_type* const_pointer

typedef value_type& reference

typedef const value_type& const_reference

typedef size_t size_type

typedef size_t difference_type

typedef vector: :iterator iterator

typedef vector: :const_iterator const_iterator

typedef vector: :reverse_iterator reverse_iterator

typedef vector: :const_reverse_iterator const_reverse_iterator

All of the following are modified a bit to deal with the myCurrent() index, but to the outside world they look like the normal vector operations:

All of the following are modified a bit to deal with the myCurrent() index, but to the outside world they look like the normal vector operations:

void insert( iterator pos, value_type* first, value_type* last )

void insert( iterator pos, size_type n, const T& x)

void erase( iterator pos )

void erase( iterator first, iterator last )

void reserve( size_t n )

size_t capacity( void )

All of the following work exactly as they do in the regular STL vector class:

All of the following work exactly as they do in the regular STL vector class:

iterator end()

reverse_iterator rbegin()

reverse_iterator rend()

const_iterator begin() const

const_iterator end() const

size_t size() const

bool empty() const

T& operator[]( size_type n )

const T& operator[]( size_type n) const

T& front()

const T& back() const

const T& front() const

T& back()

Direct child classes:

ASTlist

Alphabetic index HTML hierarchy of classes or Java