如何在C中用零填充矩阵使其平方

我目前正试图用零列填充一个m×n矩阵（其中m大于或等于n）。主要问题是我的矩阵存储在一个double*中，而不是double**。所以我的矩阵看起来不像2d矩阵，它实际上是一个向量，将矩阵的行粘在一条直线上

这是我拙劣的尝试（我对C编程语言相当陌生…）

在调用

square\u my\u matrix

之后（再次调用

printMatrix

时）

但是我得到了这个

1.00 1.00 1.00 3.00
0.00 5.00 1.00 7.00
0.00 0.00 0.00 0.00
0.00 0.00 0.00 0.00

我可能搞砸了一些显而易见的事情，但我不知道是什么

---

感谢您的帮助

将添加的内存归零（新行）

如果我了解您在做什么，您可以使用

calloc

而不是

malloc

（将所有字节设置为零）将

A

中的所有值初始化为

0

。然后按照

realloc

操作，您可以使用

memset（）

将分配的新内存归零。（如果需要将添加的列归零，请参阅本答案的第二部分）

您可以将分配给

realloc（）

的新内存归零，例如

double*A;
A = calloc (m * n, sizeof *A);
if (A == NULL) {          /* validate EVERY allocation */
    perror ("calloc-A");
    exit (EXIT_FAILURE);
}

buildMatrix(); //this fills my matrix with some data
printMatrix(m,n,A); //this prints my matrix in a 2d fashion to make it clearer

if (m > n) {
    void *tmp = realloc (A, m * m * sizeof *A);  /* ALWAYS realloc with a temporary pointer */
    if (!tmp) {           /* validate EVERY allocation */
        perror ("realloc-A");
        exit (EXIT_FAILURE);
    }
    A = tmp;              /* assign reallocated block */
    /* set new memory zero */
    memset (A + m * n, 0, m * (m - n) * sizeof *A);
    
    // square_my_matrix(A, n);
}
printMatrix(m,m,A);

如果您确实想使用

square\u my\u matrix（）

，则应删除上面的

memset（）

，并使用：

void square_my_matrix (double* A, int n)
{
    for (int i = n; i < m; i++)
        for (int j = 0; j < m; j++)
                A[i * m + j] = 0.0;
}

示例使用/输出

无论是否定义了

WMEMSET

，输出都是相同的：

$ ./bin/mxn2mm
   1   2   3   4   5   6   7   8
   9  10  11  12  13  14  15  16
  17  18  19  20  21  22  23  24
  25  26  27  28  29  30  31  32
  33  34  35  36  37  38  39  40
  41  42  43  44  45  46  47  48
  49  50  51  52  53  54  55  56
  57  58  59  60  61  62  63  64
  65  66  67  68  69  70  71  72
  73  74  75  76  77  78  79  80
   1   2   3   4   5   6   7   8   9  10
  11  12  13  14  15  16  17  18  19  20
  21  22  23  24  25  26  27  28  29  30
  31  32  33  34  35  36  37  38  39  40
  41  42  43  44  45  46  47  48  49  50
  51  52  53  54  55  56  57  58  59  60
  61  62  63  64  65  66  67  68  69  70
  71  72  73  74  75  76  77  78  79  80
   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0

仅将最后一列归零

如果需要将添加的列而不是行归零，则需要手动将原始行复制到新分配块的行中，然后释放原始行。为此，您必须更改

square\u my\u matrix（）

以获取指针的地址（指向指针的指针），而不是简单的指针，这样可以更新函数中

a

点的位置。例如：

void square_my_matrix (double **A, int n)
{
    double *b = calloc (m * m, sizeof *b);
    if (!b) {
        perror ("calloc-b");
        exit (EXIT_FAILURE);
    }
    
    for (int i = 0; i < m; i++)
        memcpy (b + i * m, *A + i * n, n * sizeof **A);
    
    free (*A);
    *A = b;
}

示例输出

那么您的输出将是：

$ ./bin/mxn2mm
   1   2   3   4   5   6   7   8
   9  10  11  12  13  14  15  16
  17  18  19  20  21  22  23  24
  25  26  27  28  29  30  31  32
  33  34  35  36  37  38  39  40
  41  42  43  44  45  46  47  48
  49  50  51  52  53  54  55  56
  57  58  59  60  61  62  63  64
  65  66  67  68  69  70  71  72
  73  74  75  76  77  78  79  80
   1   2   3   4   5   6   7   8   0   0
   9  10  11  12  13  14  15  16   0   0
  17  18  19  20  21  22  23  24   0   0
  25  26  27  28  29  30  31  32   0   0
  33  34  35  36  37  38  39  40   0   0
  41  42  43  44  45  46  47  48   0   0
  49  50  51  52  53  54  55  56   0   0
  57  58  59  60  61  62  63  64   0   0
  65  66  67  68  69  70  71  72   0   0
  73  74  75  76  77  78  79  80   0   0

