C++ 在多数组中添加值，但超出范围

我需要计算数组中每个位置周围有多少个1值。我尝试在其周围添加另一层0，如果

r=1

，它将起作用，但无法确定它是在什么时候出现的，例如

r=3

#include <iostream>
#include <time.h>
#include <cstdlib>
using namespace std;

int main() 
{
const int n=10;

int T[n][n]= {
    {1,0,0,0,1,0,1,0,0,1},
    {1,1,0,0,1,0,1,1,1,0},
    {0,1,0,0,1,0,1,0,0,1},
    {0,1,1,0,1,0,1,1,0,1},
    {0,1,0,1,1,0,0,0,0,0},
    {0,1,0,1,1,0,0,0,1,0},
    {1,1,0,0,1,0,0,0,0,1},
    {1,1,1,1,1,0,1,1,0,0},
    {0,1,0,0,1,0,1,0,0,1},
    {1,1,0,0,1,0,0,1,0,1},
};

int TD[14][14]= {0};

for(int i=2; i<12; i++) 
    for(int j=2; j<12; j++)
        TD[i][j]=T[i-2][j-2];

for(int i=0; i<14; i++) 
{
    for(int j=0; j<14; j++)
        cout<<TD[i][j]<<" ";
    cout<<endl;
}

cout<<endl<<endl<<endl;

for(int i=0; i<n; i++) 
{
    for(int j=0; j<n; j++)
        cout<<T[i][j]<<" ";
    cout<<endl;
}

cout<<endl;
cout<<endl;
cout<<endl;

int G[14][14]= {0};

for(int i=0; i<n; i++) 
{
    for(int j=0; j<n; j++)
        cout<<G[i][j]<<" ";
    cout<<endl;
}

cout<<endl;
cout<<endl;
cout<<endl;

int r=1;

for(int i=2; i<13; i++)
    for(int j=2; j<13; j++) 
    {
        for(int ii=i-r; ii<=i+r; ii++)
            for(int jj=j-r; jj<=j+r; jj++)
                G[i][j]=G[i][j]+TD[ii][jj];
    }

for(int i=2; i<12; i++) 
{
    for(int j=2; j<12; j++)
        cout<<G[i][j]<<" ";
    cout<<endl;
}
return 0;   

#包括
#包括
#包括
使用名称空间std；
int main（）
{
常数int n=10；
int T[n][n]={
{1,0,0,0,1,0,1,0,0,1},
{1,1,0,0,1,0,1,1,1,0},
{0,1,0,0,1,0,1,0,0,1},
{0,1,1,0,1,0,1,1,0,1},
{0,1,0,1,1,0,0,0,0,0},
{0,1,0,1,1,0,0,0,1,0},
{1,1,0,0,1,0,0,0,0,1},
{1,1,1,1,1,0,1,1,0,0},
{0,1,0,0,1,0,1,0,0,1},
{1,1,0,0,1,0,0,1,0,1},
};
int TD[14][14]={0}；
对于（int i=2；i当处理在固定的二维单元映射内计数的任何问题时，要确定“邻居”的数量，需要识别和“边界”单元和“内部”单元，然后编写一个围绕每个边界工作的算法，以及迭代每个内部单元

下面的示例首先读取顶部行边界，然后向下向左边界，通过内部，然后右边界，最后是底部行。代码不考虑单元格本身的值（意思是<代码>单元格[i] [j]

从其周围可能的8个单元格中计数，但如果它恰好是

1

，则在确定相邻单元格计数时不包括其自身的值（通过在相邻单元格计数的每个部分激活注释的单元格，您可以根据需要轻松调整此值）

总而言之，您可以执行以下操作：

#include <iostream>
#include <time.h>
#include <cstdlib>

#define n 10

int main (void) {

    int T[][n]= {
        {1,0,0,0,1,0,1,0,0,1},
        {1,1,0,0,1,0,1,1,1,0},
        {0,1,0,0,1,0,1,0,0,1},
        {0,1,1,0,1,0,1,1,0,1},
        {0,1,0,1,1,0,0,0,0,0},
        {0,1,0,1,1,0,0,0,1,0},
        {1,1,0,0,1,0,0,0,0,1},
        {1,1,1,1,1,0,1,1,0,0},
        {0,1,0,0,1,0,1,0,0,1},
        {1,1,0,0,1,0,0,1,0,1},
    },
    nrow = sizeof T / sizeof *T,
    ncol = n,
    neighbors = 0;

    for (int i = 0; i < nrow; i++) {    /* loop over rows */
        for (int j = 0; j < n; j++) {   /* loop over cols */
            if (!i) {       /* index of first row */
                if (!j) {       /* top-left corner */
                    neighbors = /*T[i][j]*/   T[ i ][j+1] + 
                                T[i+1][ j ] + T[i+1][j+1];
                }
                else if (j < ncol - 1) {    /* top-inside row */
                    neighbors = T[ i ][j-1] + /*T[i][j]*/ + T[ i ][j+1] +
                                T[i+1][j-1] + T[i+1][ j ] + T[i+1][j+1];
                }
                else if (j == ncol - 1) {   /* top-right corner */
                    neighbors = T[ i ][j-1] + /*T[i][j]*/ 
                                T[i+1][j-1] + T[i+1][ j ];
                }
            }
            else if (i < nrow - 1) {    /* interior cells */
                if (!j) {       /* left-side vertical */
                    neighbors = T[i-1][ j ] + T[i-1][j+1] +
                                /*T[i][j]*/ + T[ i ][j+1] +
                                T[i+1][ j ] + T[i+1][j+1];
                }
                else if (j < ncol - 1) {    /* inner cells */
                    neighbors = T[i-1][j-1] + T[i][j-1] + T[i+1][j-1] +
                                T[i-1][ j ] + /*T[i][j]*/ T[i+1][ j ] +
                                T[i-1][j+1] + T[i][j+1] + T[i+1][j+1];
                }
                else if (j == ncol - 1) {   /* right-side vertical */
                    neighbors = T[i-1][j-1] + T[i-1][ j ] +
                                T[ i ][j-1] + /*T[i][j]*/
                                T[i+1][j-1] + T[i+1][ j ];
                }
            }
            else if (i == nrow - 1) {   /* last row */
                if (!j) {       /* bottom-left corner */
                    neighbors = T[i-1][ j ] + T[i-1][j+1] +
                                /*T[i][j]*/ + T[ i ][j+1];
                }
                else if (j < ncol - 1) {    /* bottom-inside row */
                    neighbors = T[i-1][j-1] + T[i-1][ j ] + T[i-1][j+1] +
                                T[ i ][j-1] + /*T[i][j]*/ + T[ i ][j+1];
                }
                else if (j == ncol - 1) {   /* bottom-right corner */
                    neighbors = T[i-1][j-1] + T[i-1][ j ] +
                                T[ i ][j-1]   /*T[i][j]*/;
                }
            }
            std::cout << "T[" << i << "][" << j << "]: " << neighbors << '\n';
        }
    }
}

---

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

为什么要声明这么多数组。如果您真的只想计算每个索引的1，您只需要第二个维度相同的数组。问题（或您的问题）到底是什么。我只是将您的代码复制粘贴到IDE中，它运行时没有任何错误…尝试将r变量切换到1以上，它将变成完整的b到wallz。T数组是1和0所在的位置。TD数组是具有扩展边界的数组（另一层为0），我只是在其中敲打了T数组。最后一个用于计算1。问题很简单：“如果r=1，但当r=3时无法计算出来？”如问题开头所述，只需修改代码，使其不会访问超出范围的数组。不要使用12、13等幻数，而是使用常量。

$ ./bin/neighbors
T[0][0]: 2
T[0][1]: 3
T[0][2]: 1
T[0][3]: 2
T[0][4]: 1
T[0][5]: 4
T[0][6]: 2
T[0][7]: 4
T[0][8]: 3
T[0][9]: 1
T[1][0]: 3
T[1][1]: 3
T[1][2]: 2
T[1][3]: 3
T[1][4]: 2
T[1][5]: 6
T[1][6]: 3
T[1][7]: 4
T[1][8]: 3
T[1][9]: 3
...
T[8][0]: 5
T[8][1]: 5
T[8][2]: 5
T[8][3]: 5
T[8][4]: 3
T[8][5]: 5
T[8][6]: 3
T[8][7]: 4
T[8][8]: 4
T[8][9]: 1
T[9][0]: 2
T[9][1]: 2
T[9][2]: 2
T[9][3]: 2
T[9][4]: 1
T[9][5]: 3
T[9][6]: 2
T[9][7]: 1
T[9][8]: 3
T[9][9]: 1