Benutzerdefinierte Datentypen in doppelt verknüpfter Liste

Question

Ich versuche, einen benutzerdefinierten Datentyp in einer doppelt verknüpften Liste zu verwenden.Ich kann die Liste erstellen, aber wenn ich versuche, die Einfügefunktion aufzurufen, tritt ein Fehler auf.Was verursacht diesen Fehler?

wichtigsten.cpp:

#include "command.h" //my custom class 
#include "doublyLinkedList.h"
int main(){

    //create a queue of jobs:
    doublyLinkedList<command>* queue = new doublyLinkedList<command>;

    //creating a new command:
    command *c = new command();
    c->createCommand();
    c->print();
    const command *d = new command(c->name, c->description, c->shellString);

    queue->insert(*d); //problem line
};

Doppelt verknüpfte Liste.einfügefunktion von h:

template <class Type>
void doublyLinkedList<Type>::insert(const Type& insertItem)
{
nodeType<Type> *current;      //pointer to traverse the list
nodeType<Type> *trailCurrent; //pointer just before current
nodeType<Type> *newNode;      //pointer to create a node
bool found;

newNode = new nodeType<Type>; //create the node
newNode->info = insertItem;  //store the new item in the node
newNode->next = NULL;
newNode->back = NULL;

if(first == NULL) //if the list is empty, newNode is 
                  //the only node
{
   first = newNode;
   last = newNode;
   count++;
}
else
{
    found = false;
    current = first;

    while (current != NULL && !found) //search the list
        if (current->info >= insertItem)
            found = true;
        else
        {
            trailCurrent = current;
            current = current->next;
        }

    if (current == first) //insert newNode before first
    {
        first->back = newNode;
        newNode->next = first;
        first = newNode;
        count++;
    }
    else
    {
          //insert newNode between trailCurrent and current
        if (current != NULL)
        {
            trailCurrent->next = newNode;
            newNode->back = trailCurrent;
            newNode->next = current;
            current->back = newNode;
        }
        else
        {
            trailCurrent->next = newNode;
            newNode->back = trailCurrent;
            last = newNode;
        }

        count++;
    }//end else
}//end else
}//end insert

Der Code funktioniert für Ints und Strings, aber nicht für "Befehls" -Typen.

Fehlermeldung:

In file included from main.cpp:2:0:
doublyLinkedList.h: In member function âvoid doublyLinkedList<Type>::insert(const Type&) [with Type = command]â:
main.cpp:34:18:   instantiated from here
doublyLinkedList.h:171:13: error: no match for âoperator>=â in âcurrent->nodeType<command>::info >= insertItemâ
doublyLinkedList.h:171:13: note: candidates are:
/usr/include/c++/4.6/bits/stl_pair.h:232:5: note: template<class _T1, class _T2> bool std::operator>=(const std::pair<_T1, _T2>&, const std::pair<_T1, _T2>&)
/usr/include/c++/4.6/bits/stl_iterator.h:315:5: note: template<class _Iterator> bool std::operator>=(const std::reverse_iterator<_Iterator>&, const std::reverse_iterator<_Iterator>&)
/usr/include/c++/4.6/bits/stl_iterator.h:365:5: note: template<class _IteratorL, class _IteratorR> bool std::operator>=(const std::reverse_iterator<_IteratorL>&, const std::reverse_iterator<_IteratorR>&)
/usr/include/c++/4.6/bits/basic_string.h:2621:5: note: template<class _CharT, class _Traits, class _Alloc> bool std::operator>=(const std::basic_string<_CharT, _Traits, _Alloc>&, const std::basic_string<_CharT, _Traits, _Alloc>&)
/usr/include/c++/4.6/bits/basic_string.h:2633:5: note: template<class _CharT, class _Traits, class _Alloc> bool std::operator>=(const std::basic_string<_CharT, _Traits, _Alloc>&, const _CharT*)
/usr/include/c++/4.6/bits/basic_string.h:2645:5: note: template<class _CharT, class _Traits, class _Alloc> bool std::operator>=(const _CharT*, const std::basic_string<_CharT, _Traits, _Alloc>&)

Answer 1

Anscheinend versuchen Sie, die Liste sortiert zu halten, haben jedoch keine Vergleichsoperatoren für definiert command.Sie müssen implementieren operator>= für Ihren Typ, wenn Sie ihn so verwenden möchten, wie er ist.

Die Signatur könnte wahrscheinlich ungefähr so aussehen:

bool operator>= (const command& a, const command& b);