jugiii

das ist ja echt kompliziert. kann man das nicht einfacher gestalten ?

ok, nehmen wir mal an, das Wort hat 8 Buchstaben. Laut der for Schleife wird diese 7 mal aufgerufen (schleife=zkette->Length-1) dann bei tempkette=tempkette->Remove(zkette->Length-schleife-1,1) müsste so gerechnet werden: 8-7-1 das ist 0. demzufolge müsste das erste Zeichen (hier also das H) gelöscht werden.

hat jemand nun evtl. eine Erklärung für diese Aufgabe ?:confused:

find ich auch kompliziert, aber so steht es in meinem Lehrheft. Ich will ja auch gerne die komplizierten Texte verstehen

hallo zusammen ! Ich habe hier einen Quelltext, den ich nicht ganz verstehe. Das Programm dreht eine Zeichenkette um und gibt sie also umgekehrt aus, z.B. aus Hallo wird ollaH. #include "stdafx.h" using namespace System; String^ umdrehen (String^ zkette); String^ umdrehen (String^ zkette) { String ^tempkette; tempkette = zkette; for (Int32 schleife=zkette->Length-1;schleife>=0;schleife--) { tempkette=tempkette->Remove(zkette->Length-schleife-1,1); tempkette=tempkette->Insert(zkette->Length-schleife-1,Convert::ToString(zkette[schleife])); } return tempkette; } int main (array<System::String ^> ^args) { String^ eingabe; Console::Write("Geben sie eine Zeichenkette ein"); eingabe=Console::ReadLine(); eingabe = umdrehen(eingabe); Console::WriteLine("Die umgekehrte Eingabe {0}",eingabe); return 0; } Was ich jetzt hier nicht kapiere ist dieser Ausschnitt: tempkette=tempkette->Remove(zkette->Length-schleife-1 Was bedeutet denn hier dieses zkette->Length-schleife-1 ? Stimmt das mit dem - vor schleife ? Ist das ein sinnbildliches Minus oder nur ein Verbindungsstrich ? DANKE !!

hallo zusammen ! Ich habe hier einen Quelltext, den ich nicht ganz verstehe. Das Programm dreht eine Zeichenkette um und gibt sie also umgekehrt aus, z.B. aus Hallo wird ollaH. #include "stdafx.h" using namespace System; String^ umdrehen (String^ zkette); String^ umdrehen (String^ zkette) { String ^tempkette; tempkette = zkette; for (Int32 schleife=zkette->Length-1;schleife>=0;schleife--) { tempkette=tempkette->Remove(zkette->Length-schleife-1,1); tempkette=tempkette->Insert(zkette->Length-schleife-1,Convert::ToString(zkette[schleife])); } return tempkette; } int main (array<System::String ^> ^args) { String^ eingabe; Console::Write("Geben sie eine Zeichenkette ein"); eingabe=Console::ReadLine(); eingabe = umdrehen(eingabe); Console::WriteLine("Die umgekehrte Eingabe {0}",eingabe); return 0; } Was ich jetzt hier nicht kapiere ist dieser Ausschnitt: tempkette=tempkette->Remove(zkette->Length-schleife-1 Was bedeutet denn hier dieses zkette->Length-schleife-1 ? Stimmt das mit dem - vor schleife ? Ist das ein sinnbildliches Minus oder nur ein Verbindungsstrich ? DANKE !!

Nein, jetzt müsste es eigentlich passen: ref struct listenelement { String ^daten; listenelement ^next; }; listenelement ^einfuegen(String ^datenneu, listenelement ^listenende) { listenende->next = gcnew listenelement; listenende = listenende->next; listenende->daten=datenneu; return listenende; } 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) ; } } int main(array<System::String ^> ^args) { listenelement ^listenanfang; listenelement ^listenende; listenanfang = gcnew listenelement; listenanfang->daten="Element 0"; listenende=listenanfang; for (Int32 schleife=1;schleife<3;schleife++) listenende = einfuegen("Element "+schleife,listenende); ausgeben(listenanfang); return 0; }

