如何从C语言函数返回数组？矩阵乘法平移函数的数组返回问题

C语言无法直接返回数组类型，但可以通过以下几种方式实现类似需求，同时针对你代码中的问题逐一修正：

常见实现方式 #

1. 使用静态数组（简单但有局限性） #

静态数组在函数结束后不会被销毁，但属于全局生命周期资源，多次调用会覆盖之前的结果，且不适合多线程场景。

2. 调用者传入数组（最安全、推荐） #

将需要填充结果的数组作为参数传入函数，函数直接修改数组内容，无需处理内存管理问题。

3. 动态分配内存（灵活但需手动释放） #

通过malloc在堆上分配内存，返回指针，但调用者必须记得用free释放内存，避免泄漏。

4. 结构体包裹数组（类型安全） #

把数组封装到结构体中，直接返回结构体实例（结构体是值类型，支持直接返回）。

你的代码问题修正 #

原代码存在以下问题：

• 调用translation时缺少tx、ty两个必填参数
• 变量arr的类型与函数返回值不匹配
• printf中的索引越界（你的结果是3行1列数组，不应访问arr[0][1]、arr[0][2]）

修正后的静态数组版本 #

#include <stdio.h>

// 明确返回类型：指向一维数组的指针
int (*translation(int x, int y, int tx, int ty))[1] {
    static int res[3][1] = {0};
    int xy[3][1] = {{x}, {y}, {1}};
    int tm[3][3] = {{1,0, tx}, {0,1,ty}, {0,0,1}};
    
    // 每次调用重置结果，避免残留上次计算值
    for (int i = 0; i < 3; i++) {
        res[i][0] = 0;
    }
    
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            res[i][0] += tm[i][j] * xy[j][0];
        }
    }
    return res;
}

int main()
{
    // 定义匹配返回类型的指针
    int (*arr)[1] = translation(5, 5, 2, 3); // 补充tx=2、ty=3参数
    printf("%d %d %d\n", arr[0][0], arr[1][0], arr[2][0]);
    return 0;
}

推荐：调用者传入数组的版本 #

#include <stdio.h>

// 直接修改传入的结果数组
void translation(int x, int y, int tx, int ty, int res[3][1]) {
    int xy[3][1] = {{x}, {y}, {1}};
    int tm[3][3] = {{1,0, tx}, {0,1,ty}, {0,0,1}};
    
    for (int i = 0; i < 3; i++) {
        res[i][0] = 0;
        for (int j = 0; j < 3; j++) {
            res[i][0] += tm[i][j] * xy[j][0];
        }
    }
}

int main()
{
    int arr[3][1];
    translation(5, 5, 2, 3, arr);
    printf("%d %d %d\n", arr[0][0], arr[1][0], arr[2][0]);
    return 0;
}

动态分配内存版本 #

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

// 返回一维数组指针，将二维逻辑转为一维处理
int* translation(int x, int y, int tx, int ty) {
    int* res = malloc(3 * sizeof(int));
    if (!res) { // 检查内存分配是否成功
        return NULL;
    }
    int xy[3] = {x, y, 1};
    int tm[3][3] = {{1,0, tx}, {0,1,ty}, {0,0,1}};
    
    for (int i = 0; i < 3; i++) {
        res[i] = 0;
        for (int j = 0; j < 3; j++) {
            res[i] += tm[i][j] * xy[j];
        }
    }
    return res;
}

int main()
{
    int* arr = translation(5, 5, 2, 3);
    if (arr) {
        printf("%d %d %d\n", arr[0], arr[1], arr[2]);
        free(arr); // 必须释放内存
    }
    return 0;
}

结构体包裹数组版本 #

#include <stdio.h>

// 定义封装数组的结构体
typedef struct {
    int data[3][1];
} Matrix3x1;

Matrix3x1 translation(int x, int y, int tx, int ty) {
    Matrix3x1 res;
    int xy[3][1] = {{x}, {y}, {1}};
    int tm[3][3] = {{1,0, tx}, {0,1,ty}, {0,0,1}};
    
    for (int i = 0; i < 3; i++) {
        res.data[i][0] = 0;
        for (int j = 0; j < 3; j++) {
            res.data[i][0] += tm[i][j] * xy[j][0];
        }
    }
    return res;
}

int main()
{
    Matrix3x1 arr = translation(5, 5, 2, 3);
    printf("%d %d %d\n", arr.data[0][0], arr.data[1][0], arr.data[2][0]);
    return 0;
}

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