Problem mit einfach verkettete Liste



  • Hallo zusammen.

    Ich hab ein Problem mit CLI und zwar soll eine einfach verkette Liste so umgeschrieben werden, dass die Methode "einfuegen" nicht jeweils immer wieder mehrfach aufgerufen werden muss sondern direkt das Ende der Liste angesprochen wird.

    Dies hab ich soweit geschaft.

    Jetzt zeigt der mir aber immer nur den ersten und den letzten Wert an.

    Kann mir da bitte jemand weiter helfen?

    #include "stdafx.h"
    
    using namespace System;
    
    ref class listenelement{
    	String ^daten;
    	listenelement ^next;
    
    public:
    	void datenSetzen(String ^datenneu);
    	void einfuegen(String ^datenneu, listenelement ^listenende);
    	void ausgeben (listenelement ^listenanfang);
    };
    
    void listenelement::datenSetzen(String ^datenneu){
    	daten=datenneu;
    }
    
    	void listenelement::einfuegen(String ^datenneu, listenelement ^listenende)
    {
        listenende->next = gcnew listenelement;
        listenende = listenende->next;
    
        listenende->daten=datenneu;
    
    }
    
    	void listenelement::ausgeben(listenelement ^listenanfang)
    {
    
        listenelement ^hilfsHandle = listenanfang;
    
        Console::WriteLine("{0}",hilfsHandle->daten);
    
        while (hilfsHandle->next != nullptr)
        {
            hilfsHandle = hilfsHandle->next;
            Console::WriteLine("{0}",hilfsHandle->daten) ;
        }
    }
    int main(array<System::String ^> ^args)
    {
    
        listenelement ^listenanfang = gcnew listenelement;
        listenelement ^listenende = listenanfang;
    
        listenanfang->datenSetzen ("Element 0");
    
        for (Int32 schleife=1;schleife<6;schleife++)
        {
            listenende->einfuegen("Element "+schleife,listenende);
        }
    
        listenanfang->ausgeben(listenanfang);
    
    return 0;
    
    }
    

    nachtrag:

    hab grad die ausgabe Methode verkleinert. Leider ohne Erfolg

    void listenelement::ausgeben()
    {
        Console::WriteLine("{0}",daten);  
    
        if (next!= nullptr)
    		next->ausgeben();
    
    }
    


  • Dein Fehler ist in der for der main-Methode. Du "fügst" du nämlich immer das gleiche Element an sich selbst.

    Außerdem solltest du "::einfügen" nochmal überarbeiten, denn zur Zeit änderst du dort nur den Parameter und nicht die Instanz der Klasse. Die Zuweisung des Parameters listenende in einfügen
    hat keine Auswirkungen auf die Variable listenende in main.

    Edit: Fehler übersehen



  • Danke erstmal für die Hilfe.

    Habs dann zum Schluss über die tracking reference geschafft. Hier mein finaler Code in den Methoden 'einfuegen' und in der 'main':

    void listenelement::einfuegen(String ^datenneu,listenelement ^%listenende )
    {
        listenelement ^hilfshandle;
    	hilfshandle = listenende;
    
    	hilfshandle->next = gcnew listenelement;
    	hilfshandle = hilfshandle->next;
    	hilfshandle->daten=datenneu;
    	listenende = hilfshandle;
    
    }
    -------------------
    int main(array<System::String ^> ^args)
    {
    
        listenelement ^listenanfang = gcnew listenelement;
    
        listenanfang->datenSetzen ("Element 0");
    	listenelement ^listenende = listenanfang;
        for (Int32 schleife=1;schleife<6;schleife++)
        {
            listenende->einfuegen("Element "+schleife,listenende);
        }
    listenanfang->ausgeben();
    return 0;
    

    Gruß
    Michael



  • 😮 So kann man es auch machen, sollte aber nicht:

    So ist es auch ein bisschen kürzer

    ref class listenelement
    {
    private:
    	String ^daten;	// ggf. in eine public Property umwandeln
    	listenelement ^next;
    
    public:
    	listenelement(String^ value);
    	// datenSetzen wird nicht gebracht da man direkt auf "daten" zugreifen kann 
    	//void datenSetzen(String ^datenneu);
    
    	// einfuegen wird nicht gebracht da man direkt auf "next" zugreifen kann 
    	//void einfuegen(String ^datenneu, listenelement ^listenende);
    
    	// Alternativ
    	listenelement^ append(String^ value);
    
    	void ausgeben ();
    };
    
    // Konstruktor
    listenelement::listenelement(String^ value)
    { 
    	daten = value;
    }
    
    listenelement^ listenelement::append(String^ value)
    {
    	return this->next = gcnew listenelement(value);
    }
    
    void listenelement::ausgeben()
    {
    	listenelement^ hilfsHandle = this;
    
    	// Vorsicht: Zirkuläre Referenzen erzeugen Endlosschleife
    	while (hilfsHandle != nullptr)
    	{
    		Console::WriteLine(hilfsHandle->daten) ;
    		hilfsHandle = hilfsHandle->next;
    	}
    }
    
    int main(array<System::String ^> ^args)
    {
    	listenelement 
    		^listenanfang,
    		^listenende = listenanfang = gcnew listenelement("Element 0");
    
    	for (Int32 schleife=1;schleife<6;schleife++)
    	{
    		listenende = listenende->append("Element "+schleife.ToString());
    	}
    	listenanfang->ausgeben();
    	return 0;
    }
    

Log in to reply