Hey there, let's break down this frustrating malloc error you're hitting when working on your linked list delete function. First, let's make sure you understand what the error is telling you:

malloc: * error for object 0x7ffeefbff5d8: pointer being freed was not allocated

This means you're calling free() on a memory address that was never allocated using malloc(), calloc(), or realloc(). The address 0x7ffeefbff5d8 is a dead giveaway—it starts with 0x7ffe, which is typical of stack memory (the system manages stack memory automatically; you never need to free it).

Common Causes & Quick Fixes #

Here are the most likely issues and how to fix them:

1. You're trying to free a stack-allocated node #

If you created a node on the stack (instead of the heap) and then tried to free its address, this error will fire. Stack variables are automatically cleaned up when they go out of scope—you don't get to call free on them.

Wrong code example:

// Node is allocated on the stack (no malloc!)
Node stackNode;
stackNode.data = 42;
stackNode.next = NULL;

// This will trigger the error—stack memory can't be freed!
free(&stackNode);

Fix: Always allocate linked list nodes on the heap using malloc:

// Node is allocated on the heap (safe to free later)
Node *heapNode = malloc(sizeof(Node));
heapNode->data = 42;
heapNode->next = NULL;

// This is safe now
free(heapNode);

2. You're double-freeing a pointer #

If you free a node once, then accidentally free it again, the pointer becomes a "wild pointer" pointing to memory that's already been reclaimed by the system. The second free call will throw this error.

Fix: After freeing a node, set the pointer to NULL, and always check for NULL before freeing:

if (targetNode != NULL) {
    free(targetNode);
    targetNode = NULL; // Prevents accidental double-free
}

3. You're mixing up pointer variables and the memory they point to #

If your delete function is modifying the head pointer incorrectly, you might end up trying to free the pointer variable itself (which lives on the stack) instead of the heap-allocated node it points to.

Wrong code example:

// If head is a stack-allocated pointer variable (e.g., declared in main)
free(head); // This is wrong if head is just a pointer—you need to free what it points to!

Fix: When deleting the head node, use a temporary pointer to hold the node's address, update the head, then free the temporary pointer:

void deleteHead(Node **head) {
    if (*head == NULL) return;

    Node *temp = *head; // Store the node to free
    *head = (*head)->next; // Update head to point to next node
    free(temp); // Free the heap-allocated node (not the head pointer itself)
}

4. You're passing pointers by value (instead of reference) #

If your delete function takes a Node *head instead of Node **head, any changes you make to head inside the function won't affect the original pointer in your main code. This can lead to dangling pointers and accidental frees of invalid addresses.

Fix: Use a double pointer when you need to modify the original pointer (like deleting the head node or a node that changes the list structure).

Debugging in Xcode #

Xcode gives you a clear hint to fix this—here's how to use its tools:

• Set the malloc_error_break breakpoint: Go to the Breakpoint Navigator (cmd+8), click the + button, select "Add Symbolic Breakpoint", and enter malloc_error_break as the symbol. When the error occurs, Xcode will pause exactly where the invalid free is happening.
• Inspect the pointer: When paused, check the address of the pointer being freed. Use the Memory Graph Debugger (click the memory graph button in the debug toolbar) to visualize your linked list's memory—you'll be able to see which nodes are on the heap vs. stack.
• Add debug logs: Print the address of every node when you allocate and free it. This will help you track down which address is being incorrectly freed:

  Node *newNode = malloc(sizeof(Node));
  printf("Allocated node at: %p\n", newNode);
  
  // ... later in delete function
  printf("Attempting to free node at: %p\n", targetNode);
  free(targetNode);
  

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