如何用templates实现可返回C-style arrays的通用矩阵乘法？

好问题！确实用std::vector处理矩阵会省心太多，但既然想折腾纯C-style数组的通用实现，咱们来一步步解决你遇到的问题——核心卡点其实是C++（和C）的语法限制：函数不能直接返回数组类型，不管是不是模板函数都一样，所以你之前的代码才会报错。

下面给你两种实用的解决方案，都能结合模板实现任意数值类型的通用矩阵乘法：

方案一：动态分配二维数组（返回指针的指针） #

这种方式通过动态内存分配绕开“不能返回数组”的限制，模板让它支持int、float、double等任意可运算的数值类型。注意调用者要负责释放内存，避免泄漏。

#include <iostream>

template <typename T>
T** multiplyMatrices(const T* const* matA, int rowsA, int colsA,
                     const T* const* matB, int rowsB, int colsB) {
    // 先检查矩阵维度是否匹配（A的列数必须等于B的行数）
    if (colsA != rowsB) {
        std::cerr << "Error: 矩阵维度不匹配，无法执行乘法！" << std::endl;
        return nullptr;
    }

    // 动态分配结果矩阵的行指针数组
    T** result = new T*[rowsA];
    // 为每一行分配列空间，并初始化为0
    for (int i = 0; i < rowsA; ++i) {
        result[i] = new T[colsB]();
    }

    // 矩阵乘法核心逻辑
    for (int i = 0; i < rowsA; ++i) {
        for (int j = 0; j < colsB; ++j) {
            for (int k = 0; k < colsA; ++k) {
                result[i][j] += matA[i][k] * matB[k][j];
            }
        }
    }

    return result;
}

// 辅助模板函数：释放动态分配的二维数组，避免内存泄漏
template <typename T>
void deleteMatrix(T** mat, int rows) {
    for (int i = 0; i < rows; ++i) {
        delete[] mat[i];
    }
    delete[] mat;
}

// 测试示例
int main() {
    // 初始化两个2x2的整数矩阵
    int* matA[] = {new int[2]{1, 2}, new int[2]{3, 4}};
    int* matB[] = {new int[2]{5, 6}, new int[2]{7, 8}};

    // 调用乘法函数
    int** result = multiplyMatrices(matA, 2, 2, matB, 2, 2);

    if (result) {
        // 打印结果
        std::cout << "乘法结果：" << std::endl;
        for (int i = 0; i < 2; ++i) {
            for (int j = 0; j < 2; ++j) {
                std::cout << result[i][j] << " ";
            }
            std::cout << std::endl;
        }
        // 记得释放结果矩阵的内存
        deleteMatrix(result, 2);
    }

    // 释放原始矩阵的内存
    deleteMatrix(matA, 2);
    deleteMatrix(matB, 2);

    return 0;
}

方案二：通过输出参数传递结果矩阵 #

如果不想处理动态内存的分配和释放，可以让调用者预先分配好结果矩阵的内存，函数只负责填充计算结果。这种方式更贴近纯C的风格，也更安全。

#include <iostream>

template <typename T>
void multiplyMatrices(const T* const* matA, int rowsA, int colsA,
                     const T* const* matB, int rowsB, int colsB,
                     T** result) {
    // 参数合法性检查
    if (colsA != rowsB || result == nullptr) {
        std::cerr << "Error: 参数非法，请检查矩阵维度或结果指针！" << std::endl;
        return;
    }

    // 先将结果矩阵初始化为0
    for (int i = 0; i < rowsA; ++i) {
        for (int j = 0; j < colsB; ++j) {
            result[i][j] = 0;
        }
    }

    // 矩阵乘法核心逻辑
    for (int i = 0; i < rowsA; ++i) {
        for (int j = 0; j < colsB; ++j) {
            for (int k = 0; k < colsA; ++k) {
                result[i][j] += matA[i][k] * matB[k][j];
            }
        }
    }
}

// 测试示例
int main() {
    // 用静态C-style数组初始化矩阵
    int matA[2][2] = {{1, 2}, {3, 4}};
    int matB[2][2] = {{5, 6}, {7, 8}};
    // 预先分配结果矩阵的内存
    int result[2][2];

    // 把静态二维数组转成T**类型（因为函数参数要求）
    int* matA_ptr[] = {matA[0], matA[1]};
    int* matB_ptr[] = {matB[0], matB[1]};
    int* result_ptr[] = {result[0], result[1]};

    // 调用乘法函数，结果直接写入预分配的数组
    multiplyMatrices(matA_ptr, 2, 2, matB_ptr, 2, 2, result_ptr);

    // 打印结果
    std::cout << "乘法结果：" << std::endl;
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 2; ++j) {
            std::cout << result[i][j] << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

额外小提示 #

如果可以接受稍微“不那么纯C-style”的写法，std::array其实是更好的选择——它既保留了数组的栈分配特性，又支持作为函数返回值，还能完美结合模板，比如std::array<std::array<T, Cols>, Rows>，用起来比纯C数组省心很多，但如果你坚持要用C-style数组，上面两种方案足够解决你的问题。

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