doppelt verkettete Liste

[ursk]

Hallo,
ich weiß, dass das Thema schon des öfteren hier behandelt wurde. Obwohl ich mir alle Beiträge durchgelesen habe, komme ich nicht recht weiter.
In der Struktur habe ich einen neuen Handle (last) angelegt.

void einfuegen(String ^datenneu, listenelement ^listenanfang) {

   listenelement ^hilfsHandle ;
   hilfsHandle = listenanfang;

	while (hilfsHandle->next != nullptr) 
	   hilfsHandle = hilfsHandle->next;
           hilfsHandle->next = gcnew listenelement;   
	   hilfsHandle->next->last = hilfsHandle;
	   hilfsHandle = hilfsHandle->next;
	   hilfsHandle->daten=datenneu;
}

Das müsste OK sein.

void ausgaberueckwaerts(listenelement ^listenende){

  listenelement ^hilfsHandle ;
  hilfsHandle = listenende;

  Console::WriteLine("{0}",hilfsHandle->daten) ;			
     while (hilfsHandle->last != nullptr) {
	 hilfsHandle =hilfsHandle->last;
	 Console::WriteLine("{0}",hilfsHandle->daten) ;
	}
}

Mit dieser Funktion habe ich Probleme, und zwar in der Main-Funktion

