Laufzeitfehler Speicherzuordnung

Question

Der obige Code erfolgreich kompiliert wurde, aber wenn ich versuche, es zu laufen, wirft es einen malloc Fehler:

malloc: * error for object 0x7fdbf6402800: pointer being freed was not allocated * set a breakpoint in malloc_error_break to debug

Es sieht aus wie ich einige Objekte zu zerstören versuchte, die nicht waren initialisiert, aber ich konnte nicht herausfinden, wie ich es beheben kann.

#include <iostream> 
template <class T> 
class Node { 

public: 
    T data; 
    Node<T>* next; 
    Node<T>* prev; 

    Node(): data(), next(nullptr), prev(nullptr) { } 
    Node(T dt): data(dt), next(nullptr), prev(nullptr) { } 
    Node(T dt, Node* n): data(dt), next(nullptr), prev(n) { } 

    T get() { return data; } 
}; 

template <class T> 
class Stack { 

public: 
    Node<T>* head; 
    Node<T>* tail; 

    Stack(): head(nullptr), tail(nullptr) { } 
    ~Stack() { 
     Node<T>* temp = head; 
     while(temp) { 
      delete temp; 
      temp = temp->next; 
     } 
    } 

    bool empty() const; 
    Stack& push(T); 
    Stack& pop(); 
}; 

template <class T> 
bool Stack<T>::empty() const { 
    return head == nullptr; 
} 

template <class T> 
Stack<T>& Stack<T>::push(T x) { 
    if (head == nullptr) { 
     head = new Node<T>(x); 
     tail = head; 
    } 
    // It seems that problem occurs here 
    else { 
     Node<T>* temp = tail; 
     tail = new Node<T>(x, tail); 
     tail->prev = temp; 
     temp->next = tail; 
    } 

    return *this; 
} 

template <class T> 
Stack<T>& Stack<T>::pop() { 
    if (!head) { 
     return *this; 
    } 
    else if (head == tail) { 
     delete head; 
     head = nullptr; 
     tail = nullptr; 
    } 
    else { 
     Node<T>* temp = tail; 
     delete tail; 
     tail = temp; 
    } 

    return *this; 
} 

int main() { 
    Stack<int> istack; 
    istack.push(5); 
    istack.push(3); 
    istack.push(4); 
    istack.push(7); 
    istack.pop(); 
} 

Answer 1

Wenn Sie an Ihrem destructor aussehen - Sie haben einen Fehler

~Stack() { 
    Node<T>* temp = head; 
    while(temp) { 
     delete temp; 
     temp = temp->next; // Here temp is no longer a valid pointer 
          // You have just deleted it! 
    } 
} 

die So schreiben folgende

~Stack() { 
    while(head) { 
     Node<T>* temp = head->next; 
     delete head 
     head = temp; 
    } 
} 

EDIT

Wie bereits ausgeführt pop braucht etwas Arbeit . d. h.

template <class T> 
Stack<T>& Stack<T>::pop() { 
    if (!head) { 
     return *this; 
    } 

    Node<T>* temp = tail->next; 
    delete tail; 
    tail = temp; 
    if (!tail) { 
     head = nullptr; 
    } 
    return *this; 
}