SO new to C++

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;
};

---

If it helps the compiler gives me:

Code:

---

error C2440: 'return' : cannot convert from 'const LLNode' to 'LLNode *'

---

when I try to compile.

Since you need to return a pointer you should return a pointer. LLRoot is a pointer, so return it.

With:

Code:

---

//!  @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;
        }

---

I get:

Code:

---

error C2440: 'return' : cannot convert from 'const LLNode' to 'LLNode *'

---

Okay so I skimmed, and you managed to implement LLRoot as a Node itself, not a Node *. In that case, you would need to return the address of LLRoot, by returning &LLRoot.

However, in my defense, it is impossible to get the error message you stated from the code you posted. If LLRoot is not a Node *, but a Node, as you have it defined, then trying to do *Node is a syntax error

Code:

---

error: no match for ‘operator*’ in ‘*((const LinkedList*)this)->LinkedList::LLRoot'

---

since you cannot follow a pointer if the thing you are trying to follow is not, in fact, a pointer.

If you don't intend to allow modifications to the node that you return then you'll need to return a const pointer. Otherwise you'll need to make the method non-const.