What am I doing wrong here? Several "no match for operator" errors in my compile

Question

These seem to be my only errors. From my understanding, I only needed to overload an operator if I was setting "sortedListClass" equal to another declared "sortedListClass" or if I was asking if they were less than, equal to, not equal to, etc.. but these are user declared... not declared "sortedListClasses" so im confused.. can anyone shed light on these compilation errors? Thanks!

I'll include all of the code I have incase any of it has significance to the errors...

Basically I am dealing with linked lists with structs and pointers..

here is my list.h:

#ifndef LIST_H
#define LIST_H

struct cities
{
    string city;    
};
typedef cities listItemType;
typedef struct Node* nodePtr;
struct Node
{
    listItemType data;
    nodePtr next;
};

#endif

here is my sortedListClass.h :

#include <iostream>
#include <fstream>

using namespace std;

#include "list.h"


#ifndef sortedList_Class
#define sortedList_Class

class sortedListClass
{

    private:
        int size;
        nodePtr Head;

    public:
        //Constructors and Destructor
        sortedListClass();
        sortedListClass(const sortedListClass& L);
        ~sortedListClass();

        //List operations
        void ListInsert(listItemType NewItem);
        void ListDelete();
        void RetrieveCity();
        void PrintList();
        int ListLength() const;
        bool ListIsEmpty() const;
}; //End Class
#endif

and here is my sortedListClass.cpp :

//Sorted List Class
//Contains function definitions for actions towards the cities Linked List

#include "sortedListClass.h"
#include <iostream>
#include <cstdlib>
#include <string>

sortedListClass::sortedListClass()
{
    size = 0;
    Head = NULL;
}

sortedListClass::sortedListClass(const sortedListClass& List)
{
    if(List.Head == NULL)
        Head = NULL;
    else
    {
        Head = new Node;
        Head->data = List.Head->data;

        nodePtr NewPtr = Head;

        for(nodePtr OrigPtr = List.Head -> next; OrigPtr != NULL; OrigPtr = OrigPtr-> next)
        {
            NewPtr-> next = new Node;
            NewPtr = NewPtr -> next;
            NewPtr -> data = OrigPtr -> data;
        }
            NewPtr -> next = NULL;
    }
}

sortedListClass::~sortedListClass()
{
    bool success;
    while(!ListIsEmpty())
        ListDelete();
}

bool sortedListClass::ListIsEmpty() const
{
    return bool( size == 0);
}

int sortedListClass::ListLength() const
{
    return size;
}

void sortedListClass::RetrieveCity()
{
    string city;
    bool success;
    cout <<"Input a city name: ";
    cin >> city;
    cout << endl;
    nodePtr cur = Head;
    while(cur != NULL)
    {
        if(cur->data == city)
        {
            cout <<"This city is found" << endl;
            success = true;
        }
        cur = cur->next;
    }
    if(!success)
        cout <<"This city is not served" << endl;

}

void sortedListClass::PrintList()
{
    nodePtr cur = Head;
    cout << "Number of cities: " << size << endl;
    while(cur!= NULL)
    {
        cout <<cur->data;
        cur = cur->next;
    }
}

void sortedListClass::ListInsert(listItemType Item)
{
    nodePtr newNode = new Node;
    newNode -> data = Item;
    newNode->next = NULL;
    if(Head = NULL)
        Head = newNode;
    else if (Item < Head->data)
    {
        newNode->next = Head;
        Head = newNode;
    }

    nodePtr curr = Head, prev = Head;
    while((newNode->data > curr->data) && (curr != NULL))
    {
        prev = curr;
        curr = curr -> next;
    }

    if(curr->next == NULL)
    {
        curr->next = newNode;
        newNode->next = NULL;
    }
    else if(curr->data > newNode->data)
    {
        newNode->next = curr;
        prev->next = newNode;
    }
}

void sortedListClass::ListDelete()
{
    bool success = false;
    string city;
    cout << "Enter a city name to delete from the list: " << endl;
    cin >> city;
    nodePtr p = new Node;
    nodePtr curr, prev;
    curr = Head;
    prev = Head;
    p -> data = city;
    p -> next = NULL;
    if(Head == NULL)
        cout <<"Unable to delete anything, list is empty." << endl;
    else
    {
        while(curr->next != NULL)
        {
            if(curr -> data == p -> data)
            {
                prev->next = curr->next;
                curr->next = NULL;
                delete curr;
                curr = NULL;
                success = true;
            }
            else
            prev = curr;
            curr = curr->next;
        }
    }
    if(!success)
        cout <<"This city does not exist. Deletion cannot be performed." << endl;

}

and here is the errors I am getting...

sortedListClass.cpp: In member function ‘void sortedListClass::RetrieveCity()’:
sortedListClass.cpp:63: error: no match for ‘operator==’ in ‘cur->Node::data == city’
sortedListClass.cpp: In member function ‘void sortedListClass::PrintList()’:
sortedListClass.cpp:81: error: no match for ‘operator<<’ in ‘std::cout << cur->Node::data’
/usr/include/c++/4.4/ostream:108: note: candidates are: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ostream<_CharT, _Traits>& (*)(std::basic_ostream<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/ostream:117: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ios<_CharT, _Traits>& (*)(std::basic_ios<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/ostream:127: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::ios_base& (*)(std::ios_base&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/ostream:165: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/ostream:169: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/ostream:173: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(bool) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/bits/ostream.tcc:91: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(short int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/ostream:180: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(short unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/bits/ostream.tcc:105: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/ostream:191: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/ostream:200: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long long int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/ostream:204: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long long unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/ostream:209: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(double) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/ostream:213: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(float) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/ostream:221: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long double) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/ostream:225: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(const void*) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.4/bits/ostream.tcc:119: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_streambuf<_CharT, _Traits>*) [with _CharT = char, _Traits = std::char_traits<char>]
sortedListClass.cpp: In member function ‘void sortedListClass::ListInsert(listItemType)’:
sortedListClass.cpp:93: error: no match for ‘operator<’ in ‘Item < ((sortedListClass*)this)->sortedListClass::Head->Node::data’
sortedListClass.cpp:100: error: no match for ‘operator>’ in ‘newNode->Node::data > curr->Node::data’
sortedListClass.cpp:111: error: no match for ‘operator>’ in ‘curr->Node::data > newNode->Node::data’
sortedListClass.cpp: In member function ‘void sortedListClass::ListDelete()’:
sortedListClass.cpp:128: error: no match for ‘operator=’ in ‘p->Node::data = city’
list.h:5: note: candidates are: cities& cities::operator=(const cities&)
sortedListClass.cpp:136: error: no match for ‘operator==’ in ‘curr->Node::data == p->Node::data’
[1]+  Done                    scite sortedListClass.cpp

Answer 1

I only needed to overload an operator if I was setting "sortedListClass" equal to another declared "sortedListClass" or if I was asking if they were less than, equal to, not equal to, etc

You're doing those things with listItemType, and never created any operators for it.

See how it's complaining about expressions such as ‘cur->Node::data == city’? The left-hand side has type listItemType, and the right-hand side has type std::string. The compiler has no idea what you want it to do with those two things.

Similarly:

error: no match for ‘operator>’ in ‘newNode->Node::data > curr->Node::data’

Both sides of that expression have type listItemType. You need to define operator> for that type.

I realise that the error output is verbose and complex, but all the information you need is in there somewhere!