Löschen des LinkedList-Inhalts (Destruktor)

Question

Ich habe eine kurze Frage, wie mein Destruktor im folgenden Code aufrufen wird. Ich habe den ~LinkedList() Destruktor, der Gewohnheit clear() aufruft, um dynamischen Speicher freizugeben.

Also, wenn ich die LinkedList ll_one löschen möchte, wie soll ich das tun (in source.cpp unten)? So etwas wie der Ausgang unten:

Ausgeben von verketteten Liste one ...

verkettete Liste einer {19, 18, 17, 16, 15}

Destruktor aufgerufen

Ausgeben von verketteten Liste eine ...

verlinkte Liste einer {}

---

//Node.h 
#ifndef NODE 
#define NODE 
struct Node { 
    int value; 
    Node* next; 

    Node(int i) : value(i), next(nullptr) {} 
    Node() : value(0), next(nullptr) {} 
}; 
#endif /*NODE*/ 

---

//LinkedList.h 
#ifndef LINKEDLIST 
#define LINKEDLIST 
#include <ostream> 
#include "Node.h" 

class LinkedList { 
    Node* head; 
    Node* tail; 
    std::string name; 

    void recursePrint(Node*, std::ostream&) const; 

public: 
    LinkedList(); 
    LinkedList(std::string); 
    // destrcutor declaration 
    ~LinkedList(); 
    void setName(std::string); 
    std::string getName() const; 

    void insertFront(int); 
    void insertBack(int); 
    void clear(); 
    void print() const; 
    void print(std::ostream&) const; 
    void printReverse() const; 
    void printReverse(std::ostream&) const; 

    friend std::ostream& operator<<(std::ostream&, const LinkedList&); 

}; 
#endif /*LINKEDLIST*/ 

---

//LinkedList.cpp 
#include <iostream> 
#include <string> 
#include "LinkedList.h" 
using namespace std; 

LinkedList::LinkedList() : head(nullptr), tail(nullptr) {} 
LinkedList::LinkedList(string name) : 
    head(nullptr), tail(nullptr), name(name) {} 

// Define destructor 
LinkedList::~LinkedList() { 
    cout << "caling destructor" << endl; 
    clear(); 
} 

void LinkedList::setName(string name) { 
    this->name = name; 
} 

string LinkedList::getName() const{ 
    return name; 
} 

void LinkedList::insertFront(int value) { 
    Node* newNode = new Node(value); 
    newNode->next = head; // attach to list 
    head = newNode; 
    if (tail == nullptr) { // empty list 
     tail = newNode; // only node is both head and tail 
    } 
} 

void LinkedList::insertBack(int value) { 
    Node* newNode = new Node(value); 
    if (tail != nullptr) 
     tail->next = newNode; // attach to list 
    tail = newNode; 
    if (head == nullptr) { // empty list 
     head = newNode; // only node is both head and tail 
    } 
} 

// Define 
void LinkedList::clear() { 
    Node* temp; 
    while (head != NULL) { 
     temp = head->next; 
     delete head; 
     head = temp; 
    } 
    head = tail = NULL; 


} 

void LinkedList::print() const { 
    print(cout); 
} 

void LinkedList::print(ostream& os) const { 
    os << this; 
} 

void LinkedList::printReverse() const { 
    printReverse(cout); 
} 

void LinkedList::printReverse(ostream& os) const { 
    os << this->name << ": "; 
    Node* current = this->head; 
    if (current == nullptr) { 
     os << "<Empty List>"; 
    } 
    else 
     recursePrint(current, os); 
    os << endl; 
} 

void LinkedList::recursePrint(Node* node, ostream& os) const { 
    if (node != nullptr) { 
     recursePrint(node->next, os); 
     os << node->value << " "; 
    } 
} 

ostream& operator<<(ostream& os, const LinkedList& ll) { 
    os << ll.getName() << " {"; 
    Node* current = ll.head; 
    if (current == nullptr) { 
     os << " <Empty List>"; 
    } 
    while (current != nullptr) { 
     if (current != ll.head) 
      cout << ","; 
     cout << " " << current->value; 
     current = current->next; 
    } 
    cout << " }"; 
    return os; 
} 

---

//Source.cpp 
#include <iostream> 
#include "LinkedList.h" 
using namespace std; 

int main() { 
    LinkedList ll_one("Linked List one"); 
    int num = 0; 
    for (unsigned int i = 15; i < 20; ++i) { 
     ll_one.insertFront(i); 
    } 
    cout << "Outputting Linked List one..." << endl; 
    cout << ll_one << endl; 

    // How to delete the ll_one? 
    cout << "Outputting Linked List one..." << endl; 
    cout << ll_one << endl; 

    system("pause"); 
} 

Answer 1

ll_one wird auf dem Stack angelegt. Wenn dieses Objekt den Bereich von main verlässt, wird es automatisch ausgeblendet und sein Destruktor wird aufgerufen. Sie sollten nur manuell löschen müssen, wenn Sie es auf dem Heap zuordnen.

Hier ist ein Beispiel für die Zuweisung auf dem Heap.

LinkedList* ll_one = new LinkedList(); 
delete ll_one; 

Wenn Sie die Liste leeren möchten, oder jeden Raum frei bis es vor seinem gelöscht verwendet, wird dann rufen Sie klar.

Heap

LinkedList* ll_one = new LinkedList(); 
ll_one->clear(); 
delete ll_one; 

Stapel

LinkedList ll_one; 
ll_one.clear();