ref struct listenelement { String ^daten; listenelement ^next; }; listenelement ^einfuegen(String ^datenneu, listenelement ^listenende) { listenelement ^hilfsHandle; hilfsHandle = listenende; hilfsHandle->next = gcnew listenelement; hilfsHandle = hilfsHandle->next; hilfsHandle->daten=datenneu; return hilfsHandle; } 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) ; } } int main(array<System::String ^> ^args) { listenelement ^listenanfang; listenelement ^listenende; listenanfang = gcnew listenelement; listenanfang->daten="Element 0"; listenende=listenanfang; if (listenende->next == nullptr) { for (Int32 schleife=0;schleife<3;schleife++) listenende->next = einfuegen("Element "+schleife,listenende); } ausgeben(listenanfang); return 0; } jetzt korrekt ?

stimmt. muss ich dann nochmals überarbeiten

hallo zusammen ! ich habe selbst mal versucht die Aufgabe zu lösen. die Aufgaben waren ja, bei der einfach verketteten Liste diese so neu zu gestalten, dass ein listenende erstellt wird in einem eigenen handle. Das Listenende soll nach jedem Einfügen ermittelt und an die Main Funktion zurückgegeben werden. Als Argument soll man beim Einfügen nicht den listenanfang sondern listenende übergeben. Könnt ihr mal schauen, ob meins semantisch korrekt ist ? : #include "stdafx.h" using namespace System; ref struct listenelement { String ^daten; listenelement ^next; }; listenelement ^einfuegen (String ^neu, listenelement ^listenende) { listenelement ^hilfshandle; hilfshandle=listenende; while (hilfshandle->next != nullptr) hilfshandle=hilfshandle->next; hilfshandle->next = gcnew listenelement; hilfshandle = hilfshandle->next; hilfshandle->daten=neu; return hilfshandle; } void ausgeben(listenelement ^listenanfang) { listenelement ^hilfshandle; hilfshandle = listenanfang; Console::WriteLine("erstes Element: {0}",hilfshandle->daten); while (hilfshandle->next != nullptr) { hilfshandle = hilfshandle->next; Console::WriteLine("nächstes Element: {0}",hilfshandle->daten); } } int main(array<System::String ^> ^args) { listenelement ^listenanfang; listenanfang = gcnew listenelement; listenanfang->daten="Element 0"; listenelement ^listenende; listenende = listenanfang; while (listenende->next != nullptr) listenende = listenende->next; listenende->next = gcnew listenelement; listenende = listenende->next; for (Int32 schleife=1;schleife<3;schleife++) einfuegen("Element "+schleife,listenende); ausgeben(listenanfang); return 0; } DANKE

ich habs trotzdem nicht kapiert. ich bräuchte es echt zeile für zeile für Blödies **heul***

nicht schlecht, danke. dann ist deins ja wie meins http://forum.fachinformatiker.de/smilies/1012.gif

wenn du vielleicht Lust und Zeit hast, könntest du mir deine Vorstellungsweise darbieten ? ich scheitere mittlerweile schon an den kleinsten Dingen, wie z.B. was am Anfang in der Funktion einfuegen() überhaupt drinnensteht und ob dies schon Auswirkungen auf irgendwas hat

also mit den langen pfeilen -----> versuche ich immer darzustellen, worauf der handle gerade noch zeigt

ich meine damit, dass der Hilfshandle auf dieses next:nullptr gesetzt ist. also hilfshandle zeigt auf das letzte next-Objekt, welches den Wert 0 hat

