Verkettete Listen



  • hallo c-freaks 😉

    Ich hab ein Problem mit meiner Funktion void liste. Ich denke mal es hat was mit der switch funktion zu tun. Hab mir jetzt schon einige bücher durchgelesen aber noch nichts gefunden, was mir weiterhelfen könnte.

    Wäre sehr nett, wenn ihr mir weiterhelfen könntet. Eine Erklärung wäre auch nicht schlecht 🙂

    Danke im Vorraus

    #include <stdio.h>
    #include <conio.h>
    #include <malloc.h>
    #include <iostream.h>
    
    struct daten
    {
    int flugnr;
    char natio[30];
    int liter;
    };
    
    struct listenelement
    {
    struct daten *pdat;
    struct listenelement* next;
    };
    
    struct listenkopf
    {
    struct listenelement* first;
    struct listenelement* last;
    };
    
    void liste ();
    struct listenkopf *listeerzeugen (void);
    int elementanhaengen (struct listenkopf *kopf, struct daten *dat);
    void listezeigen (struct listenkopf *kopf);
    int listenelementeingeben (struct listenkopf *kopf);
    
    void main()
    {
    liste();
    }
    
    void liste ()
    {
    int wahl;
    struct daten* neu;
    struct listenkopf *kopf;
    struct listenelement* kasten;
    
    cout<<" M E N U E \n\n"<<endl;
    
    do{
    cout<<"Auswahl:\n\n"<<"1. Liste anzeigen\n"<<"2. Eintrag in Liste einfuegen\n"<<"0. Ende";
    
    cin>>wahl;
    switch (wahl)
    {
    case 0: cout<<"Ende"<<endl;
    break;
    
    case 1:  void listezeigen (struct listenkopf *kopf);
    break;
    
    case 2: neu = listenelementeingeben ();
    break;
    
    default: cout<<"Falsche Eingabe"<<endl;
    
    }
    }
    while (wahl);
    
    }
    
    struct listenkopf *listeerzeugen (void)
    {
    struct listenkopf* liste;
    liste = (struct listenkopf*) malloc (sizeof(struct listenkopf));
    
    if (liste != 0)
    {
    liste->first= NULL;
    liste->last = NULL;
    
    return liste;
    }
    
    };
    
    int elementanhaengen (struct listenkopf *kopf, struct daten *dat)
    {
    struct listenelement* neu;
    neu = (struct listenelement*) malloc (sizeof(struct listenelement));
    
    if (neu != 0)
    {
    neu->pdat = dat;
    
    neu->next = kopf->first;
    kopf->first= neu;
    return 1;
    }
    
    else
    
    return 0;
    
    }
    
    int listenelementeingeben (struct listenkopf *kopf)
    {
    struct daten* ptr;
    ptr = (struct daten*) malloc (sizeof(struct daten));
    
    if (ptr != 0)
    {
    cout<<"Flugnummer:"<<endl; 
    cin>>ptr->flugnr;
    
    cout<<"Nationalitaet"<<endl; 
    cin>>ptr->natio;
    
    cout<<"Treibstoffmenge"<<endl; 
    cin>>ptr->liter;
    
    return 1;
    }
    else
    return 0;
    
    }
    
    void listezeigen (struct listenkopf *kopf)
    {
    int index = 1;
    
    struct listenelement* hilf;
    hilf = (struct listenelement*) malloc (sizeof(struct listenelement));
    
    if (hilf == 0)
    {
    cout<<"Die Liste ist nicht vorhanden!!"<<endl;
    return;
    }
    
    while (hilf != 0)
    {
    cout<<"Flugnummer: "<<hilf->pdat->flugnr<<endl; 
    
    cout<<"Nationalitaet: "<<hilf->pdat->natio<<endl; 
    
    cout<<"Treibstoffmenge: "<<hilf->pdat->liter<<endl; 
    
    index ++;
    
    hilf->next = hilf;
    
    }
    
    }
    


  • was ist das problem?

    achja, formatier den code mal ansehnlich und benutz den [cpp] tag



  • comovai schrieb:

    hallo c-freaks 😉

    Bitte?!

    comovai schrieb:

    Ich hab ein Problem mit meiner Funktion void liste. Ich denke mal es hat was mit der switch funktion zu tun. Hab mir jetzt schon einige bücher durchgelesen aber noch nichts gefunden, was mir weiterhelfen könnte.

    In dem Code sind viele Fehler (einige habe ich angemerkt) und er entscheidet sich nicht für eine Sprache.
    Soll er nun C oder C++ sein?
    Ich hab dir hier mal eine C++-Version gebaut (keineswegs perfekt, aber und weil designmäßig nah am "Original" ;)).

    Es wäre vielleicht ganz praktisch, wenn noch ein echter C-ler deinen Code noch zu echtem C berichtigen würde, das hilft dir vielleicht bei der Entscheidung 😉

    #include <iostream> // iostream.h ist obsolet, conio brauchst du nicht
    // stdio.h und malloc.h ist C
    
    #include <string>
    
    struct daten
    {
        int flugnr;
        // char-Arrays funktionieren nicht so, wie du das gemacht hast. Nimm std::string
        std::string natio;
        int liter;
    };
    
    class liste
    {
    public:
        // Konstruktor, entspricht deinem "listeerzeugen". Nu schau mal, wie simpel
        // das hier ist ;). (In C++ benutzt man 0 statt NULL, das ist aber eher
        // kosmetisch)
        liste () : first (0), last (0)
        {}
    
        // Destruktor, du musst deinen Kram auch wieder aufräumen
        ~liste ()
        {
            listenelement* i = first;
            while (i)
            {
                listenelement* current = i;
                i = i->next;
                delete current;
            }
        }
    
        // Entspricht "elementanhaengen". Die Daten werden als Referenz übergeben.
        void append (daten const& dat)
        {
            listenelement* neu = new listenelement;
            // Die Abfrage ist unnötig, new wirft eine Ausnahme (std::bad_alloc)
            // wenn was schief geht und springt aus dieser Methode raus
            neu->pdat = dat;
            neu->next = first;
            first = neu;
        }
    
        // Eine solche Methode ist kein guter Stil! Entspricht deinem "listezeigen".
        void show ()
        {
            int index = 1;
    
            listenelement* hilf = first;
    
            // Die malloc-Zeile war Unfug
    
            if (hilf == 0)
                std::cout<< "Die Liste ist nicht vorhanden!!" << std::endl;
            else
                while (hilf != 0)
                {
                    std::cout << "Flugnummer: " << hilf->pdat->flugnr << std::endl; 
                    std::cout << "Nationalitaet: " << hilf->pdat->natio << std::endl; 
                    std::cout << "Treibstoffmenge: " << hilf->pdat->liter << std::endl; 
                    ++index;
    
                    hilf->next = hilf;
                }
        }
    
    private:
        // Wie listenelement aussieht geht keinen was an.
        struct listenelement
        {
            daten pdat; // in C++ sind structs bereits Typnamen,
                        // Zeiger brauchen wir hier nicht
            listenelement* next;
        };
    
        listenelement* first;
    };
    
    // Entspricht "listenelementeingeben". Hierfür gilt dasselbe wie für liste::show.
    daten get_data ()
    {
        // malloc (und auch new) macht in dieser Variante keinen Sinn, da die Liste
        // Kopien der angehängten Objekte anlegt. Wir können also getrost auf dem
        // Stack rumwerken.
        daten res;
    
        std::cout << "Flugnummer:" << std::endl; 
        std::cin >> daten.flugnr;
    
        std::cout << "Nationalitaet:" << std::endl; 
        std::cin >> daten.natio;
    
        std::cout << "Treibstoffmenge:" << std::endl; 
        std::cin >> daten.liter;
    }
    
    // Wenn main nur aus einem Funktionsaufruf besteht, dann /ist/ die aufgerufene
    // Funktion main! (Es gibt zu wenig Ausnahmen von dieser Regel, als dass du eine
    // davon getroffen haben könntest ;))
    // Außerdem liefert main /immer/ ein int zurück. Sowohl in C als auch in C++.
    int main ()
    {
        int wahl;
        struct daten* neu;
    
        liste l;
    
        std::cout << " M E N U E \n\n" << std::endl;
    
        do
        {
            std::cout << "Auswahl:\n\n" << "1. Liste anzeigen\n"
                                        << "2. Eintrag in Liste einfuegen\n"
                                        << "0. Ende" << std::endl;
            std::cin >> wahl;
    
            switch (wahl)
            {
            case 0: std::cout << "Ende" << std::endl;
                    break;
            // Der "Aufruf", der hier stand war Myll. Brauchen wir aber auch nicht.
            case 1: l.show ();
                    break;
            case 2: l.append (get_data ());
                    break;
            default: std::cout << "Falsche Eingabe" << std::endl;
            }
        }
        while (wahl);
    }
    

Log in to reply