Visual Studio下C语言链表插入崩溃：0xC0000005访问违例求助

Hey there! That crash error you're seeing—0xC0000005: access violation while writing to local 0xCDCDCDCD—is a super common gotcha when working with C linked lists in Visual Studio's Debug mode. Let's break down what's happening and how to fix it.

First, what does 0xCDCDCDCD mean? #

In Visual Studio's Debug runtime (ucrtbased.dll), the memory manager uses specific magic values to mark different memory states:

• 0xCDCDCDCD = Heap memory that's been allocated but never initialized
  When your code tries to write to this address, the runtime throws an access violation because this isn't valid, usable memory for your data.

Common Causes & Fixes #

1. You forgot to initialize a node's next pointer

When you allocate a new node with malloc(), the memory is reserved but not set to any default values. In Debug mode, it gets filled with 0xCDCDCDCD. If you don't set the next pointer to NULL (or another valid node), any later attempt to modify or traverse that pointer will crash.

Fix this by always initializing all node members after allocation:

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

Node* create_new_node(int data) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    // Always check if malloc succeeded!
    if (new_node == NULL) {
        printf("Memory allocation failed!\n");
        return NULL;
    }
    // Initialize EVERY member
    new_node->data = data;
    new_node->next = NULL; // Critical—this prevents 0xCDCDCDCD here
    return new_node;
}

2. Your linked list head pointer isn't initialized

If you declare a head pointer like Node* head; without setting it to NULL, in Debug mode it might hold a garbage value (or point to memory marked with 0xCDCDCDCD). When you try to insert your first node, your code might attempt to write to this invalid address.

Fix this by initializing the head pointer to NULL when you declare it:

Node* head = NULL; // Start with an empty list

3. Your insert function has incorrect pointer logic

If you're not using a double pointer (Node**) to modify the head pointer, your changes won't persist outside the function. This leaves the original head pointer pointing to invalid memory, causing crashes on subsequent inserts.

Here's a correct insert-at-head function using double pointers:

void insert_at_head(Node** head, int data) {
    Node* new_node = create_new_node(data);
    if (new_node == NULL) return;
    
    new_node->next = *head;
    *head = new_node;
}

4. Quick Debugging Tip

In Visual Studio, use the Watch Window to inspect your node pointers when the crash happens. Check if any next pointers have the value 0xCDCDCDCD—that's your culprit. You can set a breakpoint right before the insert operation to trace where the uninitialized pointer is coming from.

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