selbstgebaute c++ liste

Servus @ all,

ich hab ein kleines Problem mit ner selbstgebauten, rekursiven generischen Liste. Genauer gesagt geht es um die merge-Methode. Bekomme das Teil ums Verrecken net zum laufen und bin so langsam mit meinem Latein am Ende! Wäre dankbar für Lösungsansätze...
Der Fehler taucht in Zeile 101 auf. Meldung lautet wie folgt:

ungültige Umwandlung von »GenericList<char>*« in »char«

#ifndef GENERICLIST_H
#define GENERICLIST_H

template <class Head> class GenericList{
    public:
        GenericList();
        GenericList(Head newHead);
        int getLength();
        void putElementAtIndex(Head newHead, int index);
        void putLast(Head newHead);
        void putFirst(Head newHead);
        void removeLast();
        void removeFirst();
        void merge(GenericList other);
        Head getElementAtIndex(int index);
        Head getFirst();
        Head getLast();
        bool elementExists(Head element);
        bool isSorted();
    protected:
    private:
        Head head;
        GenericList *tail;
        int _getLength(int length);
};

template <class Head> GenericList<Head>::GenericList(){
    head = NULL;
    tail = NULL;
}

template <class Head> GenericList<Head>::GenericList(Head newHead){
    head = newHead;
    tail = NULL;
}

template <class Head> int GenericList<Head>::getLength(){
    int length;
    length = 1;
    return _getLength(length);
}

template <class Head> int GenericList<Head>::_getLength(int length){
    if(tail != NULL){
        length++;
        length = tail->_getLength(length);
    }
    return length;
}

template <class Head> void GenericList<Head>::putElementAtIndex(Head newHead, int index){
    if(index+1 <= getLength()){
        if(index != 0){
            tail->putElementAtIndex(newHead, --index);
        }else if(index == 0){
            putFirst(newHead);
        }
    }
}

template <class Head> void GenericList<Head>::putLast(Head newHead){
    if (tail != NULL){
        tail->putLast(newHead);
    }else{
        tail = new GenericList(newHead);
    }
}

template <class Head> void GenericList<Head>::putFirst(Head newHead){
    if(tail == NULL){
        tail = new GenericList(head);
    }else{
        tail->putFirst(head);
    }
    head = newHead;
}

template <class Head> void GenericList<Head>::removeLast(){
    if(tail->tail == NULL){
        tail = NULL;
    }else{
        tail->removeLast();
    }
}

template <class Head> void GenericList<Head>::removeFirst(){
    head = tail->head;
    tail = tail->tail;
}

template <class Head> void GenericList<Head>::merge(GenericList other){
    if(isSorted() && other.isSorted()){
        if(head <= other.head){
            if(tail == NULL){
                tail = &other;
            }else{
                tail->merge(other);
            }
        }else{
            putFirst(other.head);
            tail->merge(other.tail); //Hier wird der Fehler produziert... siehe unten...
        }
    }
}

template <class Head> Head GenericList<Head>::getElementAtIndex(int index){
    if(index+1 <= getLength()){
        if(index != 0){
            return tail->getElementAtIndex(--index);
        }else{
            return head;
        }
    }else{
        return NULL;
    }
}

template <class Head> Head GenericList<Head>::getFirst(){
    return head;
}

template <class Head> Head GenericList<Head>::getLast(){
    return getElementAtIndex(getLength()-1);
}

template <class Head> bool GenericList<Head>::elementExists(Head element){
    if(tail != NULL){
        if(head == element){
            return true;
        }else{
            return tail->elementExists(element);
        }
    }else{
        if(head == element){
            return true;
        }else{
            return false;
        }
    }
}

template <class Head> bool GenericList<Head>::isSorted(){
    if(tail == NULL){
        return true;
    }else{
        if(head <= tail->head){
            return tail->isSorted();
        }else{
            return false;
        }
    }
}

#endif // GENERICLIST_H

Getestet wird das Ganze wie folgt:

#include <iostream>
#include "GenericList.h"

using namespace std;

int main()
{
    GenericList<char> testGeneric('b');
    testGeneric.putLast('d');
    testGeneric.putFirst('a');
    testGeneric.putElementAtIndex('c', 2);

    GenericList<char> testGeneric2('e');
    testGeneric2.putLast('g');
    testGeneric2.putLast('x');
    testGeneric2.putLast('z');

    testGeneric.merge(testGeneric2);

    return 0;
}

Danke schon mal im Voraus!

Grüß, Olli

GenericList<Head>?

jencas

tail->merge(*other.tail);

Tipp 1: merge(GenericList other) -> hier möchtest Du 'other' ganz sicher nicht by value übergeben
Tipp 2: google("const correctness"), denn merge() sollte eine const Referenz einer GenericList übergeben bekommen, wobei das const daran scheitert, dass isSorted() nicht const ist, obwohl es am inneren Zustand der GenericLIst nichts verändert.

THX für die Tipps. Hab's jetzt hinbekommen...
Merge sieht jetzt wie folgt aus:

template <class Head> void GenericList<Head>::merge(GenericList *other){
    if(isSorted() && other->isSorted()){
        if(head <= other->head){
            if(tail == NULL){
                tail = other;
            }else{
                tail->merge(other);
            }
        }else{
            putFirst(other->head);
            tail->merge(other->tail);
        }
    }
}

Das kommt wohl davon, wenn man ewig lang nur noch mit JAVA am rumbasteln ist...

Grüße, Olli

volkard

Der Ansatz ist schief und die Liste fällt um.
So wird das nichts, sorry.

jencas

So wird das mit dem merge() nie was. Wenn die an merge() übergebene GenericList gelöscht wird, dann kracht es gewaltig.

Hab's grad gemerkt... Werd mir dann wohl was anderes einfallen lassen müssen. Trotzdem danke nochmal!

Grüße, Olli