C ++链表实现访问数据

Question

I have the custom Linked list implementation below:

#include<iostream>

using namespace std;


struct Node {
    public:
    int data;
    struct Node *next = NULL;
};


class LinkedList {

    public:
        struct Node *head;
        int length = 0;

        void add(double item);
        void add_2(double item);
        void printLL();

};

void LinkedList::add_2(double item) {

    struct Node *node = new Node();
    node->data = item;
    node->next = head;

    head = node;
    length++;   
}

void LinkedList::add(double item) {
    struct Node node;
    node.data = item;
    node.next = head;
    head = &node;
    length++;
}

void LinkedList::printLL() {
    struct Node *cur_node;
    cur_node =  head;
    int i = 0;
    while (i<length) {
        cout << cur_node->data << " ";
        cur_node = cur_node->next;
        i++;
    }
}

It works fine with the driver code below:

int main() {
    LinkedList ll = LinkedList();
    ll.add(212);
    // cout << ll.head->data<<endl;
    ll.add_2(2123); 
    //ll.printLL();
    ll.add_2(2123);
    ll.printLL();
    return 0;
}

When I try to access the data in the driver code the output gets messed up:

int main() {
    LinkedList ll = LinkedList();
    ll.add(212);
    cout << ll.head->data<<endl;
    ll.add_2(2123); 
    //ll.printLL();
    ll.add_2(2123);
    ll.printLL();
    return 0;
}

Result:

2123 2123 7339552

Expected:

2123 2123 212

Why is it that accessing the data from the driver code cout << ll.head->data<<endl changing the reference.

Answer 1

void LinkedList::add(double item) {
    struct Node node;

node is a local variable with automatic storage. Objects with automatic storage are destroyed automatically at the end of the scope (in this case, at the end of the function)

    head = &node;

You set the member head to point to the local variable. After the function returns, the pointed node no longer exists and the pointer is left dangling. Indirecting through the danging pointer has undefined behaviour.

Solution: Get rid of the broken add function. You already have a working add_2 function. However, you do leak all the allocated memory.

Answer 2

Your implementation of linked list have problem with node variable usage. It should be a pointer struct Node *node = new Node. With this declaration and initialization, the node pointer will be in heap memory section and still live outside of method add_2. with your implementation, it is in stack scope, and it will be invalid outside of method add_2.
For stopping memory leak, you need to implement the constructor and destructor of LinkedList. With that way, when the LinkedList object is out of scope, its destructor will be called and free the dynamic memory that allocated by add_2 or add. You could add more method such as remove, empty,... to complete a LinkedList.

#include <iostream>

using namespace std;

struct Node {
public:
    int data;
    struct Node *next = NULL;
};


class LinkedList {

public:
    LinkedList() : head(NULL), length(0)
    {

    }
    ~LinkedList()
    {
        struct Node *current = head;
        struct Node *prev = NULL;
        while (current != NULL)
        {
            prev = current;
            current = current->next;
            delete prev;
        }
        length = 0;
    }

    struct Node *head;
    int length = 0;

    void add(double item);
    void add_2(double item);
    void printLL();

};


// modified add is similar to add_2
void LinkedList::add(double item) {
    struct Node *node = new Node();
    node->data = item;
    node->next = head;

    head = node;
    length++;
}

void LinkedList::add_2(double item) {
    struct Node *node = new Node();
    node->data = item;
    node->next = head;

    head = node;
    length++;
}

void LinkedList::printLL() {
    struct Node *cur_node;
    cur_node = head;
    int i = 0;
    while (i < length) {
        cout << cur_node->data << " ";
        cur_node = cur_node->next;
        i++;
    }
}




int main() {
    LinkedList ll = LinkedList();
    ll.add_2(212);
    ll.add_2(2123);
    //ll.printLL();
    ll.add_2(2123);
    ll.printLL();
    return 0;
}