返回类型为int*时如何返回整数数组？仅可修改函数的求解方案

Let’s break down the feasible, practical approaches you can take since you can’t adjust the calling code—each option comes with tradeoffs, so pick based on your specific use case:

1. Use a Static Array #

This is the simplest method, but it has important caveats around thread safety and reentrancy. Static variables live in global memory, so their values persist between function calls and will be overwritten if the function is called again before the caller finishes using the returned array.

#include <stdio.h>

int* getIntArray() {
    // Define a static array (adjust size to match your needs)
    static int result[3];
    
    // Populate the array with your desired values
    result[0] = 10;
    result[1] = 20;
    result[2] = 30;
    
    return result;
}

// Example caller (which you can't modify)
int main() {
    int* arr = getIntArray();
    printf("%d, %d, %d\n", arr[0], arr[1], arr[2]);
    return 0;
}

Pros: No memory management required from the caller, straightforward to implement.
Cons: Not thread-safe (multiple threads will race to overwrite the array), and subsequent calls will erase the previous result—so the caller must use the pointer immediately before calling the function again.

2. Dynamically Allocate Memory with malloc #

This creates a new memory block every time the function runs, so there’s no risk of overwriting past results. However, it requires the caller to free the memory to avoid leaks. Since you can’t modify the caller, you’ll need to either:

• Assume the caller already handles free (if the original design intended this), or
• Accept memory leaks (only viable for short-lived programs or one-time function calls).

#include <stdlib.h>

int* getIntArray() {
    // Allocate memory for the array (adjust size as needed)
    int* result = malloc(3 * sizeof(int));
    
    // Always check if malloc succeeded to avoid null pointer crashes
    if (result == NULL) {
        // Handle allocation failure—return NULL or exit gracefully
        return NULL;
    }
    
    // Populate the array
    result[0] = 10;
    result[1] = 20;
    result[2] = 30;
    
    return result;
}

Pros: Thread-safe (each call gets its own memory), no overwriting of previous results.
Cons: Risk of memory leaks if the caller doesn’t free the pointer. This is a tradeoff you’ll have to accept if the caller code can’t be changed.

3. Static Compound Literal (C99+) #

If you’re working with C99 or later, you can use a static compound literal to define and initialize a static array in one line. It behaves exactly like the static array approach—same pros and cons apply.

int* getIntArray() {
    // Static compound literal creates a persistent array
    return (static int[]){10, 20, 30};
}

Pros: Concise syntax, same benefits as a static array.
Cons: Same thread-safety and reentrancy limitations as static arrays.

Quick Decision Guide #

• If your function is called rarely, doesn’t need thread safety, and the caller uses the result immediately: Go with the static array or compound literal.
• If thread safety or avoiding result overwrites is critical: Use malloc, even if it means accepting memory leaks (or document the requirement for the caller to free if possible).

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