Doppelt verknüpfte Liste C - Stapel um Variable 'Liste' wurde beschädigt

Question

Ich schreibe einen Code, der eine doppelt verkettete Liste list in zwei Listen listA und listB teilt und sie ausdruckt. Code scheint Arbeit zu erledigen, aber am Ende stürzt das Programm ab. Debugger wirft Run-Time Check Failure #2 - Stack around the variable 'listA' was corrupted. und Run-Time Check Failure #2 - Stack around the variable 'list' was corrupted. Ich habe gelesen, dass dies durch nicht genügend Speicher für meine Struktur zugeordnet werden kann, aber wie viel sollte ich zuweisen?

Ganze Code:

#include <stdio.h> 
#include <stdlib.h> 

typedef struct node { 
    int val; 
    struct node* prev; 
    struct node* next; 
}Node; 
typedef struct list { 
    Node* head; 
    Node* tail; 
}List; 

void init(List* l) { 
    l->head = NULL; 
    l->tail = NULL; 
} 
Node* create(int val) { 
    Node* ptr = (Node*)malloc(sizeof(Node)); 
    ptr->val = val; 
    ptr->next = NULL; 
    ptr->prev = NULL; 

    return ptr; 
} 
void printList(const List* list) { 

    Node *ptr = list->head; 
    while (ptr != NULL) { 
     printf("%i ", ptr->val); 
     ptr = ptr->next; 
    } 
    puts(""); 
    free(ptr); 
} 
void pushLast(List* l, Node* node) { 

    if (l->head == NULL) { 
     l->head = node; 
     l->tail = node; 
    } 
    else { 
     node->prev = l->tail; 
     l->tail->next = node; 
     l->tail = node; 
    } 
} 
void splitList(const List* list) { 

    List* listA; 
    List* listB; 
    init(&listA); 
    init(&listB); 

    Node* ptr = list->head; 
    int i = 0; 
    while (ptr != NULL) { 

     Node* node = create(ptr->val); 
     if (i % 2 == 0) 
      pushLast(&listA, node); 
     else 
      pushLast(&listB, node); 
     i++; 
     ptr = ptr->next; 
    } 

    puts("Input list"); 
    printList(list); 
    puts("Odd nodes list:"); 
    printList(&listA); 
    puts("Even nodes list:"); 
    printList(&listB); 
} 

int main(void) { 

    List* list; 
    init(&list); 

    int i; 
    for (i = 1; i <= 10; i++) { 
     Node* node = create(i); 
     pushLast(&list, node); 
    } 
    splitList(&list); 
    return 0; 
} 

Ausgabe erhalten:

Input list: 
1 2 3 4 5 6 7 8 9 10 
Odd nodes list: 
1 3 5 7 9 
Even nodes list: 
2 4 6 8 10 

Jede Hilfe wird begrüßt.

Answer 1

Zuerst weisen Sie den Speicher für die Zeiger list, listA und listB nicht zu.

Zweitens definieren Sie list, listA und listB als List *. Übergeben Sie dann &list, &listA, &listB - die vom Typ List ** sind - an Ihre Funktionen, während Ihre Funktionen erwarten List *.

Sie müssen die folgenden Änderungen in splitList() vornehmen. (Gezeigte nur relevanten Teil des Codes, den Fehler hat - oder die Zugabe von malloc müssen):

void splitList(const List* list) 
{ 
    List *listA; 
    List *listB; 

    /* Allocate memory to which these pointers will point */ 
    if ((listA = malloc(sizeof(List))) == NULL) { 
     /* Error handling code */ 
     exit(1); 
    } 
    if ((listB = malloc(sizeof(List))) == NULL) { 
     /* Error handling code */ 
     exit(1); 
    } 

    /* ... */ 
    while (ptr != NULL) 
    { 
      Node* node = create(ptr->val); 
      if (i % 2 == 0) 
        /* pushLast(&listA, node); */ /* ISSUE here */ 
        pushLast(listA, node); 
      else 
        /* pushLast(&listB, node); */ /* ISSUE here */ 
        pushLast(listB, node); 
      i++; 
      ptr = ptr->next; 
    } 

    /* ... */ 

    puts("Odd nodes list:"); 
    /* printList(&listA); */ /* ISSUE here */ 
    printList(listA); 
    free(ListA); /* Free 1 */ 
    puts("Even nodes list:"); 
    /* printList(&listB); */ /* ISSUE here */ 
    printList(listB); 
    free(ListB); /* Free 2 */ 
} 

Auch müssen Sie ähnliche Änderungen in Haupt machen:

int main(void) 
{ 
    List* list; 

    /* Allocate memory */ 
    if((list = malloc(sizeof(List))) == NULL) { 
     /* Error handling code */ 
     exit(1); 
    } 

    /* init(&list); */ /* ISSUE here */ 
    init(list); 

    int i; 
    for (i = 1; i <= 10; i++) 
    { 
      Node* node = create(i); 
      /* pushLast(&list, node); */ /* ISSUE here */ 
      pushLast(list, node); 
    } 
    /* splitList(&list); */ /* ISSUE here*/ 
    splitList(list); 
    free(list); /* free 3 */ 

    return 0; 
} 

Beachten Sie auch, dass Sie brauchen, um richtig zu free Der gesamte Speicher, der mit malloc zugewiesen wurde, um Speicherlecks zu vermeiden. Es kann gesehen werden, dass Sie sind NICHT befreien alle Knoten in. Alle Sie haben free d ist nur one Knoten in printList() Funktion.