如何使用 malloc 在 C 中创建矩阵并避免内存问题？如何使用 C99 语法将矩阵传递给函数？

您有关于使用的良好指示吗？malloc为矩阵分配内存空间的函数？

这些天我看到很多编码员在需要使用矩阵时以“糟糕”的方式编码malloc来管理他们。当我这样想时，我错了吗？

我的意思是“坏”代码的一个例子如下：

int main()
{
    char **row;
    int width=80, height=24, i, j;

    row = malloc(height * sizeof(char *));
    for(i = 0; i < width; i++)
        row[i] = malloc(width * sizeof(char));

    for(i = 0; i < height; i++)
    {
        for(j = 0; j < width; j++)
        {
            row[i][j] = i*j;
        }
    }

    return 0;
}

在上面的代码中我发现至少三个问题：

• 它强烈地碎片化记忆。

• 它使用了超出必要的内存

• 它使得用于矩阵的内存不连续。

有人建议我使用 C99 语法的有趣方法：

int (*matrix)[columns] = malloc(sizeof(int[rows][columns]));

现在我需要将此变量矩阵传递给以下函数：

void print_matrix2(int **m,int r,int c)
{
    int y,x;

    for(y=0;y<r;y++) {
        for(x=0;x<c;x++) {
            printf("(%2d,%2d) = %04d; ",y+1,x+1,m[y][x]);
        }
    }
}

我发现的唯一方法是更改​​原型：

void print_matrix2(int (*m)[5],int r,int c);

但我想避免 [5] 声明，我希望能够向我的函数发送我想要的任何数量的列！

如果是这样，我觉得这个 C99 改进并不是问题的最终解决方案，我认为解决矩阵管理的最好、最简单的方法是使用经典 C 语言来管理它们！

Use malloc()分配连续的内存块：

some_datatype_t* matrix = NULL;
matrix = malloc(nrows * ncols * sizeof(some_datatype_t));
if (!matrix) { 
    perror("malloc failed");
    exit(ENOMEM); 
}

编写一个函数来取消引用单元格：

some_datatype_t 
get_value_from_matrix_at_index_ij(some_datatype_t* mtx, 
                                  uint32_t ncols, 
                                  uint32_t i, 
                                  uint32_t j) 
{
    return mtx[i + i * (ncols - 1) + j];
}

或者二传手：

void
set_value_for_matrix_at_index_ij(some_datatype_t** mtx_ptr,
                                 uint32_t ncols, 
                                 uint32_t i, 
                                 uint32_t j,
                                 some_datatype_t val) 
{
    *mtx_ptr[i + i * (ncols - 1) + j] = val;
}

别忘了free()完成后你的矩阵：

free(matrix), matrix = NULL;

这是 3x4 矩阵的示例：

    0  1  2  3
  ------------
0 | 0  1  2  3
1 | 4  5  6  7
2 | 8  9 10 11

它有 3 行和 4 列（ncols = 4).

在线性化形式下，其单元格如下所示：

0 1 2 3 4 5 6 7 8 9 10 11

在某个零索引行查找单元格的内容i和列j，您可以在常数时间内计算要取消引用的索引或地址：

{1, 2} = matrix[1 + 1*3 + 2] = matrix[6]
{2, 3} = matrix[2 + 2*3 + 3] = matrix[11]
etc.

如果您想将一些有用的属性隐藏到一个干净的包中，您甚至可以将其中的大部分包装到一个struct:

typedef struct matrix {
    some_datatype_t* data;
    uint32_t nrows;
    uint32_t ncols;
} matrix_t;

然后你只需初始化并传递一个指向matrix_t多变的：

matrix_t*
init_matrix(uint32_t nrows, uint32_t ncols) 
{
    matrix_t *m = NULL;
    m = malloc(sizeof(matrix_t));
    if (!m) { /* error */ }
    m->data = NULL;
    m->data = malloc(nrows * ncols * sizeof(some_datatype_t));
    if (!m->data) { /* error */ }
    m->nrows = nrows;
    m->ncols = ncols;
    return m;
}

some_datatype_t 
get_value_from_matrix_at_index_ij(matrix_t* mtx,
                                  uint32_t i, 
                                  uint32_t j) 
{
    return mtx->data[i + i * (mtx->ncols - 1) + j];
}

void
set_value_for_matrix_at_index_ij(matrix_t** mtx_ptr,
                                 uint32_t i, 
                                 uint32_t j,
                                 some_datatype_t val) 
{
    (*mtx_ptr)->data[i + i * ((*mtx_ptr)->ncols - 1) + j] = val;
}

void
delete_matrix(matrix_t** m) 
{
    free((*m)->data), (*m)->data = NULL;
    free(*m), *m = NULL;
}

如果您使用对称方阵，则可以利用对称性并使用一半的内存。有时，如果可以删除对角线的存储（例如，相关性或其他对称统计分数），则占用的内存会少于一半。

主要是，这里的想法是思考如何编写一个在矩阵索引对之间映射的方程(i, j)和一些连续数组索引k.