C语言新手求助：抽离代码后动态数组扩展返回主函数丢失数据

Hey there, let's break down what's likely going on here—this is a super common pitfall for folks new to C, so don't stress too much about it! Based on your description, here are the most probable causes and how to fix them:

1. You're returning a pointer to a stack-allocated array (the #1 culprit) #

If inside read_deck you declared your array like this:

int temp_deck[some_size];

That array lives on the stack, which gets cleaned up as soon as the function finishes executing. When you return a pointer to this array to main(), you're left with a dangling pointer—accessing it is undefined behavior. Sometimes the first element might still look valid (stack residue), but everything else is garbage.

Fix: Use dynamic memory allocation with malloc()/realloc() instead:

int* read_deck(int* final_size) {
    // Start with an initial dynamic array
    int* deck = malloc(4 * sizeof(int)); // Example initial size
    if (deck == NULL) {
        // Handle allocation failure!
        *final_size = 0;
        return NULL;
    }

    // When you need to expand the array:
    int new_size = 8; // Example expanded size
    int* temp = realloc(deck, new_size * sizeof(int));
    if (temp != NULL) {
        deck = temp; // Only update if realloc succeeded
        *final_size = new_size; // Pass the final size back to main
    } else {
        // Handle realloc failure (don't leak memory!)
        free(deck);
        *final_size = 0;
        return NULL;
    }

    // Populate your deck here...

    return deck;
}

Then in main():

int deck_size;
int* my_deck = read_deck(&deck_size);
// Use my_deck, then free it when done:
free(my_deck);

2. You're not updating the array pointer correctly in main() #

If you're passing the array pointer to read_deck as a regular parameter (not a pointer-to-pointer), any realloc() calls inside the function won't update the pointer in main(). That's because parameters in C are passed by value—you're modifying a copy of the pointer inside read_deck.

Bad example:

void read_deck(int* deck, int* size) {
    // This realloc changes the local 'deck' pointer, not the one in main!
    deck = realloc(deck, *size * 2 * sizeof(int));
    *size *= 2;
}

Fix: Use a double pointer to modify the original pointer in main():

void read_deck(int** deck, int* size) {
    int* temp = realloc(*deck, *size * 2 * sizeof(int));
    if (temp != NULL) {
        *deck = temp; // Update the original pointer in main
        *size *= 2;
    }
}

Call it like this in main():

int deck_size = 4;
int* my_deck = malloc(deck_size * sizeof(int));
read_deck(&my_deck, &deck_size);

3. You're using the wrong array length in main() #

Even if your pointer is valid, if you're not passing the final expanded size back to main(), you might be looping over fewer elements than you think. For example, if read_deck expands the array to 20 elements but main() only uses the initial size of 1, you'll only see the first element. Always pass the final size back via an output parameter (like the examples above).

Quick Debugging Tips #

• In gdb, right before read_deck returns, print the pointer address with p deck and the values of a few elements (e.g., p deck[0], p deck[5]).
• Then in main(), immediately after receiving the pointer, print the same pointer address and elements. If the addresses don't match, you have a pointer update issue. If the addresses match but elements are garbage, you're probably returning a stack pointer.

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