为什么这个矩阵初始化为2x4而不是2x2？

Question

我正在尝试创建一个函数，它将从一个较大的矩阵返回一个子矩阵。功能是

double **getSubmatrix(double **matrix, int n, int m, int row1, int row2, int col1, int col2){
int i, j, subrow, subcol;
subrow = 0;
subcol = 0;
int numSubRows = row2 - row1 + 1;
int numSubCols = col2 - col1 + 1;

// Create Submatrix with indicated size
double **subMatrix = (double **)malloc(sizeof(double *) * numSubRows);
for (i = 0; i < numSubRows; i++) {
    subMatrix[i] = (double *)malloc(sizeof(double) * numSubCols);
}
// Add values from matrix into subMatrix
for (i = row1; i <= row2; i++) {
    for (j = col1; j <= col2; j++) {
        subMatrix[subrow][subcol] = matrix[i][j];
        subcol += 1;
    }
    subrow += 1;
}
return subMatrix;

}

对该函数的调用是

mat2 = getSubmatrix(mat1, 3, 4, 1, 2, 2, 3)

mat1是一个具有值的3x4矩阵。

8  2  4  1
10 4  2  3
12 42 1  0

我期望subMatrix返回一个矩阵

2  3
1  0

但我只得到了

2  3
0  0

因为SubMatrix变成了

2  3  0  0
0  0  1  0

尽管numSubRows和numSubCols都是2，我觉得我遗漏了一些显而易见的东西，但我不知道它是什么。

Answer 1

for (i = row1; i <= row2; i++) {
    for (j = col1; j <= col2; j++) {
        subMatrix[subrow][subcol] = matrix[i][j];
        subcol += 1;
    }
    subrow += 1;
}

在上面的循环中，当增量subcol时，不能将subrow设置为零。这就是为什么您看到了级联效应(未触及的单元格标记为.，以使其更加明显)：

2 3 . .
. . 1 0

而不是：

2 3
1 0

如果您希望进行最低限度的必要更改，代码应该是：

for (i = row1; i <= row2; i++) {
    for (j = col1; j <= col2; j++) {
        subMatrix[subrow][subcol] = matrix[i][j];
        subcol += 1;
    }
    subrow += 1;
    subcol = 0;  // added this line.
}

但是，实际上最好完全放弃这些subXXX变量，因为您在这两个维度中都使用了固定的基数：

for (i = row1; i <= row2; i++)
    for (j = col1; j <= col2; j++)
        subMatrix[i-row1][j-col1] = matrix[i][j];

另外两件事我想作为旁白提一下。首先，您通常应该始终检查来自malloc()的返回值，即使您只使用该值退出并发出错误消息。这比继续那些难以调试的未定义行为要容易得多。

而且，在C中，您不应该从malloc()转换返回值。C非常能够隐式地将void *返回值转换为任何其他指针类型，并且显式转换可以隐藏某些微妙的错误。

有关更健壮的变体，请参见以下内容。它做了更多的理智检查前，以确保你没有做“奇怪”的事情。它还检测到分配内存的问题，并在必要时清理自己。

它还有一个额外的特性，就是用子矩阵的高度和宽度自动地填充变量(如果你提供它们的话)。如果您提供的是NULL而不是指针，它就不会担心它。

#include <stdlib.h>

double **getSubmatrix (
    double **matrix,
    int height, int width,
    int row1, int row2,
    int col1, int col2,
    int *pHeight, int *pWidth
) {
    // Check parameters for validity up front.

    if ((row1 < 0) || (row1 >= height))
        return NULL;
    if ((row2 < 0) || (row2 >= height))
        return NULL;
    if (row2 < row1)
        return NULL;

    if ((col1 < 0) || (col1 >= width))
        return NULL;
    if ((col2 < 0) || (col2 >= width))
        return NULL;
    if (col2 < col1)
        return NULL;

    // Allocate first level, return NULL if no good.

    double **subMatrix = malloc(sizeof(double *) * (row2 - row1 + 1));
    if (subMatrix == NULL) return NULL;

    // Allocate second level. If any fail, free all previous.

    for (int row = row1; row <= row2; row++) {
        subMatrix[row - row1] = malloc (sizeof(double) * (col2 - col1 + 1));
        if (subMatrix[row - row1] == NULL) {
            for (int rowfree = 0; rowfree < row; rowfree++) {
                free (subMatrix[rowfree]);
            }
            free (subMatrix);
            return NULL;
        }
    }

    // Now have fully allocated sub-matrix, give size if desired.

    if (pHeight != NULL)
        *pHeight = row2 - row1 + 1;

    if (pWidth != NULL)
        *pWidth = col2 - col1 + 1;

    // Transfer the sub-matrix data and return it.

    for (int row = row1; row <= row2; row++)
        for (int col = col1; col <= col2; col++)
            subMatrix[row - row1][col - col1] = matrix[row][col];

    return subMatrix;
}

您可以在下面的测试工具中看到它的作用。

#include <stdio.h>

int main (void) {
    double **ipp = malloc (sizeof (double *) * 3);

    ipp[0] = malloc (sizeof (double) * 4);
    ipp[1] = malloc (sizeof (double) * 4);
    ipp[2] = malloc (sizeof (double) * 4);

    ipp[0][0] =  8; ipp[0][1] =  2; ipp[0][2] =  4; ipp[0][3] =  1;
    ipp[1][0] = 10; ipp[1][1] =  4; ipp[1][2] =  2; ipp[1][3] =  3;
    ipp[2][0] = 12; ipp[2][1] = 42; ipp[2][2] =  1; ipp[2][3] =  0;

    for (int row = 0; row < 3; row++) {
        for (int col = 0; col < 4; col++) {
            printf ("%5.2f ", ipp[row][col]);
        }
        putchar ('\n');
    }

    putchar ('\n');
    int h, w;
    double **part = getSubmatrix (ipp, 3, 4, 1, 2, 2, 3, &h, &w);
    if (part == NULL) {
        puts ("Could not get sub-matrix");
    } else {
        for (int row = 0; row < h; row++) {
            for (int col = 0; col < w; col++) {
                printf ("%5.2f ", part[row][col]);
            }
            putchar ('\n');
        }
    }

    return 0;
}

Answer 2

为了避免这样的错误，您也可以在subrow循环中增加/初始化for和subcol。

for (i = row1, subrow = 0; i <= row2; i++, ++subrow) {
   for (j = col1, subcol = 0; j <= col2; j++, ++subcol) {
      subMatrix[subrow][subcol] = matrix[i][j];
   }
}