如何将static array与dynamic array的矩阵乘法封装为C++函数？

一、静态二维数组的函数传递与乘法 #

静态二维数组的维度在编译期确定，通过数组引用传递可以保留维度信息，配合模板函数能实现通用的乘法逻辑：

#include <iostream>
#include <cassert>

// 静态二维数组矩阵乘法：arr1(M×K) × arr2(K×N) = result(M×N)
template <size_t M, size_t K, size_t N>
void multiplyStatic(const int (&arr1)[M][K], const int (&arr2)[K][N], int (&result)[M][N]) {
    // 初始化结果矩阵为0
    for (size_t i = 0; i < M; ++i) {
        for (size_t j = 0; j < N; ++j) {
            result[i][j] = 0;
        }
    }

    // 核心乘法逻辑
    for (size_t i = 0; i < M; ++i) {
        for (size_t j = 0; j < N; ++j) {
            for (size_t k = 0; k < K; ++k) {
                result[i][j] += arr1[i][k] * arr2[k][j];
            }
        }
    }
}

调用示例 #

int main() {
    // 2×3 和 3×2 的静态数组
    int arr1[2][3] = {{1,2,3}, {4,5,6}};
    int arr2[3][2] = {{7,8}, {9,10}, {11,12}};
    int result[2][2]; // 提前声明匹配维度的结果数组

    multiplyStatic(arr1, arr2, result);

    // 输出结果
    for (auto& row : result) {
        for (int val : row) {
            std::cout << val << " ";
        }
        std::cout << "\n";
    }
    return 0;
}

二、动态二维数组的函数传递与乘法 #

动态二维数组本质是指针数组（int**），编译期无法获取维度，必须手动传入行/列数。返回的结果需要动态分配内存，记得最后手动释放：

// 动态数组内存释放辅助函数
void deleteDynamicArray(int** arr, size_t rows) {
    for (size_t i = 0; i < rows; ++i) {
        delete[] arr[i];
    }
    delete[] arr;
}

// 动态二维数组矩阵乘法：arr1(M×K) × arr2(K×N) = result(M×N)
int** multiplyDynamic(const int** arr1, size_t M, size_t K, const int** arr2, size_t N) {
    // 断言检查矩阵维度合法性
    assert(K > 0 && "矩阵列数不能为0");
    assert(M > 0 && N > 0 && "矩阵行/列数不能为0");

    // 分配结果矩阵：先分配行指针
    int** result = new int*[M];
    // 分配每行的列空间并初始化为0
    for (size_t i = 0; i < M; ++i) {
        result[i] = new int[N]();
    }

    // 核心乘法逻辑
    for (size_t i = 0; i < M; ++i) {
        for (size_t j = 0; j < N; ++j) {
            for (size_t k = 0; k < K; ++k) {
                result[i][j] += arr1[i][k] * arr2[k][j];
            }
        }
    }

    return result;
}

调用示例 #

int main() {
    // 创建2×3动态数组
    int** dynArr1 = new int*[2];
    dynArr1[0] = new int[3]{1,2,3};
    dynArr1[1] = new int[3]{4,5,6};

    // 创建3×2动态数组
    int** dynArr2 = new int*[3];
    dynArr2[0] = new int[2]{7,8};
    dynArr2[1] = new int[2]{9,10};
    dynArr2[2] = new int[2]{11,12};

    // 调用乘法函数
    int** dynResult = multiplyDynamic(dynArr1, 2, 3, dynArr2, 2);

    // 输出结果
    for (size_t i = 0; i < 2; ++i) {
        for (size_t j = 0; j < 2; ++j) {
            std::cout << dynResult[i][j] << " ";
        }
        std::cout << "\n";
    }

    // 释放所有动态内存
    deleteDynamicArray(dynArr1, 2);
    deleteDynamicArray(dynArr2, 3);
    deleteDynamicArray(dynResult, 2);

    return 0;
}

三、静态与动态数组混合乘法 #

如果需要实现静态数组×动态数组，或动态数组×静态数组，可以结合模板和维度参数：

静态数组 × 动态数组 #

template <size_t M, size_t K>
int** multiplyStaticDynamic(const int (&arr1)[M][K], const int** arr2, size_t N) {
    int** result = new int*[M];
    for (size_t i = 0; i < M; ++i) {
        result[i] = new int[N]();
    }

    for (size_t i = 0; i < M; ++i) {
        for (size_t j = 0; j < N; ++j) {
            for (size_t k = 0; k < K; ++k) {
                result[i][j] += arr1[i][k] * arr2[k][j];
            }
        }
    }

    return result;
}

动态数组 × 静态数组 #

template <size_t K, size_t N>
int** multiplyDynamicStatic(const int** arr1, size_t M, const int (&arr2)[K][N]) {
    int** result = new int*[M];
    for (size_t i = 0; i < M; ++i) {
        result[i] = new int[N]();
    }

    for (size_t i = 0; i < M; ++i) {
        for (size_t j = 0; j < N; ++j) {
            for (size_t k = 0; k < K; ++k) {
                result[i][j] += arr1[i][k] * arr2[k][j];
            }
        }
    }

    return result;
}

关键注意事项 #

• 静态数组传递必须用数组引用（const T (&arr)[M][N]），避免数组退化为指针丢失维度信息。
• 动态数组必须手动传入行/列数，返回的动态内存必须手动释放，建议封装释放函数避免泄漏。
• 矩阵乘法的核心是维度匹配：第一个矩阵的列数必须等于第二个矩阵的行数，可通过assert或条件判断做合法性检查。

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