矩阵阻塞会导致分段错误 我尝试在C++中实现StrusEN算法。我想把方阵'hA'分成4个相等的块 // Initialize matrices on the host float hA[N][N],ha11[N / 2][N / 2], ha12[N / 2][N / 2], ha21[N / 2][N / 2], ha22[N / 2][N / 2]; for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { hA[i][j] = i; //hB[i][j] = i; } } for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { printf("\n%d,%d\n", i, j); if (i < N / 2 & j < N / 2) { ha11[i][j] = hA[i][j]; } else if (i < N / 2 & j >= N / 2) { ha12[i][j] = hA[i][j]; } else if (i >= N / 2 & j < N / 2) { ha21[i][j] = hA[i][j]; } else if (i >= N / 2 & j >= N / 2) { ha22[i][j] = hA[i][j]; //faulty! } } } //在主机上初始化矩阵 浮动hA[N][N]、ha11[N/2][N/2]、ha12[N/2][N/2]、ha21[N/2][N/2]， ha22[N/2][N/2]； 对于（int i=0；i

我使用上面的方法进行分区，它出现了错误，如下面的输出所示。但是，当我删除“if-else”阶梯中的最后一个比较时，它工作得很好。

---

为什么“i”有一个甚至超出循环条件的错误值？有没有比这种方式更方便的分区方式？

您的数组应该是nxn，而不是N/2xn/2

您使用的位运算符&虽然不常见，但很有效。我错误地认为您需要一个逻辑and（&&&）。尽管如此，为了可读性，我还是建议使用&&。你也会短路

    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            printf("\n%d,%d\n", i, j);
            if (i < N / 2 & j < N / 2) {
                ha11[i][j] = hA[i][j];
            } else if (i < N / 2 & j >= N / 2) {
                ha12[i][j] = hA[i][j];
            } else if (i >= N / 2 & j < N / 2) {
                ha21[i][j] = hA[i][j];
            } else if (i >= N / 2 & j >= N / 2) {
                ha22[i][j] = hA[i][j];    //faulty!
            }
        }
    }

for（int i=0；i=N/2）{
ha12[i][j]=hA[i][j]；
}否则如果（i>=N/2&j=N/2&j>=N/2）为else{
ha22[i][j]=hA[i][j]；//错误！
}
}
}

您的阵列应该是N x N，而不是N/2xN/2

您使用的位运算符&虽然不常见，但很有效。我错误地认为您需要一个逻辑and（&&&）。尽管如此，为了可读性，我还是建议使用&&。你也会短路

    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            printf("\n%d,%d\n", i, j);
            if (i < N / 2 & j < N / 2) {
                ha11[i][j] = hA[i][j];
            } else if (i < N / 2 & j >= N / 2) {
                ha12[i][j] = hA[i][j];
            } else if (i >= N / 2 & j < N / 2) {
                ha21[i][j] = hA[i][j];
            } else if (i >= N / 2 & j >= N / 2) {
                ha22[i][j] = hA[i][j];    //faulty!
            }
        }
    }

for（int i=0；i=N/2）{
ha12[i][j]=hA[i][j]；
}否则如果（i>=N/2&j=N/2&j>=N/2）为else{
ha22[i][j]=hA[i][j]；//错误！
}
}
}

您的阵列应该是N x N，而不是N/2xN/2

您使用的位运算符&虽然不常见，但很有效。我错误地认为您需要一个逻辑and（&&&）。尽管如此，为了可读性，我还是建议使用&&。你也会短路

    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            printf("\n%d,%d\n", i, j);
            if (i < N / 2 & j < N / 2) {
                ha11[i][j] = hA[i][j];
            } else if (i < N / 2 & j >= N / 2) {
                ha12[i][j] = hA[i][j];
            } else if (i >= N / 2 & j < N / 2) {
                ha21[i][j] = hA[i][j];
            } else if (i >= N / 2 & j >= N / 2) {
                ha22[i][j] = hA[i][j];    //faulty!
            }
        }
    }

for（int i=0；i=N/2）{
ha12[i][j]=hA[i][j]；
}否则如果（i>=N/2&j=N/2&j>=N/2）为else{
ha22[i][j]=hA[i][j]；//错误！
}
}
}

您的阵列应该是N x N，而不是N/2xN/2

您使用的位运算符&虽然不常见，但很有效。我错误地认为您需要一个逻辑and（&&&）。尽管如此，为了可读性，我还是建议使用&&。你也会短路

    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            printf("\n%d,%d\n", i, j);
            if (i < N / 2 & j < N / 2) {
                ha11[i][j] = hA[i][j];
            } else if (i < N / 2 & j >= N / 2) {
                ha12[i][j] = hA[i][j];
            } else if (i >= N / 2 & j < N / 2) {
                ha21[i][j] = hA[i][j];
            } else if (i >= N / 2 & j >= N / 2) {
                ha22[i][j] = hA[i][j];    //faulty!
            }
        }
    }

for（int i=0；i=N/2）{
ha12[i][j]=hA[i][j]；
}否则如果（i>=N/2&j=N/2&j>=N/2）为else{
ha22[i][j]=hA[i][j]；//错误！
}
}
}

要按编写的方式使用代码，子数组必须是NxN，而不是N/2乘N/2，但我认为这实际上不是“错误”

您将阵列分成4个相等的部分，因此它们应该能够比原始阵列更小。剩下两个问题

你的作业错了，h11没问题，但h12、h21和h22都需要这样调整：

ha12[i-N/2][j-N/2] = hA[i][j];
ha21[i-N/2][j] = hA[i][j];
ha22[i-N/2][j-N/2] = hA[i][j];

而不是你所拥有的（尽管把它们放在那里）

顺便说一句，如果您完全删除if语句，只迭代一个季度，但每季度做4次赋值，那么阅读起来可能会更容易

---

第二，潜在的问题当然是当N不能被2整除时会发生什么。你的代码似乎忽略了这一点，也许它可以。我希望您需要考虑将奇数值放在哪里，并使子数组的大小足以容纳四舍五入的部分。

要按照编写的代码工作，子数组的大小必须是NxN，而不是N/2乘N/2，但我认为这实际上不是“错误”

您将阵列分成4个相等的部分，因此它们应该能够比原始阵列更小。剩下两个问题

你的作业错了，h11没问题，但h12、h21和h22都需要这样调整：

ha12[i-N/2][j-N/2] = hA[i][j];
ha21[i-N/2][j] = hA[i][j];
ha22[i-N/2][j-N/2] = hA[i][j];

而不是你所拥有的（尽管把它们放在那里）

顺便说一句，如果您完全删除if语句，只迭代一个季度，但每季度做4次赋值，那么阅读起来可能会更容易

第二，潜在的问题当然是当N不能被2整除时会发生什么。你的代码似乎忽略了这一点，也许它可以。我希望您需要考虑将奇数值放在哪里，并使每个子数组足够大，以便