C语言练习：向链表添加结构体异常问题求助

Hey there! Let's dig into this—this is a super common pitfall when working with structs and linked lists in C, so you’re definitely not alone here. The two main issues you’re describing (identical memory addresses for new structs, or duplicate content in the list) almost always boil down to incorrect memory management or pointer handling. Let’s break down the most likely causes and how to fix them.

Common Culprits & Fixes #

1. Returning Pointers to Local Stack Variables #

This is the #1 reason all your nodes end up with the same address. When you define a struct as a local variable inside a function (like struct Node new_node;), it lives on the stack. Once the function returns, that stack memory is released and gets reused for subsequent function calls. So every time you call your node-creation function, you’re returning a pointer to the same recycled stack address.

Bad Example:

typedef struct Node {
    int data;
    struct Node* next;
} Node;

// ❌ Wrong: Returns pointer to stack memory
Node* create_node(int data) {
    Node new_node; // Local stack variable
    new_node.data = data;
    new_node.next = NULL;
    return &new_node; // Stack address gets reused!
}

Fix: Use malloc() to allocate memory on the heap, which persists outside the function. Always check for allocation failures too—don’t skip that!

// ✅ Correct: Allocates heap memory for the node
Node* create_node(int data) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    if (new_node == NULL) {
        fprintf(stderr, "Memory allocation failed!\n");
        exit(EXIT_FAILURE);
    }
    new_node->data = data;
    new_node->next = NULL;
    return new_node;
}

2. Reusing the Same Struct Instance/Pointer #

If you’re accidentally reusing a single struct variable or pointer (like a global variable, or a pointer you never reallocate), every new "node" you add will just overwrite the same data and point to the same address.

Bad Example:

// ❌ Wrong: Reusing a global struct
Node global_node;

Node* create_node(int data) {
    global_node.data = data;
    global_node.next = NULL;
    return &global_node; // Same address every time!
}

Fix: Ensure every node gets its own fresh allocation (like the malloc() example above). Never reuse the same pointer for multiple nodes without reallocating.

3. Forgetting to Initialize Struct Members #

If you don’t fully initialize a new struct (especially when using malloc(), which doesn’t zero out memory), leftover data from previous allocations can make nodes look identical. Use calloc() instead if you want zero-initialized memory, or explicitly set every member.

Fix:

// Option 1: Use calloc to zero-initialize memory
Node* new_node = (Node*)calloc(1, sizeof(Node));

// Option 2: Explicitly initialize all members
Node* new_node = (Node*)malloc(sizeof(Node));
if (new_node != NULL) {
    new_node->data = data;
    new_node->next = NULL; // Don't skip this!
}

Troubleshooting Steps to Verify #

• Print addresses immediately: Right after creating a new node, print its address with printf("New node address: %p\n", new_node);—if they’re the same, you’re reusing memory.
• Check for malloc failures: If malloc returns NULL, your program might be silently reusing old pointers (though this usually causes crashes too).
• Trace list additions: Step through your code with a debugger to see if you’re adding the same pointer to the list multiple times, or overwriting existing node data.

Full Working Example #

Here’s a complete, corrected linked list implementation that avoids these issues:

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

typedef struct Node {
    int data;
    struct Node* next;
} Node;

Node* create_node(int data) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    if (new_node == NULL) {
        fprintf(stderr, "Memory allocation failed!\n");
        exit(EXIT_FAILURE);
    }
    new_node->data = data;
    new_node->next = NULL;
    return new_node;
}

void add_to_list(Node** head, int data) {
    Node* new_node = create_node(data);
    if (*head == NULL) {
        *head = new_node;
    } else {
        Node* temp = *head;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = new_node;
    }
}

void free_list(Node** head) {
    Node* temp;
    while (*head != NULL) {
        temp = *head;
        *head = (*head)->next;
        free(temp);
    }
}

int main() {
    Node* head = NULL;
    add_to_list(&head, 1);
    add_to_list(&head, 2);
    add_to_list(&head, 3);
    
    // Print list to verify unique addresses and data
    Node* temp = head;
    while (temp != NULL) {
        printf("Data: %d, Address: %p\n", temp->data, temp);
        temp = temp->next;
    }
    
    free_list(&head); // Always free heap memory!
    return 0;
}

内容的提问来源于stack exchange，提问作者Link