C++ Linked List Sort a List as It's Being Created?

[Propellent]

This is part of the header

class LinkedList 
{ 
public: 
struct ListNode 
{ 
public: 
ListNode( const string& theString, ListNode* pNext = NULL ) 
{ 
word = theString; 
pNextNode = pNext; 
} 

string word; 
ListNode* pNextNode; 
}; 

public: 
LinkedList();//default constructor, written 
~LinkedList();//destructor, written 

//Given a word, place it in alphabetical position, in the Linked List
void addWord( const string& theWord );//create new node w/ string, add to linked list, help 
//Pulls words from a file one by one and passes them to addWord
void addWords( const string& filename );//Not written, but will call addWord in a loop 
//remove the first instance of a word in the linked list
void removeWord( const string& theWord );//Not written, plan to do myself 
//remove every instance of a given word in the linked list
void removeAllInstancesOfWord( const string& theWord );//Not written, plan to do myself 
//Remove all nodes and cleanup after them
void clear();// Written 

void printReport( ostream& out ) const; 

private: 
ListNode* mpHead; 

void removeEnd();//Written 
};

this is the function I'm having trouble with

void LinkedList::addWord( const string& theWord )
{
	ListNode* pCurr = mpHead;
	ListNode* pPrev = NULL;

	while(pCurr->pNextNode != NULL)
	{
		if(pCurr->word > theWord)
		{
			if(!pCurr->pNextNode)
			{
				ListNode* node = new ListNode(theWord);
					
				pCurr->pNextNode = node;
			}
			else
			{
				pCurr = pCurr->pNextNode;


			}
		}
		
		pPrev = pCurr;
		pCurr = pCurr->pNextNode;
	}
}

This is the cpp that I've been working on

#include "LinkedList.h"
#include <fstream>
#include <sstream>
#include <iostream>

using namespace std;

LinkedList::LinkedList()
{
	mpHead = NULL;
}

LinkedList::~LinkedList()
{
	clear();
}

//add a word to the list in the proper position alphabetically
void LinkedList::addWord( const string& theWord )
{
	ListNode* pCurr = mpHead;

	if(mpHead)
	{	
		while(pCurr->pNextNode != NULL)
			pCurr = pCurr->pNextNode;

		ListNode* newNode = pCurr->pNextNode;

		pCurr->pNextNode = newNode;
		newNode->word = theWord;
	}
	else
		mpHead->word = theWord;

	cout << "right before sortList";

	//sortList();
}

//add all words in the file referred to by filename - add them alphabetically
void LinkedList::addWords( const string& filename )
{
	ifstream inFile;
	string temp, temp2;
	ListNode* pCurr = mpHead;

	while(!inFile.eof())
	{
		inFile >> temp;

		if(!mpHead)
			pCurr->word = temp;

		while(pCurr->pNextNode != NULL)
			pCurr = pCurr->pNextNode;

		ListNode* newNode = pCurr->pNextNode;
		newNode->word = temp;
	}

	sortList();
}

//remove the first instance of theWord in the list (and delete it)
void LinkedList::removeWord( const string& theWord )
{
	ListNode* pCurr = mpHead;
	ListNode* pPrev = NULL;

	if(!pCurr)
	{
		pCurr = mpHead->pNextNode;
	}
	else
	
	while( pCurr != NULL )
	{
		if(pCurr->word == theWord)
		{
			pPrev->pNextNode = pCurr->pNextNode;

			if(!pCurr->pNextNode)
			{
				pPrev->pNextNode = NULL;

				delete pCurr;
			}

			break;
		}

		pPrev = pCurr;
		pCurr = pCurr->pNextNode;
	}
}

//remove all instances of theWord in the list (and delete them)
void LinkedList::removeAllInstancesOfWord( const string& theWord )
{
	bool found = false;
	ListNode* pCurr = mpHead;


	while( pCurr != NULL )
	{
		if(pCurr->word == theWord)
			removeWord(theWord);
		
		pCurr = pCurr->pNextNode;
	}
}

//remove all words from the list (and delete them)
void LinkedList::clear()
{
	while(mpHead)
	{
		removeEnd();
	}
}

void LinkedList::printReport( ostream& out ) const
{
	ListNode* pCurrent = mpHead;
	out << "List contains: ";
	while( pCurrent != NULL )
	{
		out << pCurrent->word << " ";
		pCurrent = pCurrent->pNextNode;
	}

	out << " EOL\n";
}

void LinkedList::removeEnd()
{
	if ( mpHead )
    {
       ListNode* pCurr = mpHead;
       ListNode* pPrevPtr = NULL;

       while ( pCurr->pNextNode != NULL)
       {
          pPrevPtr = pCurr;
          pCurr = pCurr->pNextNode;
       }

       delete pCurr;

       if ( pPrevPtr ) 
		   pPrevPtr->pNextNode = NULL;

       else 
		   mpHead = pPrevPtr; 
    }
}

void LinkedList::sortList()
{
	bool swap = true,
		 end = false;

	string temp = "";

	ListNode* pCurr = mpHead;

	while(swap)
	{
		while(!end)
		{
			if(pCurr->word < pCurr->pNextNode->word)
			{
				temp = pCurr->word;
				pCurr->word = pCurr->pNextNode->word;
				pCurr->pNextNode->word = temp;
			}
			else if(!pCurr->pNextNode)
				end = true;

			if(temp == "")
				swap = false;

			temp = "";
		}
	}
}

[ResidentBiscuit]

What exactly is the issue you're having?

[Propellent]

The fact that I get runtime errors when I call it

[firedraco]

Did you try to use a debugger to determine the state of the program and what line it crashes on?

[kannanmj]

Please explain (add a header comment) to the addword function so that one can understand the logic behind it and provide you with the right fix.

> 3 ListNode* pCurr = mpHead;
Is mpHead always non-NULL here?

> 1 void LinkedList::addWord( const string& theWord )
Is the function complete? I don't think so. For example:

> 8 if(pCurr->word > theWord)
What happens if "theWord" is greater than any of the existing words in the list? Function addWord does not insert(modify) the list?

[Propellent]

@ kannanmj

mpHead is only null when the list is first created, that is until the first word is added

addWord is not complete by any means and is the function I need help with

[kannanmj]

23 if(mpHead)
. .
33 else
34 mpHead->word = theWord;

At line 34, mpHead is NULL and it is being used to access a member of the object (non-existing) it is pointing to. This will lead to run-time error.