C语言返回数组指针时出现Segmentation Fault问题求助

Hey there! Segmentation faults when accessing array elements like result[result_i] almost always stem from invalid pointer references or mishandled memory in your solve() function. Let’s walk through the most likely issues and how to fix them:

Common Pitfalls to Check #

1. Returning a pointer to stack-allocated memory #

This is the #1 culprit for this kind of crash. If your solve() function declares an array like this:

int* solve() {
    int temp_arr[10]; // Allocated on the stack
    // ... fill temp_arr ...
    return temp_arr; // ❌ BAD: Stack memory is freed when the function exits
}

The pointer you return becomes a "dangling pointer"—it points to memory that’s no longer valid. When you try to access result[result_i] later, you’re reading/writing to random memory, triggering a segfault.

Fix: Use heap memory with malloc() (and remember to free it later to avoid leaks):

int* solve(int* return_size) {
    *return_size = 10; // Define the size of your result array
    int* result = malloc(sizeof(int) * (*return_size));
    if (result == NULL) {
        // Handle memory allocation failure (critical to avoid NULL derefs)
        *return_size = 0;
        return NULL;
    }
    // ... fill result array ...
    return result; // ✅ GOOD: Heap memory persists after function exits
}

2. Uninitialized or NULL pointers #

If your result pointer isn’t assigned to any valid memory (e.g., it’s set to NULL by default, or you forgot to allocate it), accessing result[result_i] will immediately crash. Always double-check:

• Did you allocate memory for result before using it?
• Did you check if malloc() returned NULL (it can fail if there’s no available memory)?

3. Out-of-bounds index access #

Even if your pointer is valid, if result_i is larger than or equal to the actual size of your result array, you’re accessing memory outside the array’s bounds. For example, if your array has 5 elements but result_i is 5 or higher, you’ll hit a segfault.

Fix: Track the exact size of your result array (pass it back via a pointer like return_size as in the example above) and validate that result_i stays within 0 <= result_i < return_size.

4. Incorrect pointer assignment logic #

It’s easy to mix up pointer and array syntax. For example:

• Accidentally reassigning the result pointer itself instead of its elements: result = &some_int; (now result points to a single int, not an array)
• Using *result[result_i] instead of result[result_i] (the subscript operator [] already dereferences the pointer, so adding * is redundant and wrong)

Double-check every line where you assign to or access the result pointer to make sure you’re targeting the array elements correctly.

Example of a Safe Implementation #

Here’s a complete, safe example to reference:

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

int* solve(int input[], int input_size, int* return_size) {
    // Calculate the size of the result array (adjust based on your logic)
    *return_size = input_size;
    // Allocate heap memory
    int* result = malloc(sizeof(int) * (*return_size));
    if (!result) {
        *return_size = 0;
        return NULL;
    }
    // Populate the result array
    for (int i = 0; i < *return_size; i++) {
        result[i] = input[i] * 2; // Example transformation
    }
    return result;
}

int main() {
    int input[] = {1, 2, 3, 4, 5};
    int input_size = 5;
    int return_size;
    int* result = solve(input, input_size, &return_size);
    
    if (result) {
        for (int i = 0; i < return_size; i++) {
            printf("%d ", result[i]); // No segfault here if solve() is correct
        }
        free(result); // Don't forget to free the heap memory!
    }
    return 0;
}

Go through your solve() function with these checks in mind—chances are you’ll spot where the pointer is going wrong.

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