4. Handle an main(...)

Handle an main(...)

  • C

    Hallo zusammen,

    ich habe das Problem einen Handle aus einer Funktion an main zurückzugeben.

    Ich bekomme immer wieder die fehlermeldung, dass = : listenelement nicht in listenelement ^ konvertiert werden kann.

    Für jeden Hinweis wäre ich sehr dankbar.

    Hier das Listing:

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

    };

    listenelement ^einfuegen(String ^datenneu, listenelement ^listenende)
    {
    listenende->next = gcnew listenelement;
    listenende->daten=datenneu;

    listenende = listenende->next;

    return(listenende);

    }

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

    listenanfang = hilfsHandle;

    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; //Erstes Element per Hand erzeugen

    listenanfang->daten="Element 1"; //Daten per Hand festlegen

    if(listenanfang->next==nullptr)
    {
    listenanfang=listenende;

    einfuegen("Element 2", listenende);
    }

    else

    listenende = *einfuegen("Element 2", listenende);

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

    ausgeben(listenanfang);

    return 0;

    }

    0
  • F

    hmmm... aufgabe 5.1 ILS

    void einfuegen (String ^datenneu, listenelement ^%listenende) {
	//*******Tracking-Referenz initialisiert ^%listenende)
	//ein Hilfshandle zum Wandern in der Liste
	listenelement ^hilfsHandle;

	//Hilfshandle an Ende der Liste setzen
	hilfsHandle = listenende;

	//Neues Element am Ende der Liste einfügen
	hilfsHandle->next=gcnew listenelement;

	//Hilfshandle auf das neue Element setzen
	hilfsHandle=hilfsHandle->next;

	//Zeichenkette im neuen Element eintragen
	hilfsHandle->daten=datenneu;

	//Listenende auf HilfsEnde setzen
	listenende = hilfsHandle;
}
.....

    den Rest musste schon alleine machen
    und mit den richtigen SuFu-Begriffen hättest Du es auch hier gefunden ;o)

    0
  • C

    Danke für deine Antwort.

    Mit der Tracking-Reference kann ich die Aufgabe lösen, doch ich weiß nicht, ob ich die Technik benutzen darf.

    Die Aufgabenstellung besagt, dass ich nur bereits erlerntes nutzen darf und ich habe in meinen Unterlagen keinen Verweis auf eine Tracking-Reference gefunden.

    Deshalb meine Frage: Hast du diese Aufgabe auch machen müssen und auch erfolgreich bestanden?

    Hier mein Listing:

    /* ###################################################

    Einsendeaufgabe 5.1

    #################################################### */

    #include "stdafx.h"

    using namespace System;

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

    //Funktion zum Einfügen neuer Listenelemente
    listenelement ^einfuegen(String ^datenneu, listenelement ^%listenende)
    {
    listenende->next=gcnew listenelement; //Neues Strukturelement erstellen
    listenende=listenende->next; //Handle auf das Listenende positionieren
    listenende->daten=datenneu; //Daten ins Element schreiben

    return listenende; //Rückgabe des Handles Listenende an main
    }

    //Ausgabe aller Strukturelemente
    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; //Handle auf das erste Element der Liste
    listenelement ^listenende; //Handle auf das letzte Element der Liste

    listenanfang = gcnew listenelement; //Erstes Element per Hand erstellen
    listenanfang->daten="Element 1"; //Daten ins Element schreiben

    listenende=gcnew listenelement; //Zweites Element per Hand erstellen
    listenende->daten="Element 2"; // Daten ins Element schreiben
    listenanfang->next=listenende;

    //Über eine Schleife mehrere Elemente einfügen
    for(Int32 schleife=3; schleife<10; schleife++)
    einfuegen("Element "+schleife, listenende);

    //Auslesen aller Strukturelemente
    ausgeben(listenanfang);

    return 0;
    }

    0
  • F

    hi,

    man kann es auch so machen!!
    viele Wege führen zum Ziel ;o)
    welcher für Dich der beste ist, das weiß nur das Licht ;o)

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

void einfuegen(String ^datenneu, listenelement ^sorter) {
	listenelement ^hilfsHandle;
	hilfsHandle = sorter;
	hilfsHandle->next = gcnew listenelement;
	hilfsHandle->daten=datenneu;
}.....

    aber, seit wann wird Eigeninitiative nicht bewertet?
    Es schreibt Dir keiner vor, welchen Weg du gehst, im gegenteil!!!!

    gerade die verketteten Listen sind zwar im ersten Augenblick schnick/schnack
    aber spätistens ab Heft 7/8 ist es GRUNDWISSEN, da hilft auch kein pauschales
    drag and drop, man sollte auch bei ILS die Sache ernst nehmen und sich Fragen ob man es wirklich will, denn dann muss man es auch können.

    und es wäre schön wenn Du die Code-Tags nimmst, denn sonst wird dir hier keiner
    so recht Hilfe anbieten, hättest Du die SuFu auch richtig genutzt würde dieser Thread auch gar nicht von nöten sein, siehe
    http://www.c-plusplus.net/forum/viewtopic-var-p-is-1507681.html

    mfg

    0
  • ?

    Das wird immer mehr hier, mit den Nachgemachten möchte gerne Programmierer.
    Man sollte langsam mal die ILS, HAF oder SDG informieren.
    Ihr könnt Stolz auf eure Noten sein...

    Gruß

    0
  • ?

    Was ist den die ILS ? Ist das ein Aufgabenbuchverlag?

    0
Anmelden zum Antworten