C语言音乐库链表程序问题：创建新节点时错误覆盖头节点

Hey Eric, let's break down what's probably causing your head node's song name to get overwritten when you add new entries—this is a super common pitfall in C when dealing with strings and linked lists, so you're not alone here!

The Most Likely Culprit: Shared Memory Pointers #

Chances are, all your nodes are pointing to the same memory buffer for their song_name (and maybe artist/genre too). Here's how that happens:

• If you're using a single global or stack-allocated char array to read user input (like char input[256];), and then just assign node->song_name = input; instead of copying the string, every node's song_name pointer will point to that same array.
• When you read a new song name into the array, it overwrites the old content—so every node that references that array will suddenly show the new song name, including your head node.

How to Fix It #

You need to ensure each node's string fields have their own independent memory space. Here's how to do that properly:

1. Allocate Memory for Each String

Instead of assigning pointers directly to your input buffer, use malloc (or strdup, if your system supports it) to create a copy of the input string for each node.

Example of a safe node creation function:

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

typedef struct Song {
    char *song_name;
    char *artist;
    char *genre;
    struct Song *next;
} Song;

Song* create_new_song(const char *name, const char *artist, const char *genre) {
    Song *new_node = malloc(sizeof(Song));
    if (!new_node) {
        perror("Failed to allocate node memory");
        return NULL;
    }

    // Allocate memory for each string and copy the content
    new_node->song_name = malloc(strlen(name) + 1);
    new_node->artist = malloc(strlen(artist) + 1);
    new_node->genre = malloc(strlen(genre) + 1);

    // Check if any memory allocation failed (clean up if so!)
    if (!new_node->song_name || !new_node->artist || !new_node->genre) {
        free(new_node->song_name);
        free(new_node->artist);
        free(new_node->genre);
        free(new_node);
        perror("Failed to allocate string memory");
        return NULL;
    }

    strcpy(new_node->song_name, name);
    strcpy(new_node->artist, artist);
    strcpy(new_node->genre, genre);
    new_node->next = NULL;

    return new_node;
}

2. Fix Your Input Handling

When reading user input, make sure you copy the input into the node's allocated memory instead of pointing to the input buffer. For example:

// Bad: Points all nodes to the same buffer
char input_buffer[256];
fgets(input_buffer, sizeof(input_buffer), stdin);
// Remove newline from input
input_buffer[strcspn(input_buffer, "\n")] = '\0';
Song *bad_node = malloc(sizeof(Song));
bad_node->song_name = input_buffer; // ❌ Shared buffer!

// Good: Uses unique memory for each node
char input_buffer[256];
fgets(input_buffer, sizeof(input_buffer), stdin);
input_buffer[strcspn(input_buffer, "\n")] = '\0';
Song *good_node = create_new_song(input_buffer, "Artist Name", "Rock"); // ✅ Copies string

3. Double-Check Your Sorted Insert Logic

Make sure your insertion code isn't accidentally modifying the head node's content instead of just rearranging pointers. For example, avoid accidental assignment (=) instead of comparison (== or strcmp) in your sorting conditionals.

Here's a safe sorted insert function to reference:

Song* insert_sorted(Song *head, Song *new_node) {
    // If list is empty, new node becomes head
    if (!head) {
        return new_node;
    }

    // Insert at the beginning if new song comes before head alphabetically
    if (strcmp(new_node->song_name, head->song_name) < 0) {
        new_node->next = head;
        return new_node;
    }

    // Traverse to find the correct insertion point
    Song *current = head;
    while (current->next && strcmp(new_node->song_name, current->next->song_name) >= 0) {
        current = current->next;
    }

    new_node->next = current->next;
    current->next = new_node;

    return head;
}

Bonus: Don't Forget to Clean Up Memory #

To avoid memory leaks, always write a function to destroy your linked list and free all allocated memory:

void destroy_library(Song *head) {
    Song *temp;
    while (head) {
        temp = head;
        head = head->next;
        // Free string memory first
        free(temp->song_name);
        free(temp->artist);
        free(temp->genre);
        // Then free the node itself
        free(temp);
    }
}

Give these fixes a try—this should stop your head node's song name from getting overwritten when you add new entries. Let me know if you run into any other kinks!

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