關於C中具有可變大小的數組

Question

我正在嘗試解決以下問題：

假設我們有一個8乘8的網格（當然它可以是一個更大的網格）。

我們將正方形的所有外邊界點標記為“ n”，並將與它們相鄰的點標記為“ t”，所有其他點為“ f”。

我想編寫一個過程，按照以下規則將所有點都轉移為“ n”（我需要遵循此規則，因為此問題是一個較大問題的一部分，而其余部分與此處的問題無關）：

我需要按順序排列所有“ t”點，並將第一個元素轉換為“ n”。 然后，我需要刪除已更改為“ n”的第一個元素，並將最后一個元素移到第一個位置。 另外，我需要將與更改點相鄰的所有“ f”點重新標記為“ t”，並將它們放置在“ t”點序列的末尾。 我需要繼續此過程，直到沒有't'或'f'。

為此，我使用了可變大小的數組，我的代碼如下：

int i,j;
char c[n+1][n+1];
int count=0;
int newi[4];
int newj[4];
int ind;
//initialization
for(i=0; i<n+1;i++){
    for(j=0;j<n+1;j++){
        if(i==0||j==0||i==n||j==n){
            c[i][j]='n';           //tagged as newly known
        }
        else if(i==1||j==1||i==n-1||j==n-1){
            c[i][j]='t';               //trial points
        }
        else{
            c[i][j]='f';               //far away points
        }
    }
}
for(i=0; i<n+1;i++){
    for(j=0;j<n+1;j++){
        if(c[i][j]=='t'){
            count=count+1;           //count is number of 't'
        }
    }
}

int ri[count]; //array that stores the row index of trial points;
int ci[count]; //array that stores the column index of trial points;
int k=0;
for(i=0; i<n+1;i++){
    for(j=0;j<n+1;j++){
        if(c[i][j]=='t'){
            ri[k]=i;
            ci[k]=j;
            k=k+1;
        }
    }
}
while(count>0){
    int num=0;
    i=ri[0];
    j=ci[0];
    c[i][j]='n';
    ri[0]=ri[count-1];
    ci[0]=ci[count-1];
    count--;
    int newcount=0;
    if(c[i-1][j]=='f'){
        c[i-1][j]='t';
        newcount++;
        newi[newcount-1]=i-1;
        newj[newcount-1]=j;
    }
    if(c[i+1][j]=='f'){
        c[i+1][j]='t';
        newcount++;
        newi[newcount-1]=i+1;
        newj[newcount-1]=j;
    }
    if(c[i][j-1]=='f'){
        c[i][j-1]='t';
        newcount++;
        newi[newcount-1]=i;
        newj[newcount-1]=j-1;
    }
    if(c[i][j+1]=='f'){
        c[i][j+1]='t';
        newcount++;
        newi[newcount-1]=i;
        newj[newcount-1]=j+1;
    }
   count=count+newcount;
    for(ind=count-newcount;ind<count;ind++)/////
    {
        ri[ind]=newi[ind-count+newcount];
        ci[ind]=newj[ind-count+newcount];
    } 
}

一開始它可以很好地用於幾個循環。 但是，在我仔細檢查之后，然后循環執行代碼

for(ind=count-newcount;ind<count;ind++)/////
    {
        ri[ind]=newi[ind-count+newcount];
        ci[ind]=newj[ind-count+newcount];
    }

不僅將新元素添加到索引數組“ ri”和“ ci”的末尾，而且還更改了“ ri”的第一個元素，然后將所有內容弄亂了。

我的問題是這是怎么發生的。 這是由於使用可變長度的數組引起的問題嗎？ 我應該避免使用可變長度的數組嗎？

Answer 1

您似乎誤解了VLA。 這並不意味着數組的大小可能會有所不同，但是您可以動態決定數組的大小是多少（但是大小固定一次）。

您要在ri和ci中添加更多元素，而無需重新分配它們。我建議您先使用動態分配：

int *ri = calloc(sizeof(int),count); //array that stores the row index of trial points;
if (ri==NULL) { /* error */ }
int *ci = calloc(sizeof(int),count);
if (ci==NULL) { /* error */ }

然后在問題循環之前添加兩行，如下所示：

int *ri2 = realloc(ri,count*sizeof(int));
if (ri2==NULL) { /* error */ }
ri = ri2;
int *ci2 = realloc(ci,count*sizeof(int));
if (ci2==NULL) { /* error */ }
ci = ci2;

在這部分代碼之間， count可能會改變！

-編輯-

您還需要注意Alex的答案...

Answer 2

是的，這就是導致問題的原因。 盡管您還沒有說出n是什么，所以其他發帖人回答中描述的問題也可能適用； 但是，您發布的代碼中也存在問題。

當你說像

c[i][j+1]='t';

如果i == n ，則

c[i][j+1] = c[i][n+1] = c[i+1][0]

這是因為您的數組是n+1 x n+1 ，所以每次訪問n+1 -st條目時，它都會溢出到下一個索引中。

如果在嘗試設置值之前檢查i == n ，那么可以避免此錯誤。