1、使用动态内存分配返回数组

通过 malloc 或 calloc 分配的动态内存在函数返回后仍然有效，因此可以在函数中分配数组并返回其指针。调用方负责释放分配的内存。

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

int* createArray(int size) {
    int* array = (int*)malloc(size * sizeof(int));  // 动态分配数组
    if (array == NULL) {
        return NULL;  // 检查内存分配是否成功
    }
    for (int i = 0; i < size; i++) {
        array[i] = i;  // 初始化数组
    }
    return array;  // 返回指针
}

int main() {
    int size = 5;
    int* arr = createArray(size);  // 接收返回的指针
    if (arr != NULL) {
        for (int i = 0; i < size; i++) {
            printf("%d ", arr[i]);
        }
        printf("\n");
        free(arr);  // 释放动态分配的内存
    }
    return 0;
}

2、使用全局变量

数组可以声明为全局变量，然后在函数中对其进行修改。全局数组在整个程序执行期间有效，但这种方法不具备通用性，因为不同函数共用同一个数组。

#include <stdio.h>

#define SIZE 5
int globalArray[SIZE];  // 全局数组

int* getGlobalArray() {
    for (int i = 0; i < SIZE; i++) {
        globalArray[i] = i;  // 初始化数组
    }
    return globalArray;  // 返回指向全局数组的指针
}

int main() {
    int* arr = getGlobalArray();
    for (int i = 0; i < SIZE; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

3、使用结构体包装数组

可以将数组放入结构体中，然后返回结构体的实例。这样做可以避免数组退化为指针，保留数组的大小信息。

#include <stdio.h>

#define SIZE 5

typedef struct {
    int array[SIZE];
} ArrayWrapper;

ArrayWrapper createArray() {
    ArrayWrapper wrapper;
    for (int i = 0; i < SIZE; i++) {
        wrapper.array[i] = i;  // 初始化结构体中的数组
    }
    return wrapper;  // 返回结构体
}

int main() {
    ArrayWrapper arrWrapper = createArray();  // 接收结构体
    for (int i = 0; i < SIZE; i++) {
        printf("%d ", arrWrapper.array[i]);
    }
    printf("\n");
    return 0;
}

4、使用指针作为输出参数

通过将指针传递给函数并在函数中修改该指针指向的数组，可以避免直接返回数组。该方法适合在调用方已经分配好数组内存的情况下使用。

#include <stdio.h>

void fillArray(int* array, int size) {
    for (int i = 0; i < size; i++) {
        array[i] = i;  // 填充数组
    }
}

int main() {
    int size = 5;
    int arr[size];  // 在调用方分配数组
    fillArray(arr, size);  // 通过指针填充数组
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}