Question

我正在尝试解决以下问题：

假设我们有8个8格（当然它可能是一个更大的网格）。

我们将正方形的所有外边界点标记为'n'，并将它们旁边的点标记为't'，其他所有点都为'f'。

我想编写一个流程，通过以下规则将所有点转移为'n'（我需要遵循此规则，因为此问题是更大问题的一部分，而其余部分与我的问题无关）：

我需要按顺序放置所有't'点，并将第一个元素转换为'n'。然后我需要删除已更改为'n'的第一个元素，并将最后一个元素移动到第一个位置。此外，我需要将与更改点相邻的所有“f”点重新标记为“t”，并将它们放在“t”点序列的末尾。我需要继续这个过程，直到没有't'或'f'。

为此，我使用了可变大小的数组，我的代码如下：

>>> s = u'\N{HORIZONTAL ELLIPSIS}'
>>> s
u'\u2026'
>>> print s
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\dev\Python27\lib\encodings\cp437.py", line 12, in encode
    return codecs.charmap_encode(input,errors,encoding_map)
UnicodeEncodeError: 'charmap' codec can't encode character u'\u2026' in position 0: character maps to <undefined>

它在开始时适用于几个循环。但是，经过我的仔细检查，然后循环代码

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

不仅在索引数组'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，则可以避免此错误。

关于C中可变大小的数组

2 个答案: