ich möchte eine Methode zum Löschen eines übergebenen Elements schreiben. Die Methode soll alle Elemente in der Liste, die dem übergebenen Element gleich sind, löschen.

template<class T>
class List {
    class Node {
    public:
        Node(const T& crT, Node* pNext) : m_T(crT), m_pNext(pNext) {}
        T m_T;
        Node* m_pNext;
    };
public:
    List() : m_pHead(0) {}
    void insert(const T& crT) { m_pHead = new Node(crT,m_pHead); }
    void deleteIt(const T& crT) {
        Node* vorgaenger = 0;
        for(Node* elem = m_pHead; elem != 0; elem = elem->m_pNext) {
            if(elem->m_pNext != 0 & elem->m_pNext->m_T == crT) {
                    vorgaenger = elem;
            }
            if(elem->m_T == crT) {
                Node* tmpN = elem;
                if(tmpN == m_pHead) {
                    m_pHead = m_pHead->m_pNext;
                }
                if(vorgaenger != 0)
                    vorgaenger->m_pNext = elem;
                delete tmpN;
            }
        }
    }
    void print() {
        for(Node* tmp = m_pHead; tmp != 0; tmp = tmp->m_pNext)
            cout << tmp->m_T << " ";
        cout << endl;
    }
private:
    Node* m_pHead;
};
int main() {
    cout << "Einfach verkettete Liste" << endl;
    List<int> l;
    for(int i = 0; i < 5; ++i)
        l.insert(i);
    l.print();
    l.insert(3);
    l.print();
    l.deleteIt(3);
    l.print();
    system("pause");
    return 0;
}

Allerdings stürzt mein Programm ab, wenn deleteIt(3) aufgerufen wurde.
Ich denke es hängt mit dem Aufruf von delete tmpN; zusammen, saß jetzt aber bestimmt schon zwei Stunden davor und kann es mir immer noch nicht richtig erklären.

Kann mir da einer helfen? Bin ich schon auf dem richtigen Weg? Was muss ich anders machen, damit das Löschen funktioniert?

Gruss vnmr

Node* tmpN = elem;
if(tmpN == m_pHead) {
  m_pHead = m_pHead->m_pNext;
}
if(vorgaenger != 0)
  vorgaenger->m_pNext = elem; // tmpN zeigt immer noch auf elem
delete tmpN;  // vorgaenger->elem ist jetzt im Nirvana...

Ich würde dir raten, erst mit Stift und Papier zu skizzieren, was passiert wenn du ein Element löschst.
Außerdem würde ich raten dir eine eigene private Methode "findParentNode(const T&)" zu basteln, die dir das parent eines passenden Items zurückliefert. Das kannst du verwenden für insertBefore, insertAfter, delete, find, usw. dann wird dein delete gleich viel übersichtlicher!

Hallo

hi^^

ich möchte eine Methode zum Löschen eines übergebenen Elements schreiben. Die Methode soll alle Elemente in der Liste, die dem übergebenen Element gleich sind, löschen.

template<class T>
class List
{
    struct Node
    {
        Node(const T& crT, Node* pNext)
        :   m_T(crT), m_pNext(pNext)
        {}

        T m_T;
        Node* m_pNext;
    };

    Node* m_pHead;
public:
    List()
    :   m_pHead(0)
    {}

    void insert(const T& crT)
    {
        m_pHead = new Node(crT,m_pHead);
    }

    void deleteIt(const T& crT)
    {
        Node* vorgaenger = 0;

        for(Node* elem = m_pHead; elem != 0; elem = elem->m_pNext)
        {
            if(elem->m_pNext != 0 & elem->m_pNext->m_T == crT)
            { //hier ist auf jeden fall schon mal ein fehler - nimm das logische und, sonst wird die rechte seite auch ausgewertet, wenn du einen nullzeiger hast!
                    vorgaenger = elem;
            }

            if(elem->m_T == crT)
            {
                Node* tmpN = elem;

                if(tmpN == m_pHead)
                    m_pHead = m_pHead->m_pNext;

                if(vorgaenger != 0)
                    vorgaenger->m_pNext = elem;

                delete tmpN;
            }
        }
    }

    void print()
    {
        for(Node* tmp = m_pHead; tmp != 0; tmp = tmp->m_pNext)
            cout << tmp->m_T << " ";

        cout << endl;
    }
};

int main()
{
    cout << "Einfach verkettete Liste" << endl;

    List<int> l;

    for(int i = 0; i < 5; ++i)
        l.insert(i);

    l.print();

    l.insert(3);
    l.print();

    l.deleteIt(3);
    l.print();

    system("pause");
    return 0;
}

Jetzt kann es der Großteil hier denke ich auch besser lesen ;o)

bb

Sebastian Pizer schrieb:

Destruktor, Kopierkonstruktor und Zuweisungsoperator fehlen, siehe Dreierregel.

Ich möchte es gerade ohne die Dreierregel realisieren.

Ich habe jetzt erstmal das logische Und genommen. Jetzt wird wenigstens nach dem deleteIt was ausgegeben.

l'abra d'or schrieb:

2. Warum versetzt du m_pHead! Das ist dein Listen Kopf (dein root-Element, oder?)
   Du modellierst eine einfach verkettete Liste, das heißt du hast keinen Zugriff mehr auf deinen Vorgänger. Sobald du m_pHead also auf ein anderes Element zeigen lässt hast du ein riesen Problem!

Ich wollte den Fall implementieren, dass wenn elem auf das erste Element zeigt (m_pHead), der Head um einen weitergesetzt wird und dann gelöscht wird. Oder ist das überflüssig?

3. tmpN zeigt immer noch auf eine gültige und verwendete Node!

Node* tmpN = elem;
if(tmpN == m_pHead) {
  m_pHead = m_pHead->m_pNext;
}
if(vorgaenger != 0)
  vorgaenger->m_pNext = elem; // tmpN zeigt immer noch auf elem
delete tmpN;  // vorgaenger->elem ist jetzt im Nirvana...

Da hast du recht, allerdings hab ich keine Ahnung, wie ich das anders implementieren kann.

Inzwischen ist es so, dass die Ausagbe nach dem deleteIt(3); folgendermaßen aussieht: 4 212856 2 1 0
Also das Umhängen von m_pHead scheint ja zu funktionieren. Allerdings funktioniert dann das umhängen eines Elements mitten in der Liste noch nicht, wie man an dem komischen int-Wert sieht. Was muss ich denn machen, um diesen Fall richtig behandeln zu können? Ich kann es mir nicht erklären.

Sebastian Pizer schrieb:

Destruktor, Kopierkonstruktor und Zuweisungsoperator fehlen, siehe Dreierregel.

Ich möchte es gerade ohne die Dreierregel realisieren.

Wenn Du keine Lust hast, Copy-Ctor und Assignment-Operator zu implementieren, dann verhindere wenigstens diese Operationen.

template<typename T>
class forwardlist : boost::noncopyable
{
  ...

Einen Destruktor solltest Du Dir schon bauen. So ein Objekt, was selbst andere Objekte per new erzeugt und "speichert" aber keinen benutzerdefinierten, aufräumenden Destruktor hat, ist einfach eine Frechheit und verstößt gegen common practice. Entweder, Du überlässt dem Nutzer die Speicherverwaltung (siehe Boost's Intrusive Containers) oder Du regelst das komplett selbst (wie alle anderen Standard-Container). Aber bitte nicht so 'ne halbe Sache. Das gibt nur Chaos.

Wenn's um das Löschen von Elementen in einer verketteten Liste geht, sind Zeiger auf Zeiger recht praktisch. Damit spart man sich den Sonderfall mit dem Anfang der Liste. Pseudo-Code

void loeschen(Node*& anfang, T const& elem)
{
  Node** pp = &anfang;
  while (*pp) {
    if (**pp == elem) {
      Node* danach = (**pp).next;
      delete *pp;
      *pp = danach;
    } else {
      pp = & (**pp).next;
    }
  }
}

(ungetestet)

willkommen im C++-Forum. Du kannst hier noch 'ne Menge lernen.

vnmr schrieb:

Da hast du recht, allerdings hab ich keine Ahnung, wie ich das anders implementieren kann.

Deine Liste sollte in etwa so aussehen:

#include <iostream>
#include <cassert>
#include <functional> // std::bind2nd, std::equal_to

template< typename T >
class List
{
    struct Node
    {
        Node( const T& x, Node* next )
            : m_next( next ), m_data( x )
        {}
        Node* m_next;
        T m_data;
    };

public:
    typedef T value_type;
    List() : m_head( 0 ) {}
    ~List()
    {
        erase( &List< T >::all );
    }

    void push_front( const T& x ) // insert steht für das Einfügen in assoziativen Containern
    {
        m_head = new Node( x, m_head );
    }

    void erase( const T& x ) // erase steht für das Löschen von Elementen aus Containern
    {
        erase( std::bind2nd( std::equal_to< T >(), x ) );
    }
    template< typename Pred >
    void erase( Pred pred )
    {
        Node* prev = 0;
        for( Node* nd = m_head; nd; )
        {
            if( pred( nd->m_data ) )
            {   // Löschbedingung ist erfüllt
                Node* const tmp = nd;
                (prev? prev->m_next: m_head) = nd->m_next;
                nd = nd->m_next; // Wichtig: 'nd' muss vor dem delete auf den nächsten Zeiger gesetzt werden
                delete tmp;
            }
            else
            {
                prev = nd;
                nd = nd->m_next;
            }
        }
    }

    friend std::ostream& operator<<( std::ostream& out, const List& list )
    {
        for( List::Node* nd = list.m_head; nd; nd = nd->m_next )
            out << nd->m_data << " ";
        return out;
    }

private:
    List( const List& ); // Dreierregel beachten!
    List& operator=( const List& );

    static bool all( const T& ) { return true; }
    // --   Members
    Node* m_head;
};

bool equal167( int x )
{
    return x == 1 || x == 6 || x == 7;
}

int main()
{
    using namespace std;
    {
        List< int > list;
        for( int i = 7; i > 0; --i )
            list.push_front( i );
        cout << list << endl;
        list.erase( 6 );
        list.erase( 1 );
        list.erase( 7 );
        cout << list << endl;
    }
    {
        List< int > list;
        for( int i = 7; i > 0; --i )
            list.push_front( i );
        cout << list << endl;
        list.erase( &equal167 );
        cout << list << endl;
    }
    return 0;
}

Das entspricht dann auch den Anforderungen, die Sebastian mit Recht angemahnt hat.

Gruß
Werner

template< typename Pred >
    void erase( Pred pred )
    {
        Node* prev = 0;
        for( Node* nd = m_head; nd; )
        {
            if( pred( nd->m_data ) )
            {   // Löschbedingung ist erfüllt
                Node* const tmp = nd;
                (prev? prev->m_next: m_head) = nd->m_next;
                nd = nd->m_next; // Wichtig: 'nd' muss vor dem delete auf den nächsten Zeiger gesetzt werden
                delete tmp;
            }
            else
            {
                prev = nd;
                nd = nd->m_next;
            }
        }
    }

Diese Funktion macht immer noch zuviel und wird deshalb unnötig lang und komplex. Im Einzelnen:
- gehe jedes Element durch
- prüfe ob Bedingung erfüllt ist
- wenn ja:
- entferne Node aus Liste
- lösche Node
Ohne ein brauchbares Iteratorkonzept, kann man die ersten beiden Teile nicht sauber trennen, aber jedenfalls die letzten beiden Punkte können isoliert implementiert werden

Node* remove_single_node( Node*& owner )
    {
        assert( owner != 0 );
        Node* node = owner;
        owner = owner->m_next;
        return node;
    }
    void erase_single_node( Node*& owner )
    {
        assert( owner != 0 );
        delete remove_single_node( owner );
    }
    template< typename Pred >
    void erase( Pred pred )
    {
        for( Node** nd = &m_head; *nd != 0; )
            if( pred( ( *nd )->m_data ) )
                erase_single_node( *nd );
            else
                nd = &( *nd )->m_next;
    }