编译器无法捕获条件块中的变量重定义

Question

int bar = 2;
if (bar)
{
   int bar;
}

gcc或Clang都没有设法为此发出警告（或错误），程序在启动时立即崩溃。 有这么好的理由吗？ 看起来似乎并不难以捕捉到。 这是块作用域的基础：嵌套作用域继承了封闭块的名称......

有什么解释吗？

编辑：事实证明崩溃是由于使用Clang。 我来回测试了很多次，似乎可以确定变量重定义和Clang的组合会导致崩溃。 但是，我无法在测试项目中重现崩溃，所以请参考。

问题结果与Objective-C相关。 正如Jonathan Leffler所指出的那样，在内部范围内执行'int bar = bar'会从自身初始化变量，这就是导致问题的原因，当初始化是通过Objective-C方法调用完成的。

以下显示了操作中的错误：

-(void)crasher
{
   NSNumber* bar = [NSNumber numberWithInt:2];
   if (bar)
   {
      NSString* bar = [self doit:bar];
   }
}

-(NSString*)doit:(NSNumber*)num
{
   NSString* str = [num stringValue];   // This line causes the crash
   return str;
}

请注意，在纯C中执行类似的操作不会导致崩溃：

int bar = 2;
if (bar)
{
   char buff[10];
   int bar = sprintf(buff, "%d",bar);       
}

Answer 1

这里没什么好抓的。 内部块中的变量是一个完全不同的变量，它将变量隐藏在外部块中。 这是从一开始就存在的语言的完美标准特征。

您遇到的崩溃与您发布的代码完全无关。 除非你在代码中犯了错误，否则在假设你正在处理外部变量时使用内部变量。

Answer 2

它是嵌套作用域的基础：在嵌套作用域内，您可以隐藏在外部作用域中声明的内容。 gcc有一个选项来获取此警告（-Wshadow），但它不会被-Wall和-Wextra激活：警告可以在不改变代码的情况下出现（标题现在在全局范围内有一个定义函数中使用的标识符）。

Answer 3

$ gcc 1.c

$ gcc -Wall 1.c
1.c: In function ‘main’:
1.c:6: warning: unused variable ‘bar’

$ cat 1.c
int main()
{
    int bar = 2;
    if (bar)
    {
        int bar;
    }
    return 0;
}

$ ./a.out ; echo $?
0

为我编译 - 在-Wall下发出警告。 程序运行正常。

你已经声明了两个变量，一个叫做bar ，另一个叫做bar 。 编译器不关心，只要它们在不同的范围内。

Answer 4

它也是块作用域的基础，从内部作用域中的外部作用域重新定义名称不是错误 - 这是正常的和预期的。 否则，基本上会让我们回到过去只有全局变量的古代BASIC方言的糟糕时期。

Answer 5

扩展Douglas Leeder给出的答案：

#include <stdio.h>
static int xx(int foo)
{
    int bar = 2;
    if (foo > bar)
    {
        int foo = bar;
        int bar = bar;
        printf("inner: foo = %d, bar = %d\n", foo, bar);
    }
    printf("outer: foo = %d, bar = %d\n", foo, bar);
    return bar;
}
int main(void)
{
    xx(13);
    return(0);
}

请注意，内部条是从自身初始化的 - 这会给出未定义的行为。 但是在MacOS X 10.6.2（GCC 4.2.1）上，我得到：

inner: foo = 2, bar = 0
outer: foo = 13, bar = 2

---

变式1：堆栈践踏 - A.

有趣的是，无论我在a之前还是之后声明i ，我都会从这段代码获得相同的输出，具有堆栈践踏功能。

inner: foo = 2, bar = 20
outer: foo = 13, bar = 2

码：

#include <stdio.h>
static void modify_stack(void)
{
    int a[20];
    int i;
    for (i = 0; i < 20; i++)
    {
        a[i] = 0xFFFFFFFF ^ i;
        printf("a[i] = 0x%08X\n", a[i]);
    }
}
static int xx(int foo)
{
    int bar = 2;
    if (foo > bar)
    {
        int foo = bar;
        int bar = bar;
        printf("inner: foo = %d, bar = %d\n", foo, bar);
    }
    printf("outer: foo = %d, bar = %d\n", foo, bar);
    return bar;
}
int main(void)
{
    modify_stack();
    xx(13);
    return(0);
}

由于行为未定义，因此结果很好。

变式2：堆栈践踏 - B.

#include <stdio.h>
static int modify_stack(void)
{
    int a[20];
    int i;
    for (i = 0; i < 20; i++)
    {
        a[i] = 0xFFFFFFFF ^ i;
        printf("a[i] = 0x%08X\n", a[i]);
    }
    i = a[13];
    return(i);
}
static int xx(int foo)
{
    int bar = 2;
    if (foo > bar)
    {
        int foo = bar;
        int bar = bar;
        printf("inner: foo = %d, bar = %d\n", foo, bar);
    }
    printf("outer: foo = %d, bar = %d\n", foo, bar);
    return bar;
}
int main(void)
{
    int i = modify_stack();
    xx(13);
    return(i & 0xFF);
}

输出（除了循环打印的数据）：

inner: foo = 2, bar = -14
outer: foo = 13, bar = 2