Thread: SLList operator= overloading problems

Hi, ive been trying to get this operator= overload to work for a few days now..

this is my recent attempt... Think you could help me out. Thanx

Code:

SLList<Type> &operator= (const SLList<Type> &list)
    {
        if(this == &list)
           return *this;
        SLList<Type> temp = list;
        
        return temp;
    }

Well you are trying to return a reference to a local variable which is a big no no.
operator = should be setting the values of *this object to the values of list.

So you'd have to look at the internals of SSList and do something like:

Code:

  a = list.a;
  b = list.b;
  c = list.c;
// etc

Thanx, I understand that as far as basics, im not quite sure as to how, to apply this method, when working the "list" object, since its a dynamic SinglyLinked List;
i think i said that right.

or perhaps my error lies somewhere else. maybe this can help.

Code:

template <typename Type>
class SLLIter;

template <typename Type>
class SLList
{
private:
    struct Node
    {
        Type element;
        Node *next;
    };

    Node *head;

public:
    //SLList(void);
friend class SLLIter;
   

    // SLList : constructor.
    SLList ()
    {
        head = NULL;
    }
   
    // operator = : assignment operator.
    // NOTE : invalidates all iterators to this list.
    SLList<Type> &operator= (const SLList<Type> &list)
    {

        //if(this == &list)
        //    return *this;

          
        if(this == &list)
           return *this;
        else
        {
        *this = list;
        return *this;
        }
    }
    // addHead : append a new item to the front of the list.
    void addHead (const Type &v)
    {
        Node *temp = new Node;
        temp->element = v;
        temp->next = head;
        head = temp;
    }
    
    // clear : clear out the list
    void clear ()
    {
        while(head)
        {
            Node *temp = head->next;
            delete head;
            head = temp;
        }
    }
    
    // insert : place a new item directly before the index 
    //          passed in.  Do nothing on a bad iterator.
    // Note : iterator will point at the newly inserted 
    // 	     item after the function call.
    void insert (SLLIter<Type> &index, const Type &v)
    {
        Node *temp = new Node;
        temp->element = v;
        temp->next = head;
        head = temp;
        

    }
    
    // remove : remove (and delete) the item at the index 
    //          passed in.  Do nothing on a bad iterator.
    // Note : iterator will point at the item after the one 
    // 	     removed after the function call, or NULL (bad) if 
    //        the tail is the one removed.
    void remove (SLLIter<Type> &index)
    {



        Node *cur, *prev;
        // walk through all list items.
        for (prev = NULL, cur = head; cur; prev = cur, cur = cur->next)
        {  
            if (cur->element == index.curr->element)
            {
                // remove 'cur' from the list.
                if (prev == NULL)
                    // if we are removing the 1st node.
                    head = head->next;
                else
                    // good when cur is not the head.
                    prev->next = cur->next;

                delete cur;
                return;
            }
        }
       /*
        Node *temp = head;
        if(temp->element == index.curr->element)
        {
            if(index.prev == NULL)
            {
                index.prev = head->next;
                index.curr = index.prev->next;
                delete head;
                head = index.prev;
                return;
            }
            if(index.curr->next == NULL)
            {
                index.prev->next = NULL;
                delete index.curr;
                return;
            }
         temp = index.curr;
         index.prev->next = index.curr->next;
         index.curr = index.curr->next;
         delete temp;
         return;
        
        }
*/
       



        
        /*   
            Node *temp, *pNode;
            temp = head;
            pNode = NULL;
            if(temp->element == index.curr->element)
            {
                if(pNode == NULL)
                {
                    pNode= head->next;
                    delete head;
                    head = pNode;
                    return;
                }
                else if (pNode !=NULL)
                {
                    pNode->next = temp->next;
                    delete temp;
                    return;
                }

            }
            else if (temp->element != index.curr->element)
            {
                pNode = temp;
                temp = temp->next;
            }

*/

        

        
    }
    
    // How to declare a node pointer of a structure declared
    // within another template class
    // ‘typename’ syntax needed b/c A* B can be interpreted as
    // multiply instead of a pointer declaration w/ templates
    typename SLList<Type>::Node* location;


    virtual ~SLList(void)
    {

        clear();
    }
};




template <typename Type>
class SLLIter
{

public:
friend class SLList<Type>;
typename SLList<Type>::Node *curr;
//typename SLList<Type>::Node *prev;
    // SLLIter Public Interface
SLList<Type> * list;

    // SLLIter : constructor.
SLLIter (SLList<Type> &listToIterate){ list = &listToIterate;}
    // ~SLLIter : destructor.
virtual ~SLLIter (){}
    // begin : move the iterator to the front of the list
void begin (){curr = list->head;}
    // end : only return true when iterator is beyond the last 
    //       item
    bool end ()
    {
    if(curr == NULL)
        return true;
    else
        return false;
    }
    // operator++ : prefix (only) ++ operator
    SLLIter<Type> &operator++ ()
    {
        
        //if(curr)
        //{   
           curr = curr->next;
           return *this;
    
        //}
    }
    // current : extract the element at the current location.
    Type &current () {return curr->element;}
    
};

Code:

        if(this == &list)
           return *this;
        else
        {
        *this = list;
        return *this;
        }

You are defining the assignment operator in terms of itself. Do as Thantos suggested and copy the internals of the List. In your case, you must copy the linked list, so set this->head equal to a copy of list.head, then set this->head->next equal to a copy of list.head->next, and so on. You would probably want to use a loop of some sort to traverse the list and copy its data into the this object.

Thanx for all the help i got it squared away had to re-write the whole thing...
{thats why you don't code when half-asleep} :P


wow i didn't realize the code was so lengthy

A return value that you might want to use is bool to return success or failure.

operator= should never fail. Only exception to this is if you had dynamically allocated memory then if allocating fails then you should throw an exception. The operator= should return the same type of as the object (basically return *this).

If you don't then you wouldn't be able to use = like you could with built in types (ie)

Code:

MyClass x = y = v = z = w;

This is the new and improved operator= overload i came up with. works great. thanx again for the help..

Code:

SLList<Type> &operator= (const SLList<Type> &list)
    {
        if (this == &list)
            return *this;
        
        
        this->clear();

        Node * temp = list.head;
        SLLIter<Type> ait (*this);
        ait.begin();
        while(temp)
        {
            
            insert(ait,temp->element);
             ++ait;
            temp = temp->next;
        }
        return *this;
     }