为什么这个矩阵初始化为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是一个3×4矩阵值

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

我期待小矩阵返回矩阵

2 3 
1 0 

但我只得到

2 3 
0 0 

由于小矩阵变成

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; 
} 

在这个循环上面，你不能递增subrow时设置subcol回零。这就是为什么你看到的级联效应（不变细胞标记为.，以使其更明显）的

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能够隐式地将返回值转换为任何其他指针类型，并且显式地转换可以隐藏某些细微的错误。

---

有关更强大的变体，请参阅以下内容。它确实有更多的理智检查，以确保你没有做出“奇怪”的事情。它还检测分配内存的问题，并在必要时自行清理。

它有一个额外的功能，自动魔术般填充变量（如果你提供它们）与子矩阵的高度和宽度。如果您提供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和subcol也在for循环。

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