So the assignment is to create a Sorted Linked List, not doubly, and not using a tail. I am using a SortedListNode Struct in the private area of the SortedList class. I think this is causing problems. I have the logic, and I was on the verge of succeeding, but then I got stuck with this. I never had to overload == or < or > for a Struct item, within a Class. (and one main requirement is that I do not use a helper function within my insert or remove functions)

The SortedList will eventually accept a string word, and compare it (while doing insert) to the cur one, to determain where to put it. (for this I am converting it to char, and then doing strcmpi)
but the main problem right now is that I think I don't know how to overload the Struct within the Class as a friend. I know there is more than one option, and not use a friend, but I will probably encounter the same problem with the syntax.

Here is my code:

#include <iostream>
#include <cstring>
#include <string>
#include <cstddef>//for NULL
using namespace std;

class SortedList
{
private:
	
	struct SortedListNode
	{
		string word;//holds within the word in the node
		SortedListNode* next;//pointer to next node
	};
	
	int size;//number of nodes (words) in the sorted list
	
	SortedListNode* head;//pointer to the sorted linked list of words

	//optional: SortedListNode* tail;//pointer to th
	
	//SortedListNode* locatePosition(string aWord, 

public:
	
	SortedList();
	
	~SortedList();

	bool sortedIsEmpty()const;

	int sortedGetLength()const;
	
	void sortedInsert(string newWord);

	void sortedRemove(string oldWord); 
	
	void sortedRetrieve(int index, string& theWord)const;

    friend bool operator==(const SortedListNode& wordA, const SortedListNode& wordB);
};

SortedList::SortedList(): size(0), head(NULL)
{}

SortedList::~SortedList() 
{
	delete head;//and not to forget, use size to walk through the sorted list and delete all Nodes
}

bool SortedList::sortedIsEmpty() const
{
	return size;//if size is 0, it returns 0, if size is any other number- it returns 1
}

int SortedList::sortedGetLength()const
{
	return size;
}

void SortedList::sortedInsert(string newWord)
{
	SortedListNode* newNodePtr = new SortedListNode;
	newNodePtr->next = NULL;
	newNodePtr->word = newWord;
	
	if(size==0)//insertion at beginning of List
	{
		newNodePtr->next = head;
		head = newNodePtr;
		size++;
	}
	else//insertion not at beginning of list
	{
		SortedListNode* prev = NULL;
		SortedListNode* cur = head;
		//for(; cur->next != NULL; prev = cur, cur = cur->next);//for(int i = size; i <= size; i++)
		//{ 
			//if (newNodePtr->word == cur->word); //throw exception- already present

			//if (newNodePtr->word > cur->word) 
			//{
			//	if(cur->next = NULL);// then its the last one on list- insert here 
		//	}
			//else
			//{
				//advance by 1 more node
		//	}
			
			//if newNodePtr->word < cur->word then prev->next = newNodePtr and newNodePtr->next = cur (insert new node here)
		

	
		//}
	}
}

bool SortedList::operator==(const SortedListNode*& wordA, const SortedListNode*& wordB)
{
	string first = wordA->word;
	string second = wordB->word;
	const char* forFirst = first.c_str();
	const char* forSecond = second.c_str();
	return strcmpi(forFirst, forSecond);
}

1) get rid of strcmpi() C function. See my version of the == operator below.
2) add #include <algorithm> for the transform() function

3) The friend function is not part of the class, so it has to reference the SortedListNode by SortedList::SortedListNode

#include <iostream>
#include <cstring>
#include <string>
#include <cstddef>//for NULL
#include <algorithm>
using namespace std;

class SortedList
{
private:
	
	struct SortedListNode
	{
		string word;//holds within the word in the node
		SortedListNode* next;//pointer to next node
	};
	
	int size;//number of nodes (words) in the sorted list
	
	SortedListNode* head;//pointer to the sorted linked list of words

	//optional: SortedListNode* tail;//pointer to th
	
	//SortedListNode* locatePosition(string aWord, 

public:
	
	SortedList();
	
	~SortedList();

	int sortedIsEmpty()const;

	int sortedGetLength()const;
	
	void sortedInsert(string newWord);

	void sortedRemove(string oldWord); 
	
	void sortedRetrieve(int index, string& theWord)const;

// Note:  if you want to pass pointers to this function
// then change it to * instead of &, but not both.
    friend bool operator==(const SortedList::SortedListNode& wordA, const SortedList::SortedListNode& wordB); 
};

SortedList::SortedList(): size(0), head(NULL)
{}

SortedList::~SortedList() 
{
	delete head;//and not to forget, use size to walk through the sorted list and delete all Nodes
}

int SortedList::sortedIsEmpty() const
{
    return size;//if size is 0, it returns 0, if size is any other number- it returns 1
}

int SortedList::sortedGetLength()const
{
	return size;
}