为了完成，上例中更新的

main（）

将减少为：

int main (void) {
    
    int n = nbegin,
        v = 1;
    double *A;
    
    A = calloc (m * n, sizeof *A);
    if (A == NULL) {          /* validate EVERY allocation */
        perror ("calloc-A");
        exit (EXIT_FAILURE);
    }
    
    // buildMatrix(); //this fills my matrix with some data
    for (int i = 0; i < m; i++)
        for (int j = 0; j < n; j++)
            A[i * n + j] = v++;
    
    printMatrix (m,n,A);
    if (m > n)
        square_my_matrix (&A, n);
    printMatrix (m,m,A);
}

int main（无效）{
int n=nbegin，
v=1；
双*A；
A=calloc（m*n，sizeof*A）；
如果（A==NULL）{/*验证每个分配*/
perror（“calloc-A”）；
退出（退出失败）；
}
//buildMatrix（）；//这会用一些数据填充我的矩阵
for（int i=0；in）
平方矩阵（&A，n）；
打印矩阵（m，m，A）；
}

---

仔细检查一下，如果您还有其他问题，请告诉我。

调用

realloc（）

后，您需要将所有内容移动到新大小的正确行。这就是

square\u my\u matrix

应该做的吗？也许调用

malloc

并将结果保存到新变量中逻辑上更简单，

B

。然后将数据从A复制到B。非常感谢您的精彩回答！我的问题现在解决了：）很乐意帮忙。这是一个有趣的问题，有两种方式来看待它。我想归零的列就是你要找的。祝你的编码好运！

$ ./bin/mxn2mm
   1   2   3   4   5   6   7   8
   9  10  11  12  13  14  15  16
  17  18  19  20  21  22  23  24
  25  26  27  28  29  30  31  32
  33  34  35  36  37  38  39  40
  41  42  43  44  45  46  47  48
  49  50  51  52  53  54  55  56
  57  58  59  60  61  62  63  64
  65  66  67  68  69  70  71  72
  73  74  75  76  77  78  79  80
   1   2   3   4   5   6   7   8   9  10
  11  12  13  14  15  16  17  18  19  20
  21  22  23  24  25  26  27  28  29  30
  31  32  33  34  35  36  37  38  39  40
  41  42  43  44  45  46  47  48  49  50
  51  52  53  54  55  56  57  58  59  60
  61  62  63  64  65  66  67  68  69  70
  71  72  73  74  75  76  77  78  79  80
   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0

void square_my_matrix (double **A, int n)
{
    double *b = calloc (m * m, sizeof *b);
    if (!b) {
        perror ("calloc-b");
        exit (EXIT_FAILURE);
    }
    
    for (int i = 0; i < m; i++)
        memcpy (b + i * m, *A + i * n, n * sizeof **A);
    
    free (*A);
    *A = b;
}

    square_my_matrix (&A, n);

$ ./bin/mxn2mm
   1   2   3   4   5   6   7   8
   9  10  11  12  13  14  15  16
  17  18  19  20  21  22  23  24
  25  26  27  28  29  30  31  32
  33  34  35  36  37  38  39  40
  41  42  43  44  45  46  47  48
  49  50  51  52  53  54  55  56
  57  58  59  60  61  62  63  64
  65  66  67  68  69  70  71  72
  73  74  75  76  77  78  79  80
   1   2   3   4   5   6   7   8   0   0
   9  10  11  12  13  14  15  16   0   0
  17  18  19  20  21  22  23  24   0   0
  25  26  27  28  29  30  31  32   0   0
  33  34  35  36  37  38  39  40   0   0
  41  42  43  44  45  46  47  48   0   0
  49  50  51  52  53  54  55  56   0   0
  57  58  59  60  61  62  63  64   0   0
  65  66  67  68  69  70  71  72   0   0
  73  74  75  76  77  78  79  80   0   0

int main (void) {
    
    int n = nbegin,
        v = 1;
    double *A;
    
    A = calloc (m * n, sizeof *A);
    if (A == NULL) {          /* validate EVERY allocation */
        perror ("calloc-A");
        exit (EXIT_FAILURE);
    }
    
    // buildMatrix(); //this fills my matrix with some data
    for (int i = 0; i < m; i++)
        for (int j = 0; j < n; j++)
            A[i * n + j] = v++;
    
    printMatrix (m,n,A);
    if (m > n)
        square_my_matrix (&A, n);
    printMatrix (m,m,A);
}