garbage in function parameter

[Reza Amiri]

Hi,

I have designed a linked list with an Iterator to access the nodes of this list in C++. When I call a section of my code that exercises the remove I get garbages in the fuction call parameter. The following is some excerpt of this code.

class ListIterator
{
public:
    ListIterator( const List* listPtr, ListNode *nodePtr );
private:
    const List* container;
    ListNode* currentNode;
/** Allow access of the private data to the following classes.*/    
friend class List;
 
};//end of ListIterator
 
 
class List {
public:
    List( );
    List( const List& Rhs );
ListIterator remove( ListIterator iter ) throw ( ListException );
private:
    ListNode* head;
    int size;
/** Allow access of the private data to the following classes. */
friend class ListIterator;
}; //end of List
 
class ListNode {
public:
    ListNode( );
    ListNode( const ListItemType&, ListNode* );
 
private:
    ListItemType item;
    ListNode* next;
/** Allow access of the private data to the following classes.*/
friend class List;    
friend class ListIterator; 
 
}; //end of ListNode
 
 
ListIterator
List::remove( ListIterator iter ) throw( ListException )
{
                /** Check for the correct container. */
    if ( iter.container == this )
    {
        /** Two iterators, prevIter is always behind remvIter.
          */
        ListIterator remvIter = begin( );
        ListIterator prevIter = begin( );
        /** Walk Through the list and find the item to remove. */
        while ( ( remvIter != iter ) && ( (remvIter + 1) != end( ) ) )
        {
            prevIter = remvIter;
            remvIter++;
        }
        /** found the item, remove it and link the nodes.
          * Also, set the iterator to the following node.
          */
        prevIter.currentNode->next = remvIter.currentNode->next;
        prevIter = remvIter + 1;
        size--;
        /** Because of dtor the head is updated.
          * Anytime an object is going out of scope, 
          * each node should be removed and therefore,
          * the head proceeds forward.
          */
        if ( remvIter == begin( ) )
        {
            head = prevIter.currentNode;
        }
        /** guard for memory leak. */
        remvIter.currentNode->next = NULL;
        delete remvIter.currentNode;
 
        /** send an iterator to an item after the removed one. */
        return prevIter;
    }
    else
       throw ListException( "ListException: remove has bad iterator value." );
} //end of remove( )
 
int main( void )
{
         List aList;
         ListIterator anIter = aList.begin( );
 
         for( int j = 1; j <= 2; j++ )
              anIter = aList.insert( anIter, j );
 
        /** Exercise remove method. */
            anIter = aList.begin( );
            anIter++;
            aList.remove( anIter );
 
} //end of main
 

In this code excerpt, I have depsited some integer value into the list and I like to remove the second element from the list.

When aList.remove is called and passed by value, on its return there is some garbage deposited into this anIter. It does not make sense to me. I thought in C or C++ if a function is passed by value, the content of that value of anIter on returned is nont changed. In this case, the content of anIter is garbage.

I like to get your help please.

Thanks,

Reza

[sicarie]

Do you have an implementation of the begin() function?

[weaknessforcats]

This is for a course you are taking, right??

I hope so since there is already a list template in the C++ Standard LIbrary.

The danger of writing a class like this is that after all the work you may want to take it out on the road and use it on a real job. Then all of use are stuck with it forever.