int main(array<System::String ^> ^args)
{
	listenelement ^listenanfang;
	listenanfang = gcnew listenelement;
        listenanfang->daten="Element 0";

	for (Int32 schleife=1;schleife<3;schleife++) 
	    einfuegen("Element "+schleife,listenanfang);

	listenelement ^listenende;
	listenende=listenanfang;

        for (Int32 schleife=1;schleife<3;schleife++)
            einfuegen("Element "+schleife,listenende);

    ausgeben(listenanfang);

    ausgaberueckwaerts(listenende);

Als Ausgabe bekomme ich die Werte: 0,1,2 1,2,0

[Doug_HH]

Hi ursk,

mein Lieblingsthema, wie viele Leute habe ich da schon durchgeprügelt.
In echt jetzt.

Tu Dir bitte in erster Linie selber mal ein gefallen und schreibe den Code sauberer.
Also in einen guten Programmierstil.

Achte bitte mal auf Deine Klammersetzung.

Schreib das bitte so, am besten Du gewöhnst Dir das gleich an.
Dadurch lässt sich der Code leichter lesen.

Nur so ein Tipp...

void einfuegen(String ^datenneu, listenelement ^listenanfang) 
{ 

   listenelement ^hilfsHandle ; 
   hilfsHandle = listenanfang; 

   while (hilfsHandle->next != nullptr) 
   {
      hilfsHandle = hilfsHandle->next;
   } 

    hilfsHandle->next = gcnew listenelement;   
    hilfsHandle->next->last = hilfsHandle; 
    hilfsHandle = hilfsHandle->next; 
    hilfsHandle->daten=datenneu; 
}

Nun zu Deiner Frage.

Mach Dir doch zu nutze, dass die Liste schon einmal vorwärts ausgegeben wurde.
Dadurch zeigt das Hilfshandle noch auf den letzten Datensatz.
Anders gesagt, wenn die Liste vorwärts ausgegeben wurde, rufe aus der Methode „ausgeben“ dann die Methode „ausgaberueckwarrts“ auf.

Gruß, Doug_HH

[ursk]

Hallo Doug_HH,

ich bin noch absoluter Anfänger.
Diesen Satz habe ich nicht verstanden, wie soll ich das machen?

"Anders gesagt, wenn die Liste vorwärts ausgegeben wurde, rufe aus der Methode „ausgeben“ dann die Methode „ausgaberueckwarrts“ auf."

Habe es kapiert und es funktioniert so auch.
Ich soll aber eine Funktion schreiben, die die Liste rückwärts ausgibt.

[Doug_HH]

Du rufst doch aus der main die Methode ausgaberueckwaerts(listenende) auf.
Wenn die Methode ausgeben(listenanfang) abgearbeitet wurde, ruf doch aus dieser Methode die Methode ausgaberueckwaerts(listenende) auf, weil der Zeiger ja eh auf den letzten Datensatz zeigt.

Poste mal den ganzen Code.
Mir ist die Methode ausgeben wichtig.

Gruß, Doug_HH

[ursk]

Hallo Doug_HH,
Also so funktioniert's, allerdings ohne die Funktion "ausgaberueckwaerts" und die brauche ich laut Lehrheft.

ref struct listenelement
{
	String ^daten;
	listenelement ^next;
	listenelement ^last;
};

void einfuegen(String ^datenneu, listenelement ^listenanfang)
{

   listenelement ^hilfsHandle ;
   hilfsHandle = listenanfang;

	while (hilfsHandle->next != nullptr)
	{
		hilfsHandle = hilfsHandle->next;
	}
        hilfsHandle->next = gcnew listenelement;   
	    hilfsHandle->next->last = hilfsHandle;
	    hilfsHandle = hilfsHandle->next;
	    hilfsHandle->daten=datenneu;
}

void ausgeben(listenelement ^listenanfang) 
{
	listenelement ^hilfsHandle;
    hilfsHandle = listenanfang;

	Console::WriteLine("{0}",hilfsHandle->daten);
	   while (hilfsHandle->next != nullptr) 
	   {
		    hilfsHandle = hilfsHandle->next;
		    Console::WriteLine("{0}",hilfsHandle->daten) ;
	   }
	   Console::WriteLine("{0}",hilfsHandle->daten) ;			
     while (hilfsHandle->last != nullptr)
	 {
		 hilfsHandle =hilfsHandle->last;
		 Console::WriteLine("{0}",hilfsHandle->daten) ;
	 }
}

void ausgaberueckwaerts(listenelement ^listenende)
{
  listenelement ^hilfsHandle ;
  hilfsHandle = listenende;

  Console::WriteLine("{0}",hilfsHandle->daten) ;			
     while (hilfsHandle->last != nullptr)
	 {
	   hilfsHandle =hilfsHandle->last;
	   Console::WriteLine("{0}",hilfsHandle->daten) ;
	 }

}

	int main(array<System::String ^> ^args)
{
	listenelement ^listenanfang;
	listenanfang = gcnew listenelement;
    listenanfang->daten="Element 0";

	for (Int32 schleife=1;schleife<3;schleife++) 
		einfuegen("Element "+schleife,listenanfang);

    ausgeben(listenanfang);

	return 0;
}

Gruß
Ursk

[Doug_HH]

Das war doch schon ganz Ok.
Aber wie schon vermutet, der Fehler lag beim Einfügen sowie in der Ausgabe.
Hoffe Du verstehst die Änderungen, wenn nicht erkläre ich sie Dir.

ref struct listenelement 
{ 
    String ^daten; 
    listenelement ^next; 
    listenelement ^last; 
}; 

void einfuegen(String ^datenneu, listenelement ^listenanfang) 
{ 

   listenelement ^hilfsHandle = listenanfang; 

   listenelement^ lastAdress; //Änderung

    while (hilfsHandle->next != nullptr) 
    { 
        hilfsHandle = hilfsHandle->next; 
    } 
		lastAdress = hilfsHandle; //Die alte Adresse vor dem Anlegen einer neuen Adresse speichern

        hilfsHandle->next = gcnew listenelement;   

		hilfsHandle = hilfsHandle->next;//Änderung

        hilfsHandle->last = lastAdress; //Änderung

		//hilfsHandle = hilfsHandle->next; gestrichen

        hilfsHandle->daten=datenneu; 
} 

void ausgaberueckwaerts(listenelement ^listenende) 
{ 
	//listenelement ^hilfsHandle; Keine neue Instanz vereinbaren
	//hilfsHandle = listenende; 

	Console::WriteLine("\n--------Rückwärts--------------------\n");

	Console::WriteLine("{0}",listenende->daten) ;            
	while (listenende->last != nullptr) 
	{ 
		listenende = listenende->last; 
		Console::WriteLine("{0}",listenende->daten) ; 
	}  

	//Eine leere Zeile ausgeben
	Console::WriteLine();

} 

void ausgeben(listenelement ^listenanfang) 
{ 
    listenelement ^hilfsHandle; 
    hilfsHandle = listenanfang; 

	Console::WriteLine("\n--------Vorwärts--------------------\n");

    Console::WriteLine("{0}",hilfsHandle->daten); 
	while (hilfsHandle->next != nullptr) 
	{ 
		hilfsHandle = hilfsHandle->next; 
		Console::WriteLine("{0}",hilfsHandle->daten) ; 
	} 

	ausgaberueckwaerts(hilfsHandle);//Ausgabe Rückwärts aufrufen und Hilfshandle übergeben
} 

int main(array<System::String ^> ^args) 
{ 
    listenelement ^listenanfang; 
    listenanfang = gcnew listenelement; 

	listenanfang->daten="Element 0"; 

    for (Int32 schleife=1;schleife<3;schleife++) 
	{
        einfuegen("Element "+schleife,listenanfang); 
	}

    ausgeben(listenanfang); 

    return 0; 
}

Gruß, Doug_HH

[ursk]

Hallo Doug_HH,

ich bin die ganze Sache noch einmal durchgegangen und denke, dass ich alles verstanden habe.

Nochmal vielen Dank

Gruß
ursk

P.S. Kannst du mir ein gutes C++ Buch empfehlen?

[Doug_HH]

Hallo ursk,

also C++/CLI Bücher gibt es nicht so viel gute.
Nur das eine hier, das ist aber in Englisch.

http://www.thalia.de/shop/buch_startseite_thalia/suchartikel/ivor_horton_s_beginning_visual_c_2005/ivor_horton/ISBN0-7645-7197-4/ID7014335.html?jumpId=2218825

Und für 2008 das hier.

http://www.thalia.de/shop/buch_startseite_thalia/suchartikel/ivor_horton_s_beginning_visual_c_2008/ivor_horton/ISBN0-470-22590-4/ID15013997.html?jumpId=2219078

C++ Buch? Von dem bin ich sehr begeistert.

http://www.thalia.de/shop/buch_startseite_thalia/schnellsuche/buch/?fi=&fqbt=&fqbr=&fqba=&fqbv=&fqbi=3898428168&fqbvbn=&fqbs=&fqbfsk=-1&ffsp=-1&ffm=-1&ffwg=-1&ffl=-1&fs=BUCH_VERKAUFSRANG_ASC&x=0&y=0

Gruß, Doug_HH

[Knuddlbaer]

C++ Buchempfehlungen findest Du auf Cplusplus.de

Für C++/CLI würde ich noch Pro Visual C++/CLI and the .NET 2.0 Platform | ISBN: 1590596404 empfehlen. Es setzt jedoch C++ Kenntnisse voraus, die man aber ohnehin haben sollte wenn man sich an C++/CLI heran wagt.

(So finde ich es z.B. total Unsinnig mit C++/CLI das wesen von doppelt verlinkten Listen zu lehren, gehen doch einige wichtige Lernaspekte schlichtweg verloren.)

[witte]

Findest Du den Fraser gut? Ich fand das Buch eher mittelmäßig. Drei Viertel behandeln das DotNet-Framework, für jemanden, der längere Zeit unter Windows Formularanwendungen gebaut hat ist es eher unnützer Ballast (da reicht die msdn-Doku), und C++/CLI-Spezifisches kommt m.E. zu kurz (z.B. versteht ein Einsteiger die Finalize-/Destruct-/Dispose-Semantik schwer).
Außerdem hat er ein Stil wie ein Fernsehprediger, aber das ist sicherlich Geschmackssache.
Irgendwie habe ich den Eindruck, dass ein allgemeines Buch zu DotNet und eine spezielle 'Broschüre' zu C++/CLI brauchbarer wäre.