void SortedList::sortedInsert(string newWord)
{
	SortedListNode* newNodePtr = new SortedListNode;
	newNodePtr->next = NULL;
	newNodePtr->word = newWord;
	
	if(size==0)//insertion at beginning of List
	{
		newNodePtr->next = head;
		head = newNodePtr;
		size++;
	}
	else//insertion not at beginning of list
	{
		SortedListNode* prev = NULL;
		SortedListNode* cur = head;
		//for(; cur->next != NULL; prev = cur, cur = cur->next);//for(int i = size; i <= size; i++)
		//{ 
			//if (newNodePtr->word == cur->word); //throw exception- already present

			//if (newNodePtr->word > cur->word) 
			//{
			//	if(cur->next = NULL);// then its the last one on list- insert here 
		//	}
			//else
			//{
				//advance by 1 more node
		//	}
			
			//if newNodePtr->word < cur->word then prev->next = newNodePtr and newNodePtr->next = cur (insert new node here)
		

	
		//}
	}
}


// Note:  See my node in the class above.
bool operator==(const SortedList::SortedListNode& wordA, const SortedList::SortedListNode& wordB)
{
    string a = wordA.word;
    string b = wordB.word;
    transform(a.begin(), a.end(), a.begin(), toupper);
    transform(b.begin(), b.end(), b.begin(), toupper);
    return a == b ? true : false;
}

1) get rid of strcmpi() C function. See my version of the == operator below.
2) add #include <algorithm> for the transform() function

3) The friend function is not part of the class, so it has to reference the SortedListNode by SortedList::SortedListNode

#include <iostream>
#include <cstring>
#include <string>
#include <cstddef>//for NULL
#include <algorithm>
using namespace std;

class SortedList
{
private:
	
	struct SortedListNode
	{
		string word;//holds within the word in the node
		SortedListNode* next;//pointer to next node
	};
	
	int size;//number of nodes (words) in the sorted list
	
	SortedListNode* head;//pointer to the sorted linked list of words

	//optional: SortedListNode* tail;//pointer to th
	
	//SortedListNode* locatePosition(string aWord, 

public:
	
	SortedList();
	
	~SortedList();

	int sortedIsEmpty()const;

	int sortedGetLength()const;
	
	void sortedInsert(string newWord);

	void sortedRemove(string oldWord); 
	
	void sortedRetrieve(int index, string& theWord)const;

// Note:  if you want to pass pointers to this function
// then change it to * instead of &, but not both.
    friend bool operator==(const SortedList::SortedListNode& wordA, const SortedList::SortedListNode& wordB); 
};

SortedList::SortedList(): size(0), head(NULL)
{}

SortedList::~SortedList() 
{
	delete head;//and not to forget, use size to walk through the sorted list and delete all Nodes
}

int SortedList::sortedIsEmpty() const
{
    return size;//if size is 0, it returns 0, if size is any other number- it returns 1
}

int SortedList::sortedGetLength()const
{
	return size;
}

void SortedList::sortedInsert(string newWord)
{
	SortedListNode* newNodePtr = new SortedListNode;
	newNodePtr->next = NULL;
	newNodePtr->word = newWord;
	
	if(size==0)//insertion at beginning of List
	{
		newNodePtr->next = head;
		head = newNodePtr;
		size++;
	}
	else//insertion not at beginning of list
	{
		SortedListNode* prev = NULL;
		SortedListNode* cur = head;
		//for(; cur->next != NULL; prev = cur, cur = cur->next);//for(int i = size; i <= size; i++)
		//{ 
			//if (newNodePtr->word == cur->word); //throw exception- already present

			//if (newNodePtr->word > cur->word) 
			//{
			//	if(cur->next = NULL);// then its the last one on list- insert here 
		//	}
			//else
			//{
				//advance by 1 more node
		//	}
			
			//if newNodePtr->word < cur->word then prev->next = newNodePtr and newNodePtr->next = cur (insert new node here)
		

	
		//}
	}
}


// Note:  See my node in the class above.
bool operator==(const SortedList::SortedListNode& wordA, const SortedList::SortedListNode& wordB)
{
    string a = wordA.word;
    string b = wordB.word;
    transform(a.begin(), a.end(), a.begin(), toupper);
    transform(b.begin(), b.end(), b.begin(), toupper);
    return a == b ? true : false;
}

I tried, but it says:
1>MSVCRTD.lib(crtexe.obj) : error LNK2019: unresolved external symbol _main referenced in function ___tmainCRTStartup
1>C:\Users\Owner\Documents\Visual Studio 2008\Projects\Project1\testing\Debug\testing.exe : fatal error LNK1120: 1 unresolved externals

Hey, its your code, not mine. Where is the main() function ??? Didn't your teacher tell you that every c++ program needs a main() function.

oh my god! LOL I have it, but I forgot to put it in when I used your solution. Im checking it, and soon ill post. THANKS!!!!!

This article has been dead for over six months. Start a new discussion instead.