Creating the methods for class List
main.cpp
Code:#include "List.h"
int main( )
{
List la; // create list la
la.push_front( "mom" );
la.push_back( "please" );
la.push_back( "send" );
la.push_back( "money" );
la.push_front( "hi" );
cout << "\nla contains:\n" << la << '\n';
List lb( la ); // copy list la to lb
cout << "lb contains:\n" << lb << '\n';
lb.pop_front( );
lb.pop_front( );
lb.push_front( "mother" );
lb.push_front( "dear" );
lb.push_back( "Bubba" );
cout << "lb contains:\n" << lb << '\n';
List lc; // create list lc
lc.push_back( "money" );
lc.push_front( "send" );
cout << "\nlc contains:\n" << lc << '\n';
List ld; // create list ld
cout << "\nld contains nothing:\n" << ld << '\n';
ld.push_front( "hi" );
cout << "ld contains:\n" << ld << '\n';
ld.pop_front( );
cout << "ld contains nothing:\n" << ld << '\n';
ld.push_back( "hello" );
ld.push_back( "Bubba" );
cout << "ld contains:\n" << ld << '\n';
ld.pop_front( );
cout << "ld contains:\n" << ld << '\n';
ld.pop_front( );
cout << "ld contains nothing:\n" << ld << '\n';
List le( ld );
cout << "le contains nothing:\n" << le << '\n';
le.push_back( "last" );
cout << "le contains:\n" << le << '\n';
return 0;
}
List.h
Code:#include <iostream>
#include <iomanip>
#include <string>
using namespace std;
class Node
{
public:
// constructor
Node( const string &, Node *, Node * );
const string &get_word( ) const;// get a const reference to word
Node *get_next( ) const; // get a Node * (value of next)
Node *get_prev( ) const; // get a Node * (value of prev)
Node *set_next( Node * ); // set next to a new value
Node *set_prev( Node * ); // set prev to a new value
private:
string word;
Node *next;
Node *prev;
};
class List
{
public:
List( ); // constructor
List( const List & ); // copy constructor
~List( ); // destructor
// push a node to the back of list
void push_back( const string & );
// push a node to the front of list
void push_front( const string & );
// pop a node from the back of list
void pop_back( );
// pop a node from the front of list
void pop_front( );
// member function for the optional part
List &operator =( const List & );
// output a list object
friend ostream &operator <<( ostream &, const List & );
Node *begin( ) const; // pointer to beginning of the list
Node *end( ) const; // pointer to end of the list
class Iterator
{
public:
Iterator( Node * );
// same as word( )
const string &operator *( ) const;
void operator ++( ); // same as next( )
bool operator !=( Node * ) const;
private:
Node *current;
};
private:
Node *head;
Node *tail;
void copy_list( const List & );// copy a linked list
void delete_list( ); // delete a linked list
};
methods.cpp
Code:#include "List.h"
/**************************************methods for Node**************************************/
// constructor: init. a Node
Node::Node( const string &s, Node * n, Node * p )
{
word = s; // init. word with a copy of s
next = n; // next points to n
prev = p; // prev points to p
}
// return a const ref to word
const string &Node::get_word( ) const
{
return (*this).word;
}
// return a pointer to next node
Node *Node::get_next( ) const
{
return (*this).next;
}
Node *Node::get_prev( ) const
{
return (*this).prev;
}
// sets next to pointer n and return next
Node *Node::set_next( Node * n )
{
next = n; // next now points to n
return (*this).next;
}
// sets prev to pointer p and return prev
Node *Node::set_prev( Node * p )
{
prev = p; // prev now points to p
return (*this).prev;
}
/**************************************methods for List**************************************/
List::List( ) // constructor: init. head and tail
{
cout << "List::List( )\n";
head = tail = 0;
}
List::List( const List &rhs )// copy constructor
{
copy_list( rhs );
}
List::~List( ) // destructor: delete the list
{
cout << "List::~List( )\n";
delete_list( );
}
void List::copy_list( const List &rhs )
{
head = tail = 0;
// copy rhs' list into this
for( Node *p = rhs.begin(); p != end(); p = p->get_next( ) )
{
push_back( p->get_word( ) );
}
}
void List::push_back( const string &s )
{
// p points to a new node
Node *p = new Node( s, 0, tail );
if( tail == 0 ) // tail not pointing to a node yet?
{
head = tail = p; // head & tail point to new node in the list
}
else
{ // tail->next points to new node
tail->set_next( p );
tail = p; // tail points to last node in the list
}
}
void List::pop_back( )
{
if( tail ) // tail points to a node?
{
Node *tmp = tail;
tail = tail->get_prev( );
delete tmp; // delete node to be removed
if( tail == 0 ) // no more elements in the list?
{
head = 0;
}
else
{
tail->set_next( 0 );
}
}
}
void List::delete_list( ) // delete a linked list
{
// . . .
cout << "List::~List( )\n";
for( Node *p = head; p; )
{
Node *tmp = p; // remember current pointer
p = p->get_next( ); // advance p to the next Node
delete tmp; // deallocate tmp
cout << "deallocated\t" << tmp << "\tnext is\t" << p << '\n';
}
}
void List::push_front( const string &s )
{
// p points to a new node
Node *p = new Node( s, 0, head );
if( head == 0 ) // head not pointing to a node?
{
tail = head = p;
}
else
{ // tail->next points to new node
tail->set_next( p );
tail = p; // tail points to last node in the list
}
}
void List::pop_front( )
{
if ( head )
{
Node *tmp = head;
head = head->get_next( );
delete tmp; // delete node to be removed
if( tail == 0 ) // no more elements in the list?
{
head = 0;
}
else
{
tail->set_next( 0 );
}
}
}
// method for the optional
//List &List::operator =( const List &rhs )
//{
// head = tail = 0;
// // . . .
// if( this != &rhs ) // left and right objects are NOT the same?
// {
// delete [ ] this; // delete stack that belongs to left side object
//
// head = rhs.head;
// tail = rhs.tail;
// // now copy right side object to left side object
// for( Node *p = rhs.head; p; p = p->get_next( ) )
// {
// push_back( p->get_word( ) );
// }
// }
//
// return *this; // return a reference to left-hand side object
//}
ostream &operator <<( ostream &out, const List &list )
{
for( Node *p = list.head; p != 0; p = p->get_next( ) )
{
cout << p << '\t' << setw( 8 ) << p->get_word( )
<< '\t' << "next:" << '\t' << p->get_next( ) << '\n';
}
return out;
}
Node *List::begin( ) const // beginning of a linked list
{
return head;
}
Node *List::end( ) const // end of a linked list
{
return 0;
}
/**************************************methods for Iterator**************************************/
// constructor: init. an Iterator
List::Iterator::Iterator( Node * p )
{
current = p; // current points to p
}
// get a const ref to word
const string &List::Iterator::operator *( ) const
{
return current->get_word( );
}
// get a const ref to word
void List::Iterator::operator ++( )
{
if( current )
{
current = current->get_next( );
}
}
// current != p
bool List::Iterator::operator !=( Node * p ) const
{
return current != p;
}
Output should look like this:
List::List( )
la contains:
00000000 hi 00348750
00348990 mom 003487E0
00348750 please 00348870
003487E0 send 00348900
00348870 money 00000000
lb contains:
00000000 hi 00348CA8
00348A98 mom 00348D00
00348CA8 please 00348D90
00348D00 send 00348E20
00348D90 money 00000000
lb contains:
00000000 dear 00348A98
00348CA8 mother 00348D00
00348A98 please 00348D90
00348D00 send 00348E20
00348D90 money 00348EE8
00348E20 Bubba 00000000
List::List( )
lc contains:
00000000 send 00348F78
00349008 money 00000000
List::List( )
ld contains nothing:
ld contains:
00000000 hi 00000000
ld contains nothing:
ld contains:
00000000 hello 00349128
00349098 Bubba 00000000
ld contains:
00000000 Bubba 00000000
ld contains nothing:
le contains nothing:
le contains:
00000000 last 00000000
List::~List( )
deallocating 00349098 with last next is 00000000
List::~List( )
deallocating 00349128 with last next is 00000000
List::~List( )
deallocating 00349008 with send next is 00348F78
deallocating 00348F78 with money next is 00000000
List::~List( )
deallocating 00348CA8 with dear next is 00348A98
deallocating 00348A98 with mother next is 00348D00
deallocating 00348D00 with please next is 00348D90
deallocating 00348D90 with send next is 00348E20
deallocating 00348E20 with money next is 00348EE8
deallocating 00348EE8 with Bubba next is 00000000
List::~List( )
deallocating 00348750 with last next is 00000000
