Speicherzugriffsfehler verkettete Liste (C)



  • Hallo Liebe Programmier-Freunde,

    für die Uni muss ich in C ein Programm schreiben in welchem ich eine verkettete Liste erstellen soll, sie ausgeben soll und ergänzen. Allerdings bekomme ich beim Ausführen keine Syntaxfehler, sondern nur den Fehler (Thread 1: EXC_BAD_ACCESS (code=1, address=0x8)). Ich hab den Fehler auch schon gegoogelt und weiß, dass es was mit den Pointern zutun hat. Allerdings sind Pointer für mich nach wie vor ein wenig abstrakt weswegen es mir schwer fällt den Fehler zu erkennen.
    Hoffe einer von euch kann mir helfen und bitte entschuldigt, falls euch die Syntax nicht so gefällt (bin noch frisch)

    LG Fasterlong

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    typedef struct LNodeStruct LNode;
    LNode* create_list(void);
    void delete_list(LNode* node);
    void print(LNode* node);
    void print_reverse(LNode* node);
    LNode* prepend_val(LNode* node, unsigned char val);
    LNode* append_val(LNode* node, unsigned char val);
    
    struct LNodeStruct{
        unsigned char value;
        LNode* next;
        LNode* prev;
    };
    
    
    LNode* create_list(void)
    {
            LNode* node = malloc(sizeof(LNode));
    
            node->value = 255;
            node->next = NULL;
            node->prev = NULL;
    
            return node;
    }
    
    
    void delete_list(LNode* node)
    {
        while (node->prev != NULL)
        {
            node = node->prev;
        }
        
             while(node != NULL)
            {
                LNode *nextptr = node ->next;
                    free(node);
                    node = nextptr;
            }
    
    }
    
    
    void print(LNode* node)
    {
        while(node->prev != NULL)
            {
                node = node->prev;
            }
    
            while(node != NULL)
            {
                    printf("%c", node->value);
                    node = node->next;
            }
            printf("\n");
    }
    
    void print_reverse(LNode* node)
    {
    
            while(node->next != NULL)
            {
                    node = node->next;
            }
    
            while(node != NULL)
            {
                    printf("%c", node->value);
                    node = node->prev;
            }
            printf("\n");
    }
    
    
    
    LNode* prepend_val(LNode* node, unsigned char val)
    {
            while(node->prev != NULL)
            {
                    node = node->prev;
            }
    
            LNode* temp_ptr = create_list();
            temp_ptr->value = val;
            temp_ptr->next = node;
            node->prev = temp_ptr;
    
            return temp_ptr;
    
    }
    
    
    LNode* append_val(LNode* node, unsigned char val)
    {
             while(node->next != NULL) (Thread 1: EXC_BAD_ACCESS (code=1, address=0x8))
            {
                    node = node->next;
            }
    
            LNode* temp_ptr = create_list();
            temp_ptr->value = val;
            temp_ptr->prev = node;
            node->next = temp_ptr;
    
            return temp_ptr;
    }
    
    
    int main(void)
    {
        LNode* grosseZahlEiner = append_val(NULL, 5);
        LNode* grosseZahlZehner = append_val(grosseZahlEiner, 2);
        LNode* grosseZahlHunderter = append_val(grosseZahlZehner, 1);
        
        print(grosseZahlZehner);
        print_reverse(grosseZahlHunderter);
        
        delete_list(grosseZahlHunderter);
        
        return 0;
    }
    
    


  • @Fasterlong sagte in Speicherzugriffsfehler verkettete Liste (C):

    Ich hab den Fehler auch schon gegoogelt und weiß, dass es was mit den Pointern zutun hat.

    👍

    @Fasterlong sagte in Speicherzugriffsfehler verkettete Liste (C):

    Allerdings sind Pointer für mich nach wie vor ein wenig abstrakt

    Wie hast du das Programm dann geschrieben?

    Schau dir mal die erste Zeile in deiner main an. Da wird append_val aufgerufen. Und jetzt schau dir die erste Zeile in append_val an. Fällt dir was auf?



  • Ich habe in meinem ganzen Leben noch keine selbst-kreierte verkettete Liste gebraucht.

    Warum wird man nicht eines Besseren auf der Uni gelehrt.



  • @eigenartig

    👍 Ich habe auch noch nie (>30Jahre) verkettete Listen gebraucht.
    ...
    Das liegt daran, dass die Hochschulprofessoren (und Buchautoren und Tutorialschreiberlinge) keine Ahnung von der Praxis haben und zu faul sind, sich was Praxisnahes auszudenken.



  • @Wutz sagte in Speicherzugriffsfehler verkettete Liste (C):

    Das liegt daran, dass die Hochschulprofessoren (und Buchautoren und Tutorialschreiberlinge) keine Ahnung von der Praxis haben und zu faul sind, sich was Praxisnahes auszudenken.

    @eigenartig sagte in Speicherzugriffsfehler verkettete Liste (C):

    Warum wird man nicht eines Besseren auf der Uni gelehrt.

    Und ich dachte schon, ich hätte eine Wahrnehmungsstörung. In der Praxis Entwicklung von u.a. Microservices und Frontends mit JWT-Authentifizierung und strikten Test Coverage-Vorgaben. An der Hochschule: "bauen Sie eine AWT-Anwendung, welche ein Gesicht mit beweglichen Augen wie im Beispiel anzeigt blablabli". Zum Kotzen.



  • @Mechanics Habe den Fehler gefunden. Ich musste in die append_val Funktion mit einer if-Anweisung noch den Fall abdecken, dass mein Pointer == NULL ist.
    Trotzdem danke für eure Hilfe! 🙂

    LNode* append_val(LNode* node, unsigned char val)
    {
        LNode* temp_ptr = create_list();
        
        if (node == NULL) {
            temp_ptr->value = val;
            temp_ptr->prev = node;
        }
        else
        {
            while(node->next != NULL)
            {
                    node = node->next;
            }
            temp_ptr->value = val;
            temp_ptr->prev = node;
            node->next = temp_ptr;
        }
    
            return temp_ptr;
    }
    


  • Also ich hab schon verkettete Listen gebraucht.
    In einem Windows-Treiber 🙂
    Für wenn mehrere Einträge im selben Bucket eines Hash-Tables landen.
    Dort hab ich aber auch die fertigen SDK Funktionen verwendet anstatt mir das selbst zu schreiben. Auch wenn es nur ein paar Zeilen sind.

    Wenn man sehr low-leveliges Zeugs macht, kann es von Vorteil sein zu wissen wie man das macht. Aber auch so ... ich denke dass es nicht schadet sowas mal verstanden zu haben. Bzw. allgemein was es so für standard Datenstrukturen gibt und wie die funktionieren. Ist mMn. auch eine gute Übung um Zeiger zu verstehen -- etwas womit der OP ja nach eigener Aussage Probleme hat.



  • @Wutz sagte in Speicherzugriffsfehler verkettete Liste (C):

    @eigenartig

    👍 Ich habe auch noch nie (>30Jahre) verkettete Listen gebraucht.
    ...
    Das liegt daran, dass die Hochschulprofessoren (und Buchautoren und Tutorialschreiberlinge) keine Ahnung von der Praxis haben und zu faul sind, sich was Praxisnahes auszudenken.

    Ich habe noch nie überhaupt ne Liste gebraucht. Bei mir dominieren Arrays(Vectoren) und Maps und dann noch die eine oder andere exotische Queue.



  • @It0101 sagte in Speicherzugriffsfehler verkettete Liste (C):

    Ich habe noch nie überhaupt ne Liste gebraucht.

    Dann taugt dein Pointer auch nix.



  • @eigenartig care to elaborate? ya talkin bullshit man.

    Nebenbei: Viel in der Win32-API ist über verkettete Listen gelöst. Selber eine schreiben ... weiß nich. Vielleicht? Wenns was bringt? Aber Rocket-Science Atomic Physics ist das jetzt auch nicht.



  • Nukular, das Wort heisst nukular!



  • This post is deleted!


  • Ich dachte, dass hätte mit Atomics zu tun! 😉

    Edit: ich bin außerdem sehr kluk. K-L-U-K!



  • @hustbaer sagte in Speicherzugriffsfehler verkettete Liste (C):

    Nukular, das Wort heisst nukular!

    Macht nichts. Ist eine Liste auch nicht. ^^



  • @eigenartig sagte in Speicherzugriffsfehler verkettete Liste (C):

    @It0101 sagte in Speicherzugriffsfehler verkettete Liste (C):

    Ich habe noch nie überhaupt ne Liste gebraucht.

    Dann taugt dein Pointer auch nix.

    Was willst du mir sagen? 😃 Mein Pointer ist sehr lang und sehr dick!



  • @Fasterlong
    Du solltest den Umgang mit einem Debugger lernen. Der wird dir nämlich die genaue Zeile zeigen können, die den Fehler auslöst. Dann musst du nur noch lernen, wie Pointer funktionieren und den beheben.

    Und fürs Protokoll, ich hab auch schon verkette Listen gebraucht. Das Konzept sollte man zumindest kennen und verstehen. Ich sehe aber auch das viele das vermutlich nie umsetzen müssen und man das dann immer noch im Detail nachlesen kann.



  • Ja damit meinte ich, dass vorherige Pointer ungültig werden, sobald man einen Vektor vergrößert oder verkleinert.

    Da könnte eine verkettete Liste in Frage kommen, wenn man ewig wehrende Iteratoren / Pointer braucht. 🙂



  • Tja, die Pointer wehren sich halt (gegen ihre Benutzung). 😉

    Du meintest wohl "ewig währende"...



  • Also benutzt bei der Programmierung habe ich eine verkette Liste auch noch nicht.

    Aber in einer meiner Vorlesungen, die ich aktuell habe "Betriebssysteme" lautet die Antwort auf die Frage "Wie realisiere ich ..." zu 90% verkettete Liste.

    Naja oder zumindest ist verkettete Liste immer eine mögliche Option zum realisieren, die beste ist es meistens nicht 🙂