ich fass nochmals zusammen. Ich starte bei main(): zu listenelement ^listenanfang ein lokaler Handle listenanfang wird auf die Struktur gesetzt, also: listenanfang ---> daten: next: dann wird Speicher reserviert und listenanfang zugewiesen (mit gcnew) dann wird in listenanfang Element 0 eingefügt, also: listenanfang ---> Element 0 next: nullptr. dann wird an Funktion einfuegen übergeben: Element 1 und listenanfang also: listenanfang ----> Element 0 next: -------> Element__ (Bei Funktionsende dann 1) next: nullptr. unter einfuegen() ein lokaler hilfshandle für die Struktur wird erstellt. Hilfshandle wird auf listenanfang gesetzt (erstes Element), also: listenanfang ---> Element 0 hilfshandle ------> next: ------> Element__ (bei Funktionsende dann 1) next: nullptr. while Schleife ist klar. hilfshandle = hilfshandle->next; also: hilfshandle ---> Element__ (bei Funktionsende dann 1) next: nullptr. Speicher reservieren und hilfshandle zuweisen dann nochmals hilfshandle=hilfshandle->next also hilfshandle direkt auf das next setzen daten werden nun eintragen, also: listenanfang -> Element 0 next: ---> Element 1 next: nullptr. <---hilfsHandle Ende des ersten Einfügens. Lieg ich noch richtig ?

hallo, ich habe ebenfalls Probleme, die verkettete Liste von oben nachzuvollziehen. Ich habe schon einige Lösungsansätze gefunden,jedoch mehrere ! Jetzt weiss ich immer noch nicht, wie diese Liste funktioniert. ich habe hier nochmals das Listing und MEINE Interpretation der einzelnen Stationen in grüner Farbe dargestellt. Vielleicht wäre jemand so nett, und kann meine Interpretation nachprüfen und ggf. mit roter Farbe korrigieren. Danke http://forum.fachinformatiker.de/images/smilies/roll.gif #include "stdafx.h" using namespace System; //die Struktur für den verwalteten Heap ref struct beispiel { int inhalt; beispiel ^next; hier wird eine Struktur angelegt. Die Struktur enthält ein Feld inhalt und einen weiteren Zeiger oder Handle welcher wiederum auf inhalt eines weiteren Speichers zugreifen bzw. zeigen kann. }; void einfuegen(int inhaltneu, beispiel ^anfang) { unter int inhaltneu wird jetzt 1 aus main übergeben und unter beispiel ^anfang anfang von main. Kann mir jemand sagen, was genau jetzt in dieser Funktion einfuegen in klammern stehen würde ? Wird durch die Übergabe der Parameter an diese Funktion bereits ein Wert in der Struktur gespeichert ? beispiel ^zeiger; zeiger=anfang; hier wird nun ein weiterer Handle zeiger erstellt und auf listenanfang gesetzt. zeigt dieser zeiger Handle jetzt auf 0 oder auf 0 + next oder auf 1 und next ? while (zeiger->next!=nullptr) { zeiger=zeiger->next; } Liste durchgehen, bis zeiger.next ungleich null ist. Dann wird dieser Zeiger auf next gesetzt. zeiger->next=gcnew beispiel; wieder Speicher reservieren zeiger=zeiger->next; zeiger wird nochmals auf next gesetzt ? welches next ist das denn jetzt ? das von zeiger oder von anfang oder der struktur selbst ? zeiger->inhalt=inhaltneu; das ist wieder klar } void ausgabe(beispiel ^anfang) { beispiel ^zeiger; zeiger=anfang; Console::WriteLine("{0}", zeiger->inhalt); while (zeiger->next != nullptr) { zeiger = zeiger->next; Console::WriteLine("{0}", zeiger->inhalt); } }diese Funktion ist auch wieder klar ! int main(array<System::String ^> ^args) { beispiel ^anfang; hier wird ein Handle bzw. Zeiger anfang erstellt, welcher die Daten der Struktur (also inhalt und next) speichern kann anfang=gcnew beispiel; hier wird für den Handle speicher reserviert anfang->inhalt=0; das erste Element wird in den handle anfang geschrieben. Da ja der Handle indirekt mit der Struktur beispiel arbeitet, wird hier jetzt indirekt dieser Wert in die Struktur geschrieben oder in anfang selbst ? for (int schleife=1;schleife<5;schleife++) { einfuegen(schleife, anfang); in dieser schleife wird das nächste element und anfang an die funktion einfuegen übergeben. Was wird denn hier genau mit anfang übergeben ? } ausgabe(anfang); das ist klar ! return 0; } DANKE !!!