I feel bad submitting such a novice question but I really am having a hard time with this linked list program I am working on. My main question is what I'm doing wrong on the function in red. As a side note, if you see anything else that I've done that is incorrect, please feel free to comment! I'm a good java programmer and am trying to learn C++. So if that background helps, feel free to use it! Thanks in advance for the help!
-Dustin
Code:
#include <string>
//! LLNode implements a doubly-linked list node
class LLNode {
friend class LinkedList; //!< LinkedList can access private members of LLNode
public:
//! Constructor
LLNode(const std::string & v, LLNode * p, LLNode * n) :
value(v), prev(p), next(n)
{
}
//! Copy Constructor SHALLOW COPY and does not free memory
//!Feel free to change this function(IE, to a deep copy).
LLNode(const LLNode & other) :
value(other.value),prev(other.prev),next(other.next)
{
}
//! Read-only public methods for use by clients of the LinkedList class
const std::string & GetValue() const
{
return value;
}
LLNode * GetPrevious()const
{
return prev;
}
LLNode * GetNext()const
{
return next;
}
//! Assignment operator makes a SHALLOW COPY and does not free memory
//!Feel free to change this function(IE, to a deep copy).
LLNode & operator=(const LLNode & other)
{
if(this!=&other)
{
value=other.value;
prev=other.prev;
next=other.next;
}
return *this;
}
private:
std::string value; //!< value stored in the node
LLNode * prev; //!< pointer to previous node in the list
LLNode * next; //!< pointer to next node in the list
};
//! LinkedList implements a doubly-linked list
class LinkedList
{
public:
//! No-arg constructor. Initializes an empty linked list
LinkedList() : LLRoot("", NULL, NULL)
{ }
//! Copy constructor. Makes a complete copy of its argument
LinkedList(const LinkedList & other):LLRoot(other.LLRoot)
{ }
//! Destructor
~LinkedList();
//! Assignment operator. Makes a complete copy of its argument
//! @return A reference to oneself
LinkedList& operator =(const LinkedList & other)
{
return LinkedList(other);
}
//! @return true if the list is empty, or false if the list is not empty
bool IsEmpty() const
{
if(LLRoot.value=="")
return true;
return false;
}
//! Removes all values from the list
void Clear()
{
LLRoot.value="";
LLRoot.next=NULL;
}
//! @return the number of values in the list
int GetSize() const
{
int size=0;
LLNode LLCurrent(LLRoot);
while(LLCurrent.GetValue()!="" && LLCurrent.GetValue()!="\0")
{
size++;
LLCurrent = LLNode(*LLCurrent.next);
}
return size;
}
//! @return a pointer to the first node in the list, or NULL if the list is empty
LLNode * GetFirst()const
{
if(LLRoot.value=="")
return NULL;
return
*LLRoot;
}
//! @returns a pointer to the last node in the list, or NULL if the list is empty
LLNode * GetLast()const;
//! Inserts value v into the list after node n
//!
//! @param v The new value being inserted
//! @param n A node that is already in the list after which the new node should
//! be inserted.
//! If n is NULL, the new node should be inserted at the beginning of the list.
//!
//! @return a pointer to the newly inserted node
LLNode * Insert(const std::string & v, LLNode * n);
//! Searches for the first occurrence of value v that appears in the list
//! after node n
//!
//! @param v The value being searched for
//! @param n The node in the list after which the search should begin.
//! If n is NULL, the list should be searched from the beginning.
//!
//! @return a pointer to the node containing v, or NULL if v is not found
LLNode * Find(const std::string & v, LLNode * n) const;
//! Removes node n from the list
//!
//! @param n The node being removed from the list
void Remove(LLNode * n);
private:
LLNode LLRoot;
};