快速初始化C数组（写入）

Question

有没有更好的解决方案来快速初始化 C 数组（在堆上创建）？就像我们对大括号所做的那样

double** matrix_multiply(const double **l_matrix, const double **r_matrix);

foo() {
    double DCT_matrix[8][8] = {
        { 0.3536,  0.3536,  0.3536,  0.3536,  0.3536,  0.3536,  0.3536,  0.3536 },
        { 0.4904,  0.4157,  0.2778,  0.0975, -0.0975, -0.2778, -0.4157, -0.4904 },
        { 0.4619,  0.1913, -0.1913, -0.4619, -0.4619, -0.1913,  0.1913,  0.4619 },
        { 0.4157, -0.0975, -0.4904, -0.2778,  0.2778,  0.4904,  0.0975, -0.4157 },
        { 0.3536, -0.3536, -0.3536,  0.3536,  0.3536, -0.3536, -0.3536,  0.3536 },
        { 0.2778, -0.4904,  0.0975,  0.4157, -0.4157, -0.0975,  0.4904, -0.2778 },
        { 0.1913, -0.4619,  0.4619, -0.1913, -0.1913,  0.4619, -0.4619,  0.1913 },
        { 0.0975, -0.2778,  0.4157, -0.4904,  0.4904, -0.4157,  0.2778, -0.0975 }
    }; 

    const double other_matrix[8][8] = {
        {  26,  -5,  -5, -5, -5, -5, -5,   8 },
        {  64,  52,   8, 26, 26, 26,  8, -18 },
        { 126,  70,  26, 26, 52, 26, -5,  -5 },
        { 111,  52,   8, 52, 52, 38, -5,  -5 },
        {  52,  26,   8, 39, 38, 21,  8,   8 },
        {   0,   8,  -5,  8, 26, 52, 70,  26 },
        {  -5, -23, -18, 21,  8,  8, 52,  38 },
        { -18,   8,  -5, -5, -5,  8, 26,   8 }
    };

    matrix_multiply(DCT_matrix, other_matrix); // Segfault
}

Answer 1

在评论部分，很明显主要缺陷是 的设计matrix_multiply。没有理由传递double**给它。

首先，布局double**表示矩阵是这样创建的：

double **mat = malloc(8 * sizeof *mat);
for(int i=0; i<8; i++) 
    mat[i] = malloc(8 * sizeof *mat[0]);

这就是在学习如何处理指针时在入门课程中教授的方式。但这会导致许多不必要的 malloc 调用，这也会使释放所有内存变得笨拙。最重要的是，它很慢。在分配/释放和使用内存时都如此，因为矩阵不适合缓存。这是我写的一个关于缓存的答案

我这里还有其他几个

所以，在你的函数中，我假设你会有很多像l_matrix[x][y]. l_matrix[x + 8*y]当从double**到 时将其替换为double*。

最重要的是，由于您没有输出参数，我假设您在函数内部分配输出。不要那样做。在很多情况下，您想要重用为矩阵分配的内存。相反，提供一个输出参数并在函数外部分配内存。这给了我们签名：

void matrix_multiply(const double *A, const double *B, double *output)

另外，由于在您的情况下矩阵大小是固定的，我建议以某种反映这一点的方式重命名该函数。也许吧DCT_matrix_multiply，但这取决于你。

如果需要，您可以将返回类型更改为double*并以 结束函数return output;。这不是强制性的，但它提供了执行此操作的选项：

matrix_multiply(matrix_multiply(A, B, C), 
                matrix_multiply(A, D, E),
                F);

但是，如果这样做，请务必小心，因为未指定参数的计算顺序。

如果您确实想要一个执行分配的函数，请编写一个包装器：

double *wrapper(const double *A, const double *B) {
    double *output = malloc(8*8 * sizeof *output);
    if(!output) return NULL;
    return matrix_multiply(A, B, output);
}

如果您想使用大小不固定的矩阵，则有点棘手，但总的来说，我仍然建议传递double*有关大小的附加信息。就像是：

double *mul(const double *A, const double *B, double *C, size_t x, size_t y);

如果您想支持矩阵和向量的乘法，签名将变得更加复杂，并且完整的解决方案超出了本答案的范围。但在这种情况下我会编写一个单独的函数。

您可能想要研究的另一个选择是拥有此签名。

typedef dm double[8][8]; // Short for dct matrix
dm *matrix_multiply(const dm *A, const *dm B, dm *output);

由于您使用的是固定大小，因此这里有一定意义，但一般来说，这种方法并不常见。原因很简单，它的好处并没有真正超过必须处理指向二维数组的指针的缺点。

当前代码的解决方法

如果您想推迟重写但仍然能够按照您想要的方式初始化，请编写一个转换器。

double **convert (double mat[8][8])
{
    double **ret = malloc (8 * sizeof *ret);
  
    if (!ret) return NULL;

    for (int i = 0; i < 8; i++)
        ret[i] = &mat[i][0];

    return ret;
}

然后你可以做

double **A = convert(DCT_matrix);
double **B = convert(other_matrix);

// Use A and B

free(A);
